This is an automated email from the ASF dual-hosted git repository.
klund pushed a commit to branch
GEODE-7513-PersistentColocatedPartitionedRegionDistributedTest-debugging
in repository https://gitbox.apache.org/repos/asf/geode.git
commit 4f3a001ff9a886981246d5a91c1a6a22b037337e
Author: Darrel Schneider <dschnei...@pivotal.io>
AuthorDate: Mon Feb 24 15:40:15 2020 -0800
GEODE-7803: provide undeprecated internal region create (#4722)
You can now use InternalRegionFactory to create a region configured with
InternalRegionArguments. No need to use the deprecated AttributesFactory.
InternalRegionFactory used to be named RegionFactoryImpl.
---
.../geode/modules/util/CreateRegionFunction.java | 37 +---
.../geode/cache30/TXDistributedDUnitTest.java | 36 +--
...ingGiiOplogWithMissingCreateRegressionTest.java | 23 +-
.../GiiDiskAccessExceptionRegressionTest.java | 28 +--
.../LRUClearWithDiskRegionOpRegressionTest.java | 11 +-
.../apache/geode/internal/cache/PRTXJUnitTest.java | 14 +-
.../apache/geode/cache/DynamicRegionFactory.java | 50 ++---
.../java/org/apache/geode/cache/RegionFactory.java | 20 +-
.../org/apache/geode/cache/RegionShortcut.java | 21 +-
.../InternalConfigurationPersistenceService.java | 23 +-
.../admin/ClientHealthMonitoringRegion.java | 18 +-
.../geode/internal/cache/CacheFactoryStatics.java | 2 +-
.../geode/internal/cache/CacheServerImpl.java | 33 +--
.../geode/internal/cache/GemFireCacheImpl.java | 8 +-
.../apache/geode/internal/cache/InternalCache.java | 9 +
.../internal/cache/InternalRegionArguments.java | 3 +
.../internal/cache/InternalRegionFactory.java | 242 +++++++++++++++++++++
.../internal/cache/PartitionedRegionHelper.java | 22 +-
.../geode/internal/cache/RegionFactoryImpl.java | 74 -------
.../internal/cache/wan/AbstractGatewaySender.java | 24 +-
.../wan/parallel/ParallelGatewaySenderQueue.java | 115 +++++-----
.../cache/wan/serial/SerialGatewaySenderQueue.java | 50 ++---
.../internal/cache/xmlcache/CacheCreation.java | 10 +-
.../management/internal/FederatingManager.java | 61 ++----
.../geode/management/internal/LocalManager.java | 57 ++---
.../geode/management/internal/RestAgent.java | 34 +--
.../operation/RegionOperationStateStore.java | 16 +-
.../geode/pdx/internal/PeerTypeRegistration.java | 25 +--
.../internal/SerialAsyncEventQueueImplTest.java | 6 +-
...mplTest.java => InternalRegionFactoryTest.java} | 46 +++-
.../ParallelGatewaySenderQueueJUnitTest.java | 5 +-
.../management/internal/FederatingManagerTest.java | 46 ++--
.../management/internal/LocalManagerTest.java | 43 ++--
.../operation/RegionOperationStateStoreTest.java | 6 +-
.../pdx/internal/PeerTypeRegistrationTest.java | 18 +-
.../commands/ExportLogsDistributedTestBase.java | 2 +-
.../experimental/driver/AuthorizationTest.java | 20 +-
.../ExportLogsFunctionIntegrationTest.java | 4 +-
.../internal/cli/functions/ExportLogsFunction.java | 25 +--
.../PartitionedRepositoryManagerJUnitTest.java | 5 +-
.../org/apache/geode/redis/GeodeRedisServer.java | 50 ++---
41 files changed, 683 insertions(+), 659 deletions(-)
diff --git
a/extensions/geode-modules/src/main/java/org/apache/geode/modules/util/CreateRegionFunction.java
b/extensions/geode-modules/src/main/java/org/apache/geode/modules/util/CreateRegionFunction.java
index 70967e4..f4ca315 100644
---
a/extensions/geode-modules/src/main/java/org/apache/geode/modules/util/CreateRegionFunction.java
+++
b/extensions/geode-modules/src/main/java/org/apache/geode/modules/util/CreateRegionFunction.java
@@ -24,23 +24,20 @@ import java.util.Collection;
import java.util.Collections;
import org.apache.geode.DataSerializable;
-import org.apache.geode.InternalGemFireError;
-import org.apache.geode.cache.Cache;
-import org.apache.geode.cache.CacheFactory;
-import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.Declarable;
import org.apache.geode.cache.EvictionAction;
import org.apache.geode.cache.EvictionAttributes;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionAttributes;
-import org.apache.geode.cache.Scope;
+import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.execute.Function;
import org.apache.geode.cache.execute.FunctionContext;
import org.apache.geode.cache.partition.PartitionRegionHelper;
import org.apache.geode.distributed.DistributedLockService;
import org.apache.geode.distributed.internal.locks.DistributedMemberLock;
-import org.apache.geode.internal.cache.GemFireCacheImpl;
-import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.CacheFactoryStatics;
+import org.apache.geode.internal.cache.InternalCache;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.PartitionedRegion;
import org.apache.geode.internal.cache.xmlcache.CacheXmlGenerator;
import org.apache.geode.internal.cache.xmlcache.RegionAttributesCreation;
@@ -55,11 +52,11 @@ public class CreateRegionFunction implements Function,
Declarable, DataSerializa
static final String REGION_CONFIGURATION_METADATA_REGION =
"__regionConfigurationMetadata";
- private final Cache cache;
+ private final InternalCache cache;
private final Region<String, RegionConfiguration> regionConfigurationsRegion;
public CreateRegionFunction() {
- this.cache = CacheFactory.getAnyInstance();
+ this.cache = CacheFactoryStatics.getAnyInstance();
this.regionConfigurationsRegion =
createRegionConfigurationMetadataRegion();
}
@@ -251,7 +248,6 @@ public class CreateRegionFunction implements Function,
Declarable, DataSerializa
PartitionRegionHelper.assignBucketsToPartitions(region);
}
- @SuppressWarnings("unchecked")
private Region<String, RegionConfiguration>
createRegionConfigurationMetadataRegion() {
// a sessionFactory in hibernate could have been re-started
// so, it is possible that this region exists already
@@ -262,22 +258,11 @@ public class CreateRegionFunction implements Function,
Declarable, DataSerializa
return region;
}
- GemFireCacheImpl gemFireCache = (GemFireCacheImpl) cache;
- InternalRegionArguments ira = new
InternalRegionArguments().setInternalRegion(true);
- RegionAttributesCreation regionAttributesCreation = new
RegionAttributesCreation();
- regionAttributesCreation.setScope(Scope.DISTRIBUTED_ACK);
- regionAttributesCreation.setDataPolicy(DataPolicy.REPLICATE);
- regionAttributesCreation.addCacheListener(new
RegionConfigurationCacheListener());
-
- try {
- return gemFireCache.createVMRegion(REGION_CONFIGURATION_METADATA_REGION,
- regionAttributesCreation, ira);
- } catch (IOException | ClassNotFoundException e) {
- InternalGemFireError assErr = new InternalGemFireError("unexpected
exception");
- assErr.initCause(e);
-
- throw assErr;
- }
+ InternalRegionFactory<String, RegionConfiguration> regionFactory =
+ cache.createInternalRegionFactory(RegionShortcut.REPLICATE);
+ regionFactory.addCacheListener(new RegionConfigurationCacheListener());
+ regionFactory.setInternalRegion(true);
+ return regionFactory.create(REGION_CONFIGURATION_METADATA_REGION);
}
private void writeCacheXml() {
diff --git
a/geode-core/src/distributedTest/java/org/apache/geode/cache30/TXDistributedDUnitTest.java
b/geode-core/src/distributedTest/java/org/apache/geode/cache30/TXDistributedDUnitTest.java
index afe88f1..4b1958b 100644
---
a/geode-core/src/distributedTest/java/org/apache/geode/cache30/TXDistributedDUnitTest.java
+++
b/geode-core/src/distributedTest/java/org/apache/geode/cache30/TXDistributedDUnitTest.java
@@ -33,7 +33,6 @@ import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.io.IOException;
import java.io.Serializable;
import java.util.HashSet;
import java.util.List;
@@ -59,7 +58,6 @@ import org.apache.geode.cache.Operation;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.Scope;
-import org.apache.geode.cache.TimeoutException;
import org.apache.geode.distributed.internal.ResourceEvent;
import org.apache.geode.distributed.internal.ResourceEventsListener;
import org.apache.geode.distributed.internal.locks.DLockBatch;
@@ -68,7 +66,7 @@ import
org.apache.geode.distributed.internal.membership.InternalDistributedMembe
import
org.apache.geode.distributed.internal.membership.api.MembershipManagerHelper;
import org.apache.geode.internal.cache.CommitReplyException;
import org.apache.geode.internal.cache.GemFireCacheImpl;
-import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.LocalRegion;
import org.apache.geode.internal.cache.RegionEntry;
import org.apache.geode.internal.cache.TXManagerImpl;
@@ -1434,27 +1432,17 @@ public class TXDistributedDUnitTest extends
JUnit4CacheTestCase {
new CacheSerializableRunnable("Initialize regions that cause
trouble") {
@Override
public void run2() {
- GemFireCacheImpl gfc = (GemFireCacheImpl) getCache();
- InternalRegionArguments ira =
- new InternalRegionArguments().setTestCallable(new
TXTroubleMaker());
- try {
- getCache().createDiskStoreFactory().setDiskDirs(getDiskDirs())
- .create(diskStoreName);
- TXManagerImpl.ALLOW_PERSISTENT_TRANSACTIONS = true;
- AttributesFactory af = new AttributesFactory();
- af.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
- af.setScope(Scope.DISTRIBUTED_ACK);
- af.setDiskStoreName(diskStoreName);
- gfc.createVMRegion(rgnName1, af.create(), ira);
- gfc.createVMRegion(rgnName2, af.create(), ira);
- gfc.getInternalDistributedSystem().addResourceListener(new
ShutdownListener());
- } catch (IOException ioe) {
- fail(ioe.toString());
- } catch (TimeoutException e) {
- fail(e.toString());
- } catch (ClassNotFoundException e) {
- fail(e.toString());
- }
+ getCache().createDiskStoreFactory().setDiskDirs(getDiskDirs())
+ .create(diskStoreName);
+ TXManagerImpl.ALLOW_PERSISTENT_TRANSACTIONS = true;
+ InternalRegionFactory factory =
getCache().createInternalRegionFactory();
+ factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
+ factory.setScope(Scope.DISTRIBUTED_ACK);
+ factory.setDiskStoreName(diskStoreName);
+ factory.setTestCallable(new TXTroubleMaker());
+ factory.create(rgnName1);
+ factory.create(rgnName2);
+
getCache().getInternalDistributedSystem().addResourceListener(new
ShutdownListener());
}
};
trouble1.invoke(initTroulbeRegions);
diff --git
a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/ClearDuringGiiOplogWithMissingCreateRegressionTest.java
b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/ClearDuringGiiOplogWithMissingCreateRegressionTest.java
index 1d70bfd..d11cf9f 100644
---
a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/ClearDuringGiiOplogWithMissingCreateRegressionTest.java
+++
b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/ClearDuringGiiOplogWithMissingCreateRegressionTest.java
@@ -31,6 +31,7 @@ import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.DiskStore;
import org.apache.geode.cache.DiskStoreFactory;
import org.apache.geode.cache.Region;
+import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.Scope;
import
org.apache.geode.internal.cache.entries.VersionedThinDiskRegionEntryHeapObjectKey;
import org.apache.geode.test.dunit.VM;
@@ -140,22 +141,22 @@ public class
ClearDuringGiiOplogWithMissingCreateRegressionTest extends CacheTes
DiskStore diskStore = dsf.create(uniqueName);
- AttributesFactory factory = new AttributesFactory();
- factory.setScope(Scope.DISTRIBUTED_ACK);
- factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
+ InternalRegionFactory factory =
+
getCache().createInternalRegionFactory(RegionShortcut.REPLICATE_PERSISTENT);
factory.setDiskSynchronous(false);
factory.setDiskStoreName(diskStore.getName());
- DistributedRegion distRegion = new DistributedRegion(regionName,
factory.create(), null,
- getCache(), new
InternalRegionArguments().setDestroyLockFlag(true).setRecreateFlag(false)
- .setSnapshotInputStream(null).setImageTarget(null),
- disabledClock());
+ DistributedRegion distRegion =
+ new DistributedRegion(regionName, factory.getCreateAttributes(), null,
+ getCache(),
+ new
InternalRegionArguments().setDestroyLockFlag(true).setRecreateFlag(false)
+ .setSnapshotInputStream(null).setImageTarget(null),
+ disabledClock());
distRegion.entries.setEntryFactory(new TestableDiskRegionEntryFactory());
-
- getCache().createVMRegion(regionName, factory.create(),
- new
InternalRegionArguments().setInternalMetaRegion(distRegion).setDestroyLockFlag(true)
- .setSnapshotInputStream(null).setImageTarget(null));
+ factory.setInternalMetaRegion(distRegion).setDestroyLockFlag(true)
+ .setSnapshotInputStream(null).setImageTarget(null);
+ factory.create(regionName);
}
/**
diff --git
a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/GiiDiskAccessExceptionRegressionTest.java
b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/GiiDiskAccessExceptionRegressionTest.java
index 0a011e7..d2d4512 100644
---
a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/GiiDiskAccessExceptionRegressionTest.java
+++
b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/GiiDiskAccessExceptionRegressionTest.java
@@ -110,13 +110,13 @@ public class GiiDiskAccessExceptionRegressionTest extends
CacheTestCase {
DiskStore diskStore = diskStoreFactory.create(uniqueName);
- AttributesFactory factory = new AttributesFactory();
+ InternalRegionFactory factory = getCache().createInternalRegionFactory();
factory.setScope(Scope.DISTRIBUTED_ACK);
factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
factory.setDiskSynchronous(false);
factory.setDiskStoreName(diskStore.getName());
- Region<Integer, Integer> region = getCache().createRegion(uniqueName,
factory.create());
+ Region<Integer, Integer> region = factory.create(uniqueName);
// Now put entries in the disk region
for (int i = 0; i < 100; ++i) {
@@ -129,22 +129,22 @@ public class GiiDiskAccessExceptionRegressionTest extends
CacheTestCase {
// Now recreate the region but set the factory such that disk region entry
object
// used is customized by us to throw exception while writing to disk
- DistributedRegion distributedRegion = new DistributedRegion(uniqueName,
factory.create(), null,
- getCache(), new
InternalRegionArguments().setDestroyLockFlag(true).setRecreateFlag(false)
- .setSnapshotInputStream(null).setImageTarget(null),
- disabledClock());
+ DistributedRegion distributedRegion =
+ new DistributedRegion(uniqueName, factory.getCreateAttributes(), null,
+ getCache(),
+ new
InternalRegionArguments().setDestroyLockFlag(true).setRecreateFlag(false)
+ .setSnapshotInputStream(null).setImageTarget(null),
+ disabledClock());
distributedRegion.entries.setEntryFactory(new
DiskRegionEntryThrowsFactory());
- InternalRegionArguments internalRegionArguments = new
InternalRegionArguments();
- internalRegionArguments.setInternalMetaRegion(distributedRegion);
- internalRegionArguments.setDestroyLockFlag(true);
- internalRegionArguments.setSnapshotInputStream(null);
- internalRegionArguments.setImageTarget(null);
+ factory.setInternalMetaRegion(distributedRegion);
+ factory.setDestroyLockFlag(true);
+ factory.setSnapshotInputStream(null);
+ factory.setImageTarget(null);
- assertThatThrownBy(
- () -> getCache().createVMRegion(uniqueName, factory.create(),
internalRegionArguments))
- .isInstanceOf(DiskAccessException.class);
+ assertThatThrownBy(() -> factory.create(uniqueName))
+ .isInstanceOf(DiskAccessException.class);
}
/**
diff --git
a/geode-core/src/integrationTest/java/org/apache/geode/internal/cache/LRUClearWithDiskRegionOpRegressionTest.java
b/geode-core/src/integrationTest/java/org/apache/geode/internal/cache/LRUClearWithDiskRegionOpRegressionTest.java
index 70812c4..3a2e3de 100644
---
a/geode-core/src/integrationTest/java/org/apache/geode/internal/cache/LRUClearWithDiskRegionOpRegressionTest.java
+++
b/geode-core/src/integrationTest/java/org/apache/geode/internal/cache/LRUClearWithDiskRegionOpRegressionTest.java
@@ -26,7 +26,6 @@ import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.rules.TestName;
-import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.CacheFactory;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.DiskStoreFactory;
@@ -63,7 +62,7 @@ public class LRUClearWithDiskRegionOpRegressionTest {
cache = (InternalCache) new CacheFactory().set("locators",
"").set("mcast-port", "0").create();
- AttributesFactory<Integer, Integer> factory = new AttributesFactory();
+ InternalRegionFactory<Integer, Integer> factory =
cache.createInternalRegionFactory();
DiskStoreFactory diskStoreFactory = cache.createDiskStoreFactory();
diskStoreFactory.setDiskDirsAndSizes(new File[] {dir}, new int[]
{Integer.MAX_VALUE});
@@ -78,7 +77,7 @@ public class LRUClearWithDiskRegionOpRegressionTest {
factory.setEvictionAttributes(
EvictionAttributes.createLRUEntryAttributes(1,
EvictionAction.OVERFLOW_TO_DISK));
- RegionAttributes<Integer, Integer> regionAttributes = factory.create();
+ RegionAttributes<Integer, Integer> regionAttributes =
factory.getCreateAttributes();
InternalRegionArguments args = new
InternalRegionArguments().setDestroyLockFlag(true)
.setRecreateFlag(false).setSnapshotInputStream(null).setImageTarget(null);
@@ -86,9 +85,9 @@ public class LRUClearWithDiskRegionOpRegressionTest {
DistributedRegion distributedRegion =
new DistributedRegion(regionName, regionAttributes, null, cache, args,
disabledClock());
- region = cache.createVMRegion(regionName, regionAttributes,
- new InternalRegionArguments().setInternalMetaRegion(distributedRegion)
-
.setDestroyLockFlag(true).setSnapshotInputStream(null).setImageTarget(null));
+ factory.setInternalMetaRegion(distributedRegion)
+
.setDestroyLockFlag(true).setSnapshotInputStream(null).setImageTarget(null);
+ region = factory.create(regionName);
}
@After
diff --git
a/geode-core/src/integrationTest/java/org/apache/geode/internal/cache/PRTXJUnitTest.java
b/geode-core/src/integrationTest/java/org/apache/geode/internal/cache/PRTXJUnitTest.java
index b0bc5d9..8900ebe 100644
---
a/geode-core/src/integrationTest/java/org/apache/geode/internal/cache/PRTXJUnitTest.java
+++
b/geode-core/src/integrationTest/java/org/apache/geode/internal/cache/PRTXJUnitTest.java
@@ -34,15 +34,17 @@ public class PRTXJUnitTest extends TXJUnitTest {
@Override
protected void createRegion() throws Exception {
- AttributesFactory attributesFactory = new AttributesFactory();
+ InternalRegionFactory regionFactory = cache.createInternalRegionFactory();
// test validation expects this behavior
- attributesFactory.setConcurrencyChecksEnabled(false);
- attributesFactory
+ regionFactory.setConcurrencyChecksEnabled(false);
+ regionFactory
.setPartitionAttributes(new
PartitionAttributesFactory().setTotalNumBuckets(3).create());
+ regionFactory.setDestroyLockFlag(true).setRecreateFlag(false)
+ .setSnapshotInputStream(null).setImageTarget(null);
- this.region = new PRWithLocalOps(getClass().getSimpleName(),
attributesFactory.create(), null,
- this.cache, new
InternalRegionArguments().setDestroyLockFlag(true).setRecreateFlag(false)
- .setSnapshotInputStream(null).setImageTarget(null));
+ this.region =
+ new PRWithLocalOps(getClass().getSimpleName(),
regionFactory.getCreateAttributes(), null,
+ this.cache, regionFactory.getInternalRegionArguments());
((PartitionedRegion) this.region).initialize(null, null, null);
((PartitionedRegion) this.region).postCreateRegion();
diff --git
a/geode-core/src/main/java/org/apache/geode/cache/DynamicRegionFactory.java
b/geode-core/src/main/java/org/apache/geode/cache/DynamicRegionFactory.java
index c145a37..9b00cda 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/DynamicRegionFactory.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/DynamicRegionFactory.java
@@ -15,7 +15,6 @@
package org.apache.geode.cache;
import java.io.File;
-import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
@@ -24,7 +23,6 @@ import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
-import org.apache.geode.InternalGemFireError;
import org.apache.geode.SystemFailure;
import org.apache.geode.annotations.internal.MakeNotStatic;
import org.apache.geode.cache.client.Pool;
@@ -44,6 +42,7 @@ import org.apache.geode.internal.cache.InitialImageOperation;
import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.cache.InternalRegion;
import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.LocalRegion;
import org.apache.geode.internal.cache.RegionEntry;
import org.apache.geode.internal.cache.RegionEventImpl;
@@ -246,21 +245,21 @@ public abstract class DynamicRegionFactory {
this.dynamicRegionList = theCache.getRegion(DYNAMIC_REGION_LIST_NAME);
final boolean isClient = this.config.getPoolName() != null;
if (this.dynamicRegionList == null) {
- InternalRegionArguments ira = new
InternalRegionArguments().setDestroyLockFlag(true)
-
.setInternalRegion(true).setSnapshotInputStream(null).setImageTarget(null);
- AttributesFactory af = new AttributesFactory();
+ InternalRegionFactory factory = cache.createInternalRegionFactory();
+
factory.setDestroyLockFlag(true).setInternalRegion(true).setSnapshotInputStream(null)
+ .setImageTarget(null);
if (this.config.getPersistBackup()) {
- af.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
- af.setDiskWriteAttributes(new DiskWriteAttributesFactory().create());
+ factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
+ factory.setDiskWriteAttributes(new
DiskWriteAttributesFactory().create());
if (this.config.getDiskDir() != null) {
- af.setDiskDirs(new File[] {this.config.getDiskDir()});
+ factory.setDiskDirs(new File[] {this.config.getDiskDir()});
}
}
if (isClient) {
- af.setScope(Scope.LOCAL);
- af.setDataPolicy(DataPolicy.NORMAL);
- af.setStatisticsEnabled(true);
+ factory.setScope(Scope.LOCAL);
+ factory.setDataPolicy(DataPolicy.NORMAL);
+ factory.setStatisticsEnabled(true);
String cpName = this.config.getPoolName();
if (cpName != null) {
Pool cp = PoolManager.find(cpName);
@@ -273,38 +272,27 @@ public abstract class DynamicRegionFactory {
throw new IllegalStateException(
"The client pool of a DynamicRegionFactory must be
configured with queue-enabled set to true.");
}
- af.setPoolName(cpName);
+ factory.setPoolName(cpName);
}
}
- ira.setInternalMetaRegion(new LocalMetaRegion(af.create(), ira));
+ factory.setInternalMetaRegion(new
LocalMetaRegion(factory.getCreateAttributes(),
+ factory.getInternalRegionArguments()));
} else {
- af.setScope(Scope.DISTRIBUTED_ACK);
- af.setValueConstraint(DynamicRegionAttributes.class);
+ factory.setScope(Scope.DISTRIBUTED_ACK);
+ factory.setValueConstraint(DynamicRegionAttributes.class);
if (!this.config.getPersistBackup()) { // if persistBackup, the data
policy has already
// been set
- af.setDataPolicy(DataPolicy.REPLICATE);
+ factory.setDataPolicy(DataPolicy.REPLICATE);
}
for (GatewaySender gs : this.cache.getGatewaySenders()) {
if (!gs.isParallel())
- af.addGatewaySenderId(gs.getId());
+ factory.addGatewaySenderId(gs.getId());
}
- ira.setInternalMetaRegion(new DistributedMetaRegion(af.create()));
// bug fix 35432
- }
-
- try {
- this.dynamicRegionList =
- theCache.createVMRegion(DYNAMIC_REGION_LIST_NAME, af.create(),
ira);
- } catch (IOException e) {
- // only if loading snapshot, not here
- throw new InternalGemFireError(
- "unexpected exception", e);
- } catch (ClassNotFoundException e) {
- // only if loading snapshot, not here
- throw new InternalGemFireError(
- "unexpected exception", e);
+ factory.setInternalMetaRegion(new
DistributedMetaRegion(factory.getCreateAttributes()));
}
+ this.dynamicRegionList = factory.create(DYNAMIC_REGION_LIST_NAME);
if (isClient) {
this.dynamicRegionList.registerInterest("ALL_KEYS");
}
diff --git a/geode-core/src/main/java/org/apache/geode/cache/RegionFactory.java
b/geode-core/src/main/java/org/apache/geode/cache/RegionFactory.java
index 7f4451b..bd5562b 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/RegionFactory.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/RegionFactory.java
@@ -108,8 +108,8 @@ public class RegionFactory<K, V> {
*/
@VisibleForTesting
protected RegionFactory(RegionFactory<K, V> regionFactory) {
- this.attrsFactory = new
AttributesFactory<>(regionFactory.attrsFactory.create());
- this.cache = regionFactory.cache;
+ this.attrsFactory = new
AttributesFactory<>(regionFactory.getRegionAttributes());
+ this.cache = regionFactory.getCache();
}
/**
@@ -244,10 +244,10 @@ public class RegionFactory<K, V> {
}
/**
- * Returns the Region attributes used by this Region factory.
+ * Returns the attributes used by this factory to create a region.
*/
protected RegionAttributes<K, V> getRegionAttributes() {
- return this.attrsFactory.create();
+ return attrsFactory.create();
}
/**
@@ -767,12 +767,10 @@ public class RegionFactory<K, V> {
* region in another cache in the distributed system (see {@link
AttributesFactory} for
* compatibility rules)
*/
- @SuppressWarnings("unchecked")
+ @SuppressWarnings("deprecation")
public Region<K, V> create(String name)
throws CacheExistsException, RegionExistsException,
CacheWriterException, TimeoutException {
- @SuppressWarnings("deprecation")
- RegionAttributes<K, V> ra = this.attrsFactory.create();
- return getCache().createRegion(name, ra);
+ return getCache().createRegion(name, getRegionAttributes());
}
/**
@@ -789,12 +787,10 @@ public class RegionFactory<K, V> {
* @throws CacheClosedException if the cache is closed
* @since GemFire 7.0
*/
- @SuppressWarnings("unchecked")
+ @SuppressWarnings({"deprecation", "unchecked"})
public Region<K, V> createSubregion(Region<?, ?> parent, String name)
throws RegionExistsException {
- @SuppressWarnings("deprecation")
- RegionAttributes<K, V> ra = this.attrsFactory.create();
- return ((InternalRegion) parent).createSubregion(name, ra);
+ return ((InternalRegion) parent).createSubregion(name,
getRegionAttributes());
}
/**
diff --git
a/geode-core/src/main/java/org/apache/geode/cache/RegionShortcut.java
b/geode-core/src/main/java/org/apache/geode/cache/RegionShortcut.java
index 45254f0..1d7fe0b 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/RegionShortcut.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/RegionShortcut.java
@@ -157,30 +157,32 @@ public enum RegionShortcut {
/**
* A LOCAL region only has local state and never sends operations to others.
The actual
- * RegionAttributes for a LOCAL region set the {@code DataPolicy} to {@code
DataPolicy.NORMAL}.
+ * RegionAttributes for a LOCAL region set the {@code Scope} to {@code
Scope.LOCAL}
+ * and the {@code DataPolicy} to {@code DataPolicy.NORMAL}.
*/
LOCAL,
/**
* A LOCAL_PERSISTENT region only has local state and never sends operations
to others but it does
* write its state to disk and can recover that state when the region is
created. The actual
- * RegionAttributes for a LOCAL_PERSISTENT region set the {@code DataPolicy}
to
- * {@code DataPolicy.PERSISTENT_REPLICATE}.
+ * RegionAttributes for a LOCAL_PERSISTENT region set the {@code Scope} to
{@code Scope.LOCAL}
+ * and the {@code DataPolicy} to {@code DataPolicy.PERSISTENT_REPLICATE}.
*/
LOCAL_PERSISTENT,
/**
* A LOCAL_HEAP_LRU region only has local state and never sends operations
to others. It will also
* destroy entries once it detects that the java vm is running low of
memory. The actual
- * RegionAttributes for a LOCAL_HEAP_LRU region set the {@code DataPolicy} to
- * {@code DataPolicy.NORMAL} and {@code EvictionAttributes} are set to
+ * RegionAttributes for a LOCAL_HEAP_LRU region set the the {@code Scope} to
{@code Scope.LOCAL},
+ * the {@code DataPolicy} to {@code DataPolicy.NORMAL}, and {@code
EvictionAttributes} are set to
* {@code EvictionAlgorithm.LRU_HEAP} with {@code
EvictionAction.LOCAL_DESTROY}.
*/
LOCAL_HEAP_LRU,
/**
* A LOCAL_OVERFLOW region only has local state and never sends operations
to others. It will also
* move the values of entries to disk once it detects that the java vm is
running low of memory.
- * The actual RegionAttributes for a LOCAL_OVERFLOW region set the {@code
DataPolicy} to
- * {@code DataPolicy.NORMAL} and {@code EvictionAttributes} are set to
+ * The actual RegionAttributes for a LOCAL_OVERFLOW region set
+ * the {@code Scope} to {@code Scope.LOCAL},
+ * the {@code DataPolicy} to {@code DataPolicy.NORMAL}, and {@code
EvictionAttributes} are set to
* {@code EvictionAlgorithm.LRU_HEAP} with {@code
EvictionAction.OVERFLOW_TO_DISK}.
*/
LOCAL_OVERFLOW,
@@ -188,8 +190,9 @@ public enum RegionShortcut {
* A LOCAL_PERSISTENT_OVERFLOW region only has local state and never sends
operations to others
* but it does write its state to disk and can recover that state when the
region is created. It
* will also remove the values of entries from memory once it detects that
the java vm is running
- * low of memory. The actual RegionAttributes for a
LOCAL_PERSISTENT_OVERFLOW region set the
- * {@code DataPolicy} to {@code DataPolicy.PERSISTENT_REPLICATE} and {@code
EvictionAttributes}
+ * low of memory. The actual RegionAttributes for a
LOCAL_PERSISTENT_OVERFLOW region set
+ * the {@code Scope} to {@code Scope.LOCAL}, the
+ * {@code DataPolicy} to {@code DataPolicy.PERSISTENT_REPLICATE}, and {@code
EvictionAttributes}
* are set to {@code EvictionAlgorithm.LRU_HEAP} with {@code
EvictionAction.OVERFLOW_TO_DISK}.
*/
LOCAL_PERSISTENT_OVERFLOW,
diff --git
a/geode-core/src/main/java/org/apache/geode/distributed/internal/InternalConfigurationPersistenceService.java
b/geode-core/src/main/java/org/apache/geode/distributed/internal/InternalConfigurationPersistenceService.java
index a6d4e23..f838e0a 100644
---
a/geode-core/src/main/java/org/apache/geode/distributed/internal/InternalConfigurationPersistenceService.java
+++
b/geode-core/src/main/java/org/apache/geode/distributed/internal/InternalConfigurationPersistenceService.java
@@ -59,11 +59,9 @@ import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import org.apache.geode.annotations.VisibleForTesting;
-import org.apache.geode.cache.AttributesFactory;
-import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.DiskStore;
import org.apache.geode.cache.Region;
-import org.apache.geode.cache.Scope;
+import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.configuration.CacheConfig;
import org.apache.geode.distributed.ConfigurationPersistenceService;
import org.apache.geode.distributed.DistributedLockService;
@@ -73,7 +71,7 @@ import
org.apache.geode.distributed.internal.locks.DLockService;
import org.apache.geode.internal.JarDeployer;
import org.apache.geode.internal.cache.ClusterConfigurationLoader;
import org.apache.geode.internal.cache.InternalCache;
-import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.persistence.PersistentMemberID;
import org.apache.geode.internal.cache.persistence.PersistentMemberManager;
import org.apache.geode.internal.cache.persistence.PersistentMemberPattern;
@@ -806,17 +804,12 @@ public class InternalConfigurationPersistenceService
implements ConfigurationPer
cache.createDiskStoreFactory().setDiskDirs(diskDirs).setAutoCompact(true)
.setMaxOplogSize(10).create(CLUSTER_CONFIG_DISK_STORE_NAME);
- AttributesFactory<String, Configuration> regionAttrsFactory = new
AttributesFactory<>();
- regionAttrsFactory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
- regionAttrsFactory.setCacheListener(new
ConfigurationChangeListener(this, cache));
- regionAttrsFactory.setDiskStoreName(CLUSTER_CONFIG_DISK_STORE_NAME);
- regionAttrsFactory.setScope(Scope.DISTRIBUTED_ACK);
- InternalRegionArguments internalArgs = new InternalRegionArguments();
- internalArgs.setIsUsedForMetaRegion(true);
- internalArgs.setMetaRegionWithTransactions(false);
-
- return cache.createVMRegion(CONFIG_REGION_NAME,
regionAttrsFactory.create(),
- internalArgs);
+ InternalRegionFactory<String, Configuration> regionFactory =
+
cache.createInternalRegionFactory(RegionShortcut.REPLICATE_PERSISTENT);
+ regionFactory.addCacheListener(new ConfigurationChangeListener(this,
cache));
+ regionFactory.setDiskStoreName(CLUSTER_CONFIG_DISK_STORE_NAME);
+
regionFactory.setIsUsedForMetaRegion(true).setMetaRegionWithTransactions(false);
+ return regionFactory.create(CONFIG_REGION_NAME);
} catch (RuntimeException e) {
status.set(SharedConfigurationStatus.STOPPED);
// throw RuntimeException as is
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/admin/ClientHealthMonitoringRegion.java
b/geode-core/src/main/java/org/apache/geode/internal/admin/ClientHealthMonitoringRegion.java
index c9a53bd..e463bc8 100644
---
a/geode-core/src/main/java/org/apache/geode/internal/admin/ClientHealthMonitoringRegion.java
+++
b/geode-core/src/main/java/org/apache/geode/internal/admin/ClientHealthMonitoringRegion.java
@@ -17,17 +17,15 @@ package org.apache.geode.internal.admin;
import org.apache.logging.log4j.Logger;
import org.apache.geode.annotations.internal.MakeNotStatic;
-import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.CacheListener;
import org.apache.geode.cache.ExpirationAction;
import org.apache.geode.cache.ExpirationAttributes;
import org.apache.geode.cache.Region;
-import org.apache.geode.cache.RegionAttributes;
-import org.apache.geode.cache.Scope;
+import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.util.CacheListenerAdapter;
import org.apache.geode.internal.admin.remote.ClientHealthStats;
import org.apache.geode.internal.cache.InternalCache;
-import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.logging.internal.log4j.api.LogService;
/**
@@ -76,8 +74,7 @@ public class ClientHealthMonitoringRegion {
*/
private static void initialize(InternalCache cache) {
try {
- AttributesFactory factory = new AttributesFactory();
- factory.setScope(Scope.LOCAL);
+ InternalRegionFactory factory =
cache.createInternalRegionFactory(RegionShortcut.LOCAL);
factory.setEntryTimeToLive(
new ExpirationAttributes(ADMIN_REGION_EXPIRY_INTERVAL,
ExpirationAction.DESTROY));
if (logger.isDebugEnabled()) {
@@ -86,13 +83,8 @@ public class ClientHealthMonitoringRegion {
factory.addCacheListener(prepareCacheListener());
factory.setValueConstraint(ClientHealthStats.class);
factory.setStatisticsEnabled(true);
- RegionAttributes regionAttrs = factory.create();
-
- InternalRegionArguments internalArgs = new InternalRegionArguments();
- internalArgs.setIsUsedForMetaRegion(true);
- internalArgs.setIsUsedForPartitionedRegionAdmin(false);
-
- currentInstance = cache.createVMRegion(ADMIN_REGION_NAME, regionAttrs,
internalArgs);
+
factory.setIsUsedForMetaRegion(true).setIsUsedForPartitionedRegionAdmin(false);
+ currentInstance = factory.create(ADMIN_REGION_NAME);
} catch (Exception ex) {
logger.error("Error while creating an admin region", ex);
}
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/cache/CacheFactoryStatics.java
b/geode-core/src/main/java/org/apache/geode/internal/cache/CacheFactoryStatics.java
index 9b0f989..2e70db4 100644
---
a/geode-core/src/main/java/org/apache/geode/internal/cache/CacheFactoryStatics.java
+++
b/geode-core/src/main/java/org/apache/geode/internal/cache/CacheFactoryStatics.java
@@ -80,7 +80,7 @@ public class CacheFactoryStatics {
* @throws CacheClosedException if a cache has not been created or the only
created one is
* {@link Cache#isClosed closed}
*/
- public static Cache getAnyInstance() {
+ public static InternalCache getAnyInstance() {
synchronized (InternalCacheBuilder.class) {
InternalCache instance = GemFireCacheImpl.getInstance();
if (instance == null) {
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/cache/CacheServerImpl.java
b/geode-core/src/main/java/org/apache/geode/internal/cache/CacheServerImpl.java
index 3e46a88..19d262e 100644
---
a/geode-core/src/main/java/org/apache/geode/internal/cache/CacheServerImpl.java
+++
b/geode-core/src/main/java/org/apache/geode/internal/cache/CacheServerImpl.java
@@ -34,7 +34,6 @@ import org.apache.geode.GemFireIOException;
import org.apache.geode.InternalGemFireError;
import org.apache.geode.InvalidValueException;
import org.apache.geode.annotations.internal.MakeNotStatic;
-import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.ClientSession;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.DiskStoreFactory;
@@ -42,7 +41,6 @@ import org.apache.geode.cache.DynamicRegionFactory;
import org.apache.geode.cache.EvictionAction;
import org.apache.geode.cache.EvictionAttributes;
import org.apache.geode.cache.InterestRegistrationListener;
-import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.RegionExistsException;
import org.apache.geode.cache.Scope;
import org.apache.geode.cache.server.CacheServer;
@@ -593,17 +591,15 @@ public class CacheServerImpl extends AbstractCacheServer
implements Distribution
*/
public static String clientMessagesRegion(InternalCache cache, String
ePolicy, int capacity,
int port, String overFlowDir, boolean isDiskStore) {
- AttributesFactory factory =
- getAttribFactoryForClientMessagesRegion(cache, ePolicy, capacity,
overFlowDir, isDiskStore);
- RegionAttributes attr = factory.create();
-
- return createClientMessagesRegion(attr, cache, capacity, port);
+ InternalRegionFactory factory =
+ getRegionFactoryForClientMessagesRegion(cache, ePolicy, capacity,
overFlowDir, isDiskStore);
+ return createClientMessagesRegion(factory, port);
}
- public static AttributesFactory
getAttribFactoryForClientMessagesRegion(InternalCache cache,
+ private static InternalRegionFactory
getRegionFactoryForClientMessagesRegion(InternalCache cache,
String ePolicy, int capacity, String overflowDir, boolean isDiskStore)
throws InvalidValueException, GemFireIOException {
- AttributesFactory factory = new AttributesFactory();
+ InternalRegionFactory factory = cache.createInternalRegionFactory();
factory.setScope(Scope.LOCAL);
if (isDiskStore) {
@@ -655,28 +651,17 @@ public class CacheServerImpl extends AbstractCacheServer
implements Distribution
return factory;
}
- private static String createClientMessagesRegion(RegionAttributes attr,
InternalCache cache,
- int capacity, int port) {
+ private static String createClientMessagesRegion(InternalRegionFactory
factory, int port) {
// generating unique name in VM for ClientMessagesRegion
String regionName = generateNameForClientMsgsRegion(port);
try {
- cache.createVMRegion(regionName, attr,
- new
InternalRegionArguments().setDestroyLockFlag(true).setRecreateFlag(false)
-
.setSnapshotInputStream(null).setImageTarget(null).setIsUsedForMetaRegion(true));
+ factory.setDestroyLockFlag(true).setRecreateFlag(false)
+
.setSnapshotInputStream(null).setImageTarget(null).setIsUsedForMetaRegion(true);
+ factory.create(regionName);
} catch (RegionExistsException ree) {
InternalGemFireError assErr = new InternalGemFireError("unexpected
exception");
assErr.initCause(ree);
throw assErr;
- } catch (IOException e) {
- // only if loading snapshot, not here
- InternalGemFireError assErr = new InternalGemFireError("unexpected
exception");
- assErr.initCause(e);
- throw assErr;
- } catch (ClassNotFoundException e) {
- // only if loading snapshot, not here
- InternalGemFireError assErr = new InternalGemFireError("unexpected
exception");
- assErr.initCause(e);
- throw assErr;
}
return regionName;
}
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/cache/GemFireCacheImpl.java
b/geode-core/src/main/java/org/apache/geode/internal/cache/GemFireCacheImpl.java
index 88be1f8..06ceb62 100755
---
a/geode-core/src/main/java/org/apache/geode/internal/cache/GemFireCacheImpl.java
+++
b/geode-core/src/main/java/org/apache/geode/internal/cache/GemFireCacheImpl.java
@@ -4325,25 +4325,25 @@ public class GemFireCacheImpl implements InternalCache,
InternalClientCache, Has
@Override
public <K, V> RegionFactory<K, V> createRegionFactory(RegionShortcut
shortcut) {
throwIfClient();
- return new RegionFactoryImpl<>(this, shortcut);
+ return new InternalRegionFactory<>(this, shortcut);
}
@Override
public <K, V> RegionFactory<K, V> createRegionFactory() {
throwIfClient();
- return new RegionFactoryImpl<>(this);
+ return new InternalRegionFactory<>(this);
}
@Override
public <K, V> RegionFactory<K, V> createRegionFactory(String
regionAttributesId) {
throwIfClient();
- return new RegionFactoryImpl<>(this, regionAttributesId);
+ return new InternalRegionFactory<>(this, regionAttributesId);
}
@Override
public <K, V> RegionFactory<K, V> createRegionFactory(RegionAttributes<K, V>
regionAttributes) {
throwIfClient();
- return new RegionFactoryImpl<>(this, regionAttributes);
+ return new InternalRegionFactory<>(this, regionAttributes);
}
/**
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/cache/InternalCache.java
b/geode-core/src/main/java/org/apache/geode/internal/cache/InternalCache.java
index 4d42272..ca7d632 100644
---
a/geode-core/src/main/java/org/apache/geode/internal/cache/InternalCache.java
+++
b/geode-core/src/main/java/org/apache/geode/internal/cache/InternalCache.java
@@ -37,6 +37,7 @@ import org.apache.geode.cache.DiskStoreFactory;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.RegionExistsException;
+import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.TimeoutException;
import org.apache.geode.cache.asyncqueue.AsyncEventQueue;
import org.apache.geode.cache.asyncqueue.internal.AsyncEventQueueImpl;
@@ -572,4 +573,12 @@ public interface InternalCache extends Cache,
Extensible<Cache>, CacheTime, Inte
void saveCacheXmlForReconnect();
InternalQueryService getInternalQueryService();
+
+ default <K, V> InternalRegionFactory<K, V> createInternalRegionFactory() {
+ return (InternalRegionFactory) createRegionFactory();
+ }
+
+ default <K, V> InternalRegionFactory<K, V>
createInternalRegionFactory(RegionShortcut shortcut) {
+ return (InternalRegionFactory) createRegionFactory(shortcut);
+ }
}
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/cache/InternalRegionArguments.java
b/geode-core/src/main/java/org/apache/geode/internal/cache/InternalRegionArguments.java
index 966e16f..d4431e1 100644
---
a/geode-core/src/main/java/org/apache/geode/internal/cache/InternalRegionArguments.java
+++
b/geode-core/src/main/java/org/apache/geode/internal/cache/InternalRegionArguments.java
@@ -69,6 +69,9 @@ public class InternalRegionArguments {
private Set<String> internalAsyncEventQueueIds;
+
+ public InternalRegionArguments() {}
+
/* methods that set and retrieve internal state used to configure a Region */
public InternalRegionArguments setIsUsedForPartitionedRegionAdmin(boolean
adminFlag) {
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/cache/InternalRegionFactory.java
b/geode-core/src/main/java/org/apache/geode/internal/cache/InternalRegionFactory.java
new file mode 100644
index 0000000..efbf73b
--- /dev/null
+++
b/geode-core/src/main/java/org/apache/geode/internal/cache/InternalRegionFactory.java
@@ -0,0 +1,242 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
contributor license
+ * agreements. See the NOTICE file distributed with this work for additional
information regarding
+ * copyright ownership. The ASF licenses this file to You under the Apache
License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the
License. You may obtain a
+ * copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express
+ * or implied. See the License for the specific language governing permissions
and limitations under
+ * the License.
+ */
+package org.apache.geode.internal.cache;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import org.apache.geode.InternalGemFireError;
+import org.apache.geode.cache.CacheExistsException;
+import org.apache.geode.cache.CacheWriterException;
+import org.apache.geode.cache.Region;
+import org.apache.geode.cache.RegionAttributes;
+import org.apache.geode.cache.RegionExistsException;
+import org.apache.geode.cache.RegionFactory;
+import org.apache.geode.cache.RegionShortcut;
+import org.apache.geode.cache.TimeoutException;
+import
org.apache.geode.distributed.internal.membership.InternalDistributedMember;
+import org.apache.geode.internal.cache.partitioned.RegionAdvisor;
+import org.apache.geode.internal.cache.persistence.PersistenceAdvisor;
+import org.apache.geode.internal.cache.wan.AbstractGatewaySender;
+
+/**
+ * {@code InternalRegionFactory} extends RegionFactory adding {@link
RegionShortcut} support.
+ * It also supports setting {@link InternalRegionArguments}.
+ *
+ * @since GemFire 6.5
+ */
+public class InternalRegionFactory<K, V> extends RegionFactory<K, V> {
+ private InternalRegionArguments internalRegionArguments;
+
+ public InternalRegionFactory(InternalCache cache) {
+ super(cache);
+ }
+
+ public InternalRegionFactory(InternalCache cache, RegionShortcut pra) {
+ super(cache, pra);
+ }
+
+ public InternalRegionFactory(InternalCache cache, RegionAttributes<K, V> ra)
{
+ super(cache, ra);
+ }
+
+ public InternalRegionFactory(InternalCache cache, String regionAttributesId)
{
+ super(cache, regionAttributesId);
+ }
+
+ public InternalRegionFactory(RegionFactory<K, V> regionFactory) {
+ super(regionFactory);
+ }
+
+ /**
+ * Returns the region attributes that would currently be used to create the
region.
+ */
+ public RegionAttributes<K, V> getCreateAttributes() {
+ return getRegionAttributes();
+ }
+
+ @Override
+ public Region<K, V> create(String name)
+ throws CacheExistsException, RegionExistsException,
CacheWriterException, TimeoutException {
+ if (internalRegionArguments == null) {
+ return super.create(name);
+ }
+ try {
+ return getCache().createVMRegion(name, getRegionAttributes(),
internalRegionArguments);
+ } catch (IOException | ClassNotFoundException e) {
+ throw new InternalGemFireError("unexpected exception", e);
+ }
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public Region<K, V> createSubregion(Region<?, ?> parent, String name)
+ throws RegionExistsException {
+ if (internalRegionArguments == null) {
+ return super.createSubregion(parent, name);
+ }
+ try {
+ return ((InternalRegion) parent).createSubregion(name,
getRegionAttributes(),
+ internalRegionArguments);
+ } catch (IOException | ClassNotFoundException e) {
+ throw new InternalGemFireError("unexpected exception", e);
+ }
+ }
+
+ public InternalRegionArguments getInternalRegionArguments() {
+ return internalRegionArguments;
+ }
+
+ public InternalRegionFactory<K, V>
setIsUsedForPartitionedRegionAdmin(boolean adminFlag) {
+ makeInternal().setIsUsedForPartitionedRegionAdmin(adminFlag);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setPartitionedRegionBucketRedundancy(int
redundancy) {
+ makeInternal().setPartitionedRegionBucketRedundancy(redundancy);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setPartitionedRegionAdvisor(RegionAdvisor
advisor) {
+ makeInternal().setPartitionedRegionAdvisor(advisor);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setBucketAdvisor(BucketAdvisor advisor) {
+ makeInternal().setBucketAdvisor(advisor);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setPersistenceAdvisor(PersistenceAdvisor
persistenceAdvisor) {
+ makeInternal().setPersistenceAdvisor(persistenceAdvisor);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setDiskRegion(DiskRegion diskRegion) {
+ makeInternal().setDiskRegion(diskRegion);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setIsUsedForMetaRegion(boolean
isMetaRegion) {
+ makeInternal().setIsUsedForMetaRegion(isMetaRegion);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setMetaRegionWithTransactions(
+ boolean metaRegionWithTransactions) {
+ makeInternal().setMetaRegionWithTransactions(metaRegionWithTransactions);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setLoaderHelperFactory(
+ LoaderHelperFactory loaderHelperFactory) {
+ makeInternal().setLoaderHelperFactory(loaderHelperFactory);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setDestroyLockFlag(boolean
getDestoryLock) {
+ makeInternal().setDestroyLockFlag(getDestoryLock);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setSnapshotInputStream(InputStream
snapshotInputStream) {
+ makeInternal().setSnapshotInputStream(snapshotInputStream);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setImageTarget(InternalDistributedMember
imageTarget) {
+ makeInternal().setImageTarget(imageTarget);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setRecreateFlag(boolean recreate) {
+ makeInternal().setRecreateFlag(recreate);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setInternalMetaRegion(LocalRegion r) {
+ makeInternal().setInternalMetaRegion(r);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setCachePerfStatsHolder(
+ HasCachePerfStats cachePerfStatsHolder) {
+ makeInternal().setCachePerfStatsHolder(cachePerfStatsHolder);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setPartitionedRegion(PartitionedRegion
partitionedRegion) {
+ makeInternal().setPartitionedRegion(partitionedRegion);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setTestCallable(LocalRegion.TestCallable
c) {
+ makeInternal().setTestCallable(c);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setUserAttribute(Object userAttr) {
+ makeInternal().setUserAttribute(userAttr);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V>
setIsUsedForSerialGatewaySenderQueue(boolean queueFlag) {
+ makeInternal().setIsUsedForSerialGatewaySenderQueue(queueFlag);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V>
setIsUsedForParallelGatewaySenderQueue(boolean queueFlag) {
+ makeInternal().setIsUsedForParallelGatewaySenderQueue(queueFlag);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V>
setParallelGatewaySender(AbstractGatewaySender pgSender) {
+ makeInternal().setParallelGatewaySender(pgSender);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V>
setSerialGatewaySender(AbstractGatewaySender serialSender) {
+ makeInternal().setSerialGatewaySender(serialSender);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setIndexes(List indexes) {
+ makeInternal().setIndexes(indexes);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V>
addCacheServiceProfile(CacheServiceProfile profile) {
+ makeInternal().addCacheServiceProfile(profile);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> addInternalAsyncEventQueueId(String
aeqId) {
+ makeInternal().addInternalAsyncEventQueueId(aeqId);
+ return this;
+ }
+
+ public InternalRegionFactory<K, V> setInternalRegion(final boolean
internalRegion) {
+ makeInternal().setInternalRegion(internalRegion);
+ return this;
+ }
+
+ private InternalRegionArguments makeInternal() {
+ if (internalRegionArguments == null) {
+ internalRegionArguments = new InternalRegionArguments();
+ }
+ return internalRegionArguments;
+ }
+}
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/cache/PartitionedRegionHelper.java
b/geode-core/src/main/java/org/apache/geode/internal/cache/PartitionedRegionHelper.java
index 0b20500..1c2707c 100644
---
a/geode-core/src/main/java/org/apache/geode/internal/cache/PartitionedRegionHelper.java
+++
b/geode-core/src/main/java/org/apache/geode/internal/cache/PartitionedRegionHelper.java
@@ -16,7 +16,6 @@ package org.apache.geode.internal.cache;
import static
org.apache.geode.internal.cache.LocalRegion.InitializationLevel.ANY_INIT;
-import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
@@ -30,7 +29,6 @@ import org.apache.logging.log4j.Logger;
import org.apache.geode.CancelException;
import org.apache.geode.annotations.Immutable;
-import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.CacheWriterException;
import org.apache.geode.cache.DataPolicy;
@@ -43,9 +41,8 @@ import org.apache.geode.cache.FixedPartitionResolver;
import org.apache.geode.cache.Operation;
import org.apache.geode.cache.PartitionResolver;
import org.apache.geode.cache.Region;
-import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.RegionExistsException;
-import org.apache.geode.cache.Scope;
+import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.partition.PartitionNotAvailableException;
import org.apache.geode.cache.util.CacheListenerAdapter;
import org.apache.geode.cache.util.CacheWriterAdapter;
@@ -210,9 +207,7 @@ public class PartitionedRegionHelper {
logger.debug("Creating root Partitioned Admin Region {}",
PartitionedRegionHelper.PR_ROOT_REGION_NAME);
}
- AttributesFactory factory = new AttributesFactory();
- factory.setScope(Scope.DISTRIBUTED_ACK);
- factory.setDataPolicy(DataPolicy.REPLICATE);
+ InternalRegionFactory factory =
cache.createInternalRegionFactory(RegionShortcut.REPLICATE);
factory.addCacheListener(new FixedPartitionAttributesListener());
if (Boolean.getBoolean(GeodeGlossary.GEMFIRE_PREFIX + "PRDebug")) {
factory.addCacheListener(new CacheListenerAdapter() {
@@ -263,7 +258,6 @@ public class PartitionedRegionHelper {
});
}
- RegionAttributes ra = factory.create();
// Create anonymous stats holder for Partitioned Region meta data
final HasCachePerfStats prMetaStatsHolder = new HasCachePerfStats() {
@Override
@@ -273,18 +267,16 @@ public class PartitionedRegionHelper {
}
};
+ factory.setIsUsedForPartitionedRegionAdmin(true);
+ factory.setInternalRegion(true);
+ factory.setCachePerfStatsHolder(prMetaStatsHolder);
+
try {
- root = (DistributedRegion) cache.createVMRegion(PR_ROOT_REGION_NAME,
ra,
- new
InternalRegionArguments().setIsUsedForPartitionedRegionAdmin(true)
-
.setInternalRegion(true).setCachePerfStatsHolder(prMetaStatsHolder));
+ root = (DistributedRegion) factory.create(PR_ROOT_REGION_NAME);
root.getDistributionAdvisor().addMembershipListener(new
MemberFailureListener(cache));
} catch (RegionExistsException ignore) {
// we avoid this before hand, but yet we have to catch it
root = (DistributedRegion) cache.getRegion(PR_ROOT_REGION_NAME, true);
- } catch (IOException ieo) {
- Assert.assertTrue(false, "IOException creating Partitioned Region
root: " + ieo);
- } catch (ClassNotFoundException cne) {
- Assert.assertTrue(false, "ClassNotFoundExcpetion creating Partitioned
Region root: " + cne);
}
}
Assert.assertTrue(root != null,
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/cache/RegionFactoryImpl.java
b/geode-core/src/main/java/org/apache/geode/internal/cache/RegionFactoryImpl.java
deleted file mode 100644
index 1968950..0000000
---
a/geode-core/src/main/java/org/apache/geode/internal/cache/RegionFactoryImpl.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
contributor license
- * agreements. See the NOTICE file distributed with this work for additional
information regarding
- * copyright ownership. The ASF licenses this file to You under the Apache
License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
License. You may obtain a
- * copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
distributed under the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express
- * or implied. See the License for the specific language governing permissions
and limitations under
- * the License.
- */
-package org.apache.geode.internal.cache;
-
-import java.io.IOException;
-
-import org.apache.geode.InternalGemFireError;
-import org.apache.geode.cache.CacheExistsException;
-import org.apache.geode.cache.CacheWriterException;
-import org.apache.geode.cache.Region;
-import org.apache.geode.cache.RegionAttributes;
-import org.apache.geode.cache.RegionExistsException;
-import org.apache.geode.cache.RegionFactory;
-import org.apache.geode.cache.RegionShortcut;
-import org.apache.geode.cache.TimeoutException;
-
-/**
- * {@code RegionFactoryImpl} extends RegionFactory adding {@link
RegionShortcut} support.
- *
- * @since GemFire 6.5
- */
-public class RegionFactoryImpl<K, V> extends RegionFactory<K, V> {
- private InternalRegionArguments internalRegionArguments;
-
- public RegionFactoryImpl(InternalCache cache) {
- super(cache);
- }
-
- public RegionFactoryImpl(InternalCache cache, RegionShortcut pra) {
- super(cache, pra);
- }
-
- public RegionFactoryImpl(InternalCache cache, RegionAttributes<K, V> ra) {
- super(cache, ra);
- }
-
- public RegionFactoryImpl(InternalCache cache, String regionAttributesId) {
- super(cache, regionAttributesId);
- }
-
- public RegionFactoryImpl(RegionFactory<K, V> regionFactory) {
- super(regionFactory);
- }
-
- public void setInternalRegionArguments(
- InternalRegionArguments internalRegionArguments) {
- this.internalRegionArguments = internalRegionArguments;
- }
-
- @Override
- public Region<K, V> create(String name)
- throws CacheExistsException, RegionExistsException,
CacheWriterException, TimeoutException {
- if (internalRegionArguments == null) {
- return super.create(name);
- }
- try {
- return getCache().createVMRegion(name, getRegionAttributes(),
internalRegionArguments);
- } catch (IOException | ClassNotFoundException e) {
- throw new InternalGemFireError("unexpected exception", e);
- }
- }
-}
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/cache/wan/AbstractGatewaySender.java
b/geode-core/src/main/java/org/apache/geode/internal/cache/wan/AbstractGatewaySender.java
index e7dd8b9..dfcc6dc 100644
---
a/geode-core/src/main/java/org/apache/geode/internal/cache/wan/AbstractGatewaySender.java
+++
b/geode-core/src/main/java/org/apache/geode/internal/cache/wan/AbstractGatewaySender.java
@@ -34,14 +34,12 @@ import org.apache.geode.InternalGemFireError;
import org.apache.geode.annotations.Immutable;
import org.apache.geode.annotations.VisibleForTesting;
import org.apache.geode.annotations.internal.MutableForTesting;
-import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.CacheException;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.Region;
-import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.RegionDestroyedException;
import org.apache.geode.cache.RegionExistsException;
-import org.apache.geode.cache.Scope;
+import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.asyncqueue.AsyncEventListener;
import org.apache.geode.cache.client.internal.LocatorDiscoveryCallback;
import org.apache.geode.cache.client.internal.PoolImpl;
@@ -64,7 +62,7 @@ import org.apache.geode.internal.cache.EnumListenerEvent;
import org.apache.geode.internal.cache.HasCachePerfStats;
import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.cache.InternalRegion;
-import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.LocalRegion;
import org.apache.geode.internal.cache.PartitionedRegion;
import org.apache.geode.internal.cache.RegionQueue;
@@ -1294,17 +1292,13 @@ public abstract class AbstractGatewaySender implements
InternalGatewaySender, Di
return this.eventIdIndexMetaDataRegion;
}
- @SuppressWarnings({"rawtypes", "unchecked", "deprecation"})
private static synchronized Region<String, Integer>
initializeEventIdIndexMetaDataRegion(
AbstractGatewaySender sender) {
final InternalCache cache = sender.getCache();
Region<String, Integer> region = cache.getRegion(META_DATA_REGION_NAME);
if (region == null) {
- // Create region attributes (must be done this way to use
InternalRegionArguments)
- AttributesFactory factory = new AttributesFactory();
- factory.setScope(Scope.DISTRIBUTED_ACK);
- factory.setDataPolicy(DataPolicy.REPLICATE);
- RegionAttributes ra = factory.create();
+ InternalRegionFactory<String, Integer> factory =
+ cache.createInternalRegionFactory(RegionShortcut.REPLICATE);
// Create a stats holder for the meta data stats
final HasCachePerfStats statsHolder = new HasCachePerfStats() {
@@ -1314,14 +1308,10 @@ public abstract class AbstractGatewaySender implements
InternalGatewaySender, Di
"RegionStats-" + META_DATA_REGION_NAME, sender.statisticsClock);
}
};
-
- // Create internal region arguments
- InternalRegionArguments ira = new
InternalRegionArguments().setIsUsedForMetaRegion(true)
- .setCachePerfStatsHolder(statsHolder);
-
- // Create the region
+ factory.setIsUsedForMetaRegion(true);
+ factory.setCachePerfStatsHolder(statsHolder);
try {
- region = cache.createVMRegion(META_DATA_REGION_NAME, ra, ira);
+ region = factory.create(META_DATA_REGION_NAME);
} catch (RegionExistsException e) {
region = cache.getRegion(META_DATA_REGION_NAME);
} catch (Exception e) {
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/cache/wan/parallel/ParallelGatewaySenderQueue.java
b/geode-core/src/main/java/org/apache/geode/internal/cache/wan/parallel/ParallelGatewaySenderQueue.java
index a4a9a28..a62eae6 100644
---
a/geode-core/src/main/java/org/apache/geode/internal/cache/wan/parallel/ParallelGatewaySenderQueue.java
+++
b/geode-core/src/main/java/org/apache/geode/internal/cache/wan/parallel/ParallelGatewaySenderQueue.java
@@ -17,7 +17,6 @@ package org.apache.geode.internal.cache.wan.parallel;
import static org.apache.geode.cache.wan.GatewaySender.DEFAULT_BATCH_SIZE;
import static
org.apache.geode.internal.cache.LocalRegion.InitializationLevel.BEFORE_INITIAL_IMAGE;
-import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
@@ -41,7 +40,6 @@ import org.apache.logging.log4j.Logger;
import org.apache.geode.CancelException;
import org.apache.geode.SystemFailure;
import org.apache.geode.annotations.internal.MutableForTesting;
-import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.AttributesMutator;
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.CacheException;
@@ -54,6 +52,7 @@ import org.apache.geode.cache.PartitionAttributesFactory;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.RegionDestroyedException;
+import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.asyncqueue.internal.AsyncEventQueueImpl;
import org.apache.geode.distributed.internal.DistributionManager;
import org.apache.geode.distributed.internal.InternalDistributedSystem;
@@ -70,6 +69,7 @@ import org.apache.geode.internal.cache.EntryEventImpl;
import org.apache.geode.internal.cache.ForceReattemptException;
import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.LocalRegion;
import org.apache.geode.internal.cache.LocalRegion.InitializationLevel;
import org.apache.geode.internal.cache.PartitionedRegion;
@@ -320,8 +320,7 @@ public class ParallelGatewaySenderQueue implements
RegionQueue {
final String prQName = getQueueName(sender.getId(),
userRegion.getFullPath());
prQ = (PartitionedRegion) cache.getRegion(prQName);
if (prQ == null) {
- // TODO:REF:Avoid deprecated apis
- AttributesFactory fact = new AttributesFactory();
+ InternalRegionFactory fact = cache.createInternalRegionFactory();
// Fix for 48621 - don't enable concurrency checks
// for queue buckets., event with persistence
fact.setConcurrencyChecksEnabled(false);
@@ -355,7 +354,7 @@ public class ParallelGatewaySenderQueue implements
RegionQueue {
fact.setEvictionAttributes(ea);
fact.setPartitionAttributes(pfact.create());
- final RegionAttributes ra = fact.create();
+ final RegionAttributes ra = fact.getCreateAttributes();
if (logger.isDebugEnabled()) {
logger.debug("{}: Attempting to create queue region: {}", this,
prQName);
@@ -365,40 +364,30 @@ public class ParallelGatewaySenderQueue implements
RegionQueue {
new ParallelGatewaySenderQueueMetaRegion(prQName, ra, null, cache,
sender,
sender.getStatisticsClock());
- try {
- prQ = (PartitionedRegion) cache.createVMRegion(prQName, ra,
- new
InternalRegionArguments().setInternalMetaRegion(meta).setDestroyLockFlag(true)
- .setSnapshotInputStream(null).setImageTarget(null));
+ fact.setInternalMetaRegion(meta).setDestroyLockFlag(true)
+ .setSnapshotInputStream(null).setImageTarget(null);
+ prQ = (PartitionedRegion) fact.create(prQName);
- if (logger.isDebugEnabled()) {
- logger.debug("Region created : {} partition Attributes : {}", prQ,
- prQ.getPartitionAttributes());
- }
+ if (logger.isDebugEnabled()) {
+ logger.debug("Region created : {} partition Attributes : {}", prQ,
+ prQ.getPartitionAttributes());
+ }
- // TODO This should not be set on the PR but on the GatewaySender
- prQ.enableConflation(sender.isBatchConflationEnabled());
-
- // Before going ahead, make sure all the buckets of shadowPR are
- // loaded
- // and primary nodes have been decided.
- // This is required in case of persistent PR and sender.
- if (prQ.getLocalMaxMemory() != 0) {
- Iterator<Integer> itr =
prQ.getRegionAdvisor().getBucketSet().iterator();
- while (itr.hasNext()) {
- itr.next();
- }
+ // TODO This should not be set on the PR but on the GatewaySender
+ prQ.enableConflation(sender.isBatchConflationEnabled());
+
+ // Before going ahead, make sure all the buckets of shadowPR are
+ // loaded
+ // and primary nodes have been decided.
+ // This is required in case of persistent PR and sender.
+ if (prQ.getLocalMaxMemory() != 0) {
+ Iterator<Integer> itr =
prQ.getRegionAdvisor().getBucketSet().iterator();
+ while (itr.hasNext()) {
+ itr.next();
}
- // In case of Replicated Region it may not be necessary.
-
- } catch (IOException veryUnLikely) {
- logger.fatal("Unexpected Exception during init of " +
- this.getClass(),
- veryUnLikely);
- } catch (ClassNotFoundException alsoUnlikely) {
- logger.fatal("Unexpected Exception during init of " +
- this.getClass(),
- alsoUnlikely);
}
+ // In case of Replicated Region it may not be necessary.
+
if (logger.isDebugEnabled()) {
logger.debug("{}: Created queue region: {}", this, prQ);
}
@@ -469,9 +458,14 @@ public class ParallelGatewaySenderQueue implements
RegionQueue {
final String prQName = sender.getId() + QSTRING +
convertPathToName(userPR.getFullPath());
prQ = (PartitionedRegion) cache.getRegion(prQName);
if (prQ == null) {
- // TODO:REF:Avoid deprecated apis
+ RegionShortcut regionShortcut;
+ if (sender.isPersistenceEnabled() && !isAccessor) {
+ regionShortcut = RegionShortcut.PARTITION_PERSISTENT;
+ } else {
+ regionShortcut = RegionShortcut.PARTITION;
+ }
+ InternalRegionFactory fact =
cache.createInternalRegionFactory(regionShortcut);
- AttributesFactory fact = new AttributesFactory();
fact.setConcurrencyChecksEnabled(false);
PartitionAttributesFactory pfact = new PartitionAttributesFactory();
pfact.setTotalNumBuckets(userPR.getTotalNumberOfBuckets());
@@ -486,10 +480,6 @@ public class ParallelGatewaySenderQueue implements
RegionQueue {
pfact.setStartupRecoveryDelay(userPR.getPartitionAttributes().getStartupRecoveryDelay());
pfact.setRecoveryDelay(userPR.getPartitionAttributes().getRecoveryDelay());
- if (sender.isPersistenceEnabled() && !isAccessor) {
- fact.setDataPolicy(DataPolicy.PERSISTENT_PARTITION);
- }
-
fact.setDiskStoreName(sender.getDiskStoreName());
// if persistence is enabled, set the diskSyncronous to whatever user
has set
@@ -507,7 +497,7 @@ public class ParallelGatewaySenderQueue implements
RegionQueue {
fact.setEvictionAttributes(ea);
fact.setPartitionAttributes(pfact.create());
- final RegionAttributes ra = fact.create();
+ final RegionAttributes ra = fact.getCreateAttributes();
if (logger.isDebugEnabled()) {
logger.debug("{}: Attempting to create queue region: {}", this,
prQName);
@@ -516,28 +506,25 @@ public class ParallelGatewaySenderQueue implements
RegionQueue {
ParallelGatewaySenderQueueMetaRegion meta =
metaRegionFactory.newMetataRegion(cache, prQName, ra, sender);
- try {
- prQ = (PartitionedRegion) cache.createVMRegion(prQName, ra,
- new
InternalRegionArguments().setInternalMetaRegion(meta).setDestroyLockFlag(true)
-
.setInternalRegion(true).setSnapshotInputStream(null).setImageTarget(null));
- // at this point we should be able to assert prQ == meta;
-
- // TODO This should not be set on the PR but on the GatewaySender
- prQ.enableConflation(sender.isBatchConflationEnabled());
- if (isAccessor)
- return; // return from here if accessor node
-
- // Add the overflow statistics to the mbean
- addOverflowStatisticsToMBean(cache, prQ);
-
- // Wait for buckets to be recovered.
- prQ.shadowPRWaitForBucketRecovery();
-
- } catch (IOException | ClassNotFoundException veryUnLikely) {
- logger.fatal("Unexpected Exception during init of " +
- this.getClass(),
- veryUnLikely);
- }
+ fact.setInternalMetaRegion(meta);
+ fact.setDestroyLockFlag(true);
+ fact.setInternalRegion(true);
+ fact.setSnapshotInputStream(null);
+ fact.setImageTarget(null);
+ prQ = (PartitionedRegion) fact.create(prQName);
+ // at this point we should be able to assert prQ == meta;
+
+ // TODO This should not be set on the PR but on the GatewaySender
+ prQ.enableConflation(sender.isBatchConflationEnabled());
+ if (isAccessor)
+ return; // return from here if accessor node
+
+ // Add the overflow statistics to the mbean
+ addOverflowStatisticsToMBean(cache, prQ);
+
+ // Wait for buckets to be recovered.
+ prQ.shadowPRWaitForBucketRecovery();
+
if (logger.isDebugEnabled()) {
logger.debug("{}: Created queue region: {}", this, prQ);
}
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/cache/wan/serial/SerialGatewaySenderQueue.java
b/geode-core/src/main/java/org/apache/geode/internal/cache/wan/serial/SerialGatewaySenderQueue.java
index 0e19ebb..243fe73 100644
---
a/geode-core/src/main/java/org/apache/geode/internal/cache/wan/serial/SerialGatewaySenderQueue.java
+++
b/geode-core/src/main/java/org/apache/geode/internal/cache/wan/serial/SerialGatewaySenderQueue.java
@@ -16,7 +16,6 @@ package org.apache.geode.internal.cache.wan.serial;
import static org.apache.geode.cache.wan.GatewaySender.DEFAULT_BATCH_SIZE;
-import java.io.IOException;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashMap;
@@ -33,7 +32,6 @@ import org.apache.logging.log4j.Logger;
import org.apache.geode.CancelException;
import org.apache.geode.SystemFailure;
import org.apache.geode.annotations.Immutable;
-import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.AttributesMutator;
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.CacheException;
@@ -47,6 +45,7 @@ import org.apache.geode.cache.Operation;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.RegionDestroyedException;
+import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.Scope;
import org.apache.geode.cache.TimeoutException;
import org.apache.geode.cache.asyncqueue.AsyncEvent;
@@ -58,6 +57,7 @@ import org.apache.geode.internal.cache.DistributedRegion;
import org.apache.geode.internal.cache.EntryEventImpl;
import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.LocalRegion;
import org.apache.geode.internal.cache.RegionQueue;
import org.apache.geode.internal.cache.Token;
@@ -847,10 +847,17 @@ public class SerialGatewaySenderQueue implements
RegionQueue {
final InternalCache gemCache = sender.getCache();
this.region = gemCache.getRegion(this.regionName);
if (this.region == null) {
- AttributesFactory<Long, AsyncEvent> factory = new
AttributesFactory<Long, AsyncEvent>();
- factory.setScope(NO_ACK ? Scope.DISTRIBUTED_NO_ACK :
Scope.DISTRIBUTED_ACK);
- factory.setDataPolicy(
- this.enablePersistence ? DataPolicy.PERSISTENT_REPLICATE :
DataPolicy.REPLICATE);
+ RegionShortcut regionShortcut;
+ if (enablePersistence) {
+ regionShortcut = RegionShortcut.REPLICATE_PERSISTENT;
+ } else {
+ regionShortcut = RegionShortcut.REPLICATE;
+ }
+ InternalRegionFactory<Long, AsyncEvent> factory =
+ gemCache.createInternalRegionFactory(regionShortcut);
+ if (NO_ACK) {
+ factory.setScope(Scope.DISTRIBUTED_NO_ACK);
+ }
if (logger.isDebugEnabled()) {
logger.debug("The policy of region is {}",
(this.enablePersistence ? DataPolicy.PERSISTENT_REPLICATE :
DataPolicy.REPLICATE));
@@ -876,29 +883,22 @@ public class SerialGatewaySenderQueue implements
RegionQueue {
if (logger.isDebugEnabled()) {
logger.debug("{}: Attempting to create queue region: {}", this,
this.regionName);
}
- final RegionAttributes<Long, AsyncEvent> ra = factory.create();
+ final RegionAttributes<Long, AsyncEvent> ra =
factory.getCreateAttributes();
try {
SerialGatewaySenderQueueMetaRegion meta =
new SerialGatewaySenderQueueMetaRegion(this.regionName, ra, null,
gemCache, sender,
sender.getStatisticsClock());
- try {
- this.region = gemCache.createVMRegion(this.regionName, ra,
- new
InternalRegionArguments().setInternalMetaRegion(meta).setDestroyLockFlag(true)
- .setSnapshotInputStream(null).setImageTarget(null)
-
.setIsUsedForSerialGatewaySenderQueue(true).setInternalRegion(true)
- .setSerialGatewaySender(sender));
-
- // Add overflow statistics to the mbean
- addOverflowStatisticsToMBean(gemCache, sender);
- } catch (IOException veryUnLikely) {
- logger.fatal(String.format("Unexpected Exception during init of %s",
- this.getClass()),
- veryUnLikely);
- } catch (ClassNotFoundException alsoUnlikely) {
- logger.fatal(String.format("Unexpected Exception during init of %s",
- this.getClass()),
- alsoUnlikely);
- }
+ factory
+ .setInternalMetaRegion(meta)
+ .setDestroyLockFlag(true)
+ .setSnapshotInputStream(null)
+ .setImageTarget(null)
+ .setIsUsedForSerialGatewaySenderQueue(true)
+ .setInternalRegion(true)
+ .setSerialGatewaySender(sender);
+ region = factory.create(regionName);
+ // Add overflow statistics to the mbean
+ addOverflowStatisticsToMBean(gemCache, sender);
if (logger.isDebugEnabled()) {
logger.debug("{}: Created queue region: {}", this, this.region);
}
diff --git
a/geode-core/src/main/java/org/apache/geode/internal/cache/xmlcache/CacheCreation.java
b/geode-core/src/main/java/org/apache/geode/internal/cache/xmlcache/CacheCreation.java
index 324a6ef..930a21c 100755
---
a/geode-core/src/main/java/org/apache/geode/internal/cache/xmlcache/CacheCreation.java
+++
b/geode-core/src/main/java/org/apache/geode/internal/cache/xmlcache/CacheCreation.java
@@ -134,11 +134,11 @@ import
org.apache.geode.internal.cache.InternalCacheForClientAccess;
import org.apache.geode.internal.cache.InternalCacheServer;
import org.apache.geode.internal.cache.InternalRegion;
import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.LocalRegion;
import org.apache.geode.internal.cache.PartitionedRegion;
import org.apache.geode.internal.cache.PoolFactoryImpl;
import org.apache.geode.internal.cache.PoolManagerImpl;
-import org.apache.geode.internal.cache.RegionFactoryImpl;
import org.apache.geode.internal.cache.RegionListener;
import org.apache.geode.internal.cache.TXEntryStateFactory;
import org.apache.geode.internal.cache.TXManagerImpl;
@@ -1111,25 +1111,25 @@ public class CacheCreation implements InternalCache {
@Override
public <K, V> RegionFactory<K, V> createRegionFactory(RegionShortcut
shortcut) {
throwIfClient();
- return new RegionFactoryImpl<>(this, shortcut);
+ return new InternalRegionFactory<>(this, shortcut);
}
@Override
public <K, V> RegionFactory<K, V> createRegionFactory() {
throwIfClient();
- return new RegionFactoryImpl<>(this);
+ return new InternalRegionFactory<>(this);
}
@Override
public <K, V> RegionFactory<K, V> createRegionFactory(String
regionAttributesId) {
throwIfClient();
- return new RegionFactoryImpl<>(this, regionAttributesId);
+ return new InternalRegionFactory<>(this, regionAttributesId);
}
@Override
public <K, V> RegionFactory<K, V> createRegionFactory(RegionAttributes<K, V>
regionAttributes) {
throwIfClient();
- return new RegionFactoryImpl<>(this, regionAttributes);
+ return new InternalRegionFactory<>(this, regionAttributes);
}
@Override
diff --git
a/geode-core/src/main/java/org/apache/geode/management/internal/FederatingManager.java
b/geode-core/src/main/java/org/apache/geode/management/internal/FederatingManager.java
index bc3fe34..714c9cb 100755
---
a/geode-core/src/main/java/org/apache/geode/management/internal/FederatingManager.java
+++
b/geode-core/src/main/java/org/apache/geode/management/internal/FederatingManager.java
@@ -14,7 +14,6 @@
*/
package org.apache.geode.management.internal;
-import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
@@ -36,12 +35,10 @@ import org.apache.logging.log4j.Logger;
import org.apache.geode.CancelException;
import org.apache.geode.StatisticsFactory;
import org.apache.geode.annotations.VisibleForTesting;
-import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.EvictionAction;
import org.apache.geode.cache.EvictionAttributes;
import org.apache.geode.cache.Region;
-import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.RegionDestroyedException;
import org.apache.geode.cache.RegionExistsException;
import org.apache.geode.cache.Scope;
@@ -52,7 +49,7 @@ import
org.apache.geode.distributed.internal.membership.InternalDistributedMembe
import org.apache.geode.internal.cache.CachePerfStats;
import org.apache.geode.internal.cache.HasCachePerfStats;
import org.apache.geode.internal.cache.InternalCache;
-import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.statistics.StatisticsClock;
import org.apache.geode.logging.internal.log4j.api.LogService;
import org.apache.geode.management.ManagementException;
@@ -388,10 +385,6 @@ public class FederatingManager extends Manager {
// GII wont start at all if its interrupted
if (!Thread.currentThread().isInterrupted()) {
- // as the regions will be internal regions
- InternalRegionArguments internalRegionArguments = new
InternalRegionArguments();
- internalRegionArguments.setIsUsedForMetaRegion(true);
-
// Create anonymous stats holder for Management Regions
HasCachePerfStats monitoringRegionStats = new HasCachePerfStats() {
@@ -407,49 +400,42 @@ public class FederatingManager extends Manager {
}
};
-
internalRegionArguments.setCachePerfStatsHolder(monitoringRegionStats);
-
// Monitoring region for member is created
- AttributesFactory<String, Object> monitorAttributesFactory = new
AttributesFactory<>();
- monitorAttributesFactory.setScope(Scope.DISTRIBUTED_NO_ACK);
- monitorAttributesFactory.setDataPolicy(DataPolicy.REPLICATE);
- monitorAttributesFactory.setConcurrencyChecksEnabled(false);
+ InternalRegionFactory<String, Object> monitorFactory =
+ cache.createInternalRegionFactory();
+ monitorFactory.setScope(Scope.DISTRIBUTED_NO_ACK);
+ monitorFactory.setDataPolicy(DataPolicy.REPLICATE);
+ monitorFactory.setConcurrencyChecksEnabled(false);
ManagementCacheListener managementCacheListener =
new ManagementCacheListener(proxyFactory);
- monitorAttributesFactory.addCacheListener(managementCacheListener);
-
- RegionAttributes<String, Object> monitoringRegionAttrs =
- monitorAttributesFactory.create();
+ monitorFactory.addCacheListener(managementCacheListener);
+ monitorFactory.setIsUsedForMetaRegion(true);
+ monitorFactory.setCachePerfStatsHolder(monitoringRegionStats);
// Notification region for member is created
- AttributesFactory<NotificationKey, Notification>
notificationAttributesFactory =
- new AttributesFactory<>();
- notificationAttributesFactory.setScope(Scope.DISTRIBUTED_NO_ACK);
- notificationAttributesFactory.setDataPolicy(DataPolicy.REPLICATE);
- notificationAttributesFactory.setConcurrencyChecksEnabled(false);
+ InternalRegionFactory<NotificationKey, Notification>
notificationFactory =
+ cache.createInternalRegionFactory();
+ notificationFactory.setScope(Scope.DISTRIBUTED_NO_ACK);
+ notificationFactory.setDataPolicy(DataPolicy.REPLICATE);
+ notificationFactory.setConcurrencyChecksEnabled(false);
// Fix for issue #49638, evict the internal region
_notificationRegion
- notificationAttributesFactory
+ notificationFactory
.setEvictionAttributes(EvictionAttributes.createLRUEntryAttributes(
ManagementConstants.NOTIF_REGION_MAX_ENTRIES,
EvictionAction.LOCAL_DESTROY));
NotificationCacheListener notifListener = new
NotificationCacheListener(proxyFactory);
- notificationAttributesFactory.addCacheListener(notifListener);
-
- RegionAttributes<NotificationKey, Notification> notifRegionAttrs =
- notificationAttributesFactory.create();
+ notificationFactory.addCacheListener(notifListener);
+ notificationFactory.setIsUsedForMetaRegion(true);
+ notificationFactory.setCachePerfStatsHolder(monitoringRegionStats);
Region<String, Object> proxyMonitoringRegion;
try {
if (!running) {
return;
}
- proxyMonitoringRegion =
- cache.createInternalRegion(monitoringRegionName,
monitoringRegionAttrs,
- internalRegionArguments);
-
- } catch (TimeoutException | RegionExistsException | IOException
- | ClassNotFoundException e) {
+ proxyMonitoringRegion =
monitorFactory.create(monitoringRegionName);
+ } catch (TimeoutException | RegionExistsException e) {
if (logger.isDebugEnabled()) {
logger.debug("Error During Internal Region creation", e);
}
@@ -462,12 +448,9 @@ public class FederatingManager extends Manager {
if (!running) {
return;
}
- proxyNotificationRegion =
- cache.createInternalRegion(notificationRegionName,
notifRegionAttrs,
- internalRegionArguments);
+ proxyNotificationRegion =
notificationFactory.create(notificationRegionName);
proxyNotificationRegionCreated = true;
- } catch (TimeoutException | RegionExistsException | IOException
- | ClassNotFoundException e) {
+ } catch (TimeoutException | RegionExistsException e) {
if (logger.isDebugEnabled()) {
logger.debug("Error During Internal Region creation", e);
}
diff --git
a/geode-core/src/main/java/org/apache/geode/management/internal/LocalManager.java
b/geode-core/src/main/java/org/apache/geode/management/internal/LocalManager.java
index 556a913..b67d8f5 100644
---
a/geode-core/src/main/java/org/apache/geode/management/internal/LocalManager.java
+++
b/geode-core/src/main/java/org/apache/geode/management/internal/LocalManager.java
@@ -14,7 +14,6 @@
*/
package org.apache.geode.management.internal;
-import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
@@ -33,10 +32,8 @@ import org.apache.geode.GemFireException;
import org.apache.geode.StatisticsFactory;
import org.apache.geode.SystemFailure;
import org.apache.geode.annotations.VisibleForTesting;
-import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.CacheListener;
import org.apache.geode.cache.DataPolicy;
-import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.RegionExistsException;
import org.apache.geode.cache.Scope;
import org.apache.geode.cache.TimeoutException;
@@ -44,7 +41,7 @@ import
org.apache.geode.distributed.internal.InternalDistributedSystem;
import org.apache.geode.internal.cache.CachePerfStats;
import org.apache.geode.internal.cache.HasCachePerfStats;
import org.apache.geode.internal.cache.InternalCache;
-import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.statistics.StatisticsClock;
import org.apache.geode.logging.internal.executors.LoggingExecutors;
import org.apache.geode.logging.internal.log4j.api.LogService;
@@ -113,12 +110,6 @@ public class LocalManager extends Manager {
logger.debug("Creating Management Region :");
}
- /*
- * Sharing the same Internal Argument for both notification region and
monitoring region
- */
- InternalRegionArguments internalArgs = new InternalRegionArguments();
- internalArgs.setIsUsedForMetaRegion(true);
-
// Create anonymous stats holder for Management Regions
HasCachePerfStats monitoringRegionStats = new HasCachePerfStats() {
@@ -134,46 +125,38 @@ public class LocalManager extends Manager {
}
};
- internalArgs.setCachePerfStatsHolder(monitoringRegionStats);
-
- AttributesFactory<String, Object> monitorRegionAttributeFactory =
- new AttributesFactory<>();
- monitorRegionAttributeFactory.setScope(Scope.DISTRIBUTED_NO_ACK);
- monitorRegionAttributeFactory.setDataPolicy(DataPolicy.REPLICATE);
- monitorRegionAttributeFactory.setConcurrencyChecksEnabled(false);
+ InternalRegionFactory<String, Object> monitorFactory =
cache.createInternalRegionFactory();
+ monitorFactory.setScope(Scope.DISTRIBUTED_NO_ACK);
+ monitorFactory.setDataPolicy(DataPolicy.REPLICATE);
+ monitorFactory.setConcurrencyChecksEnabled(false);
CacheListener<String, Object> localListener = new
MonitoringRegionCacheListener(service);
- monitorRegionAttributeFactory.addCacheListener(localListener);
-
- RegionAttributes<String, Object> monitoringRegionAttrs =
- monitorRegionAttributeFactory.create();
-
- AttributesFactory<NotificationKey, Notification>
notificationRegionAttributeFactory =
- new AttributesFactory<>();
- notificationRegionAttributeFactory.setScope(Scope.DISTRIBUTED_NO_ACK);
- notificationRegionAttributeFactory.setDataPolicy(DataPolicy.EMPTY);
- notificationRegionAttributeFactory.setConcurrencyChecksEnabled(false);
-
- RegionAttributes<NotificationKey, Notification> notifRegionAttrs =
- notificationRegionAttributeFactory.create();
+ monitorFactory.addCacheListener(localListener);
+ monitorFactory.setIsUsedForMetaRegion(true);
+ monitorFactory.setCachePerfStatsHolder(monitoringRegionStats);
+
+ InternalRegionFactory<NotificationKey, Notification> notificationFactory
=
+ cache.createInternalRegionFactory();
+ notificationFactory.setScope(Scope.DISTRIBUTED_NO_ACK);
+ notificationFactory.setDataPolicy(DataPolicy.EMPTY);
+ notificationFactory.setConcurrencyChecksEnabled(false);
+ notificationFactory.setIsUsedForMetaRegion(true);
+ notificationFactory.setCachePerfStatsHolder(monitoringRegionStats);
String appender =
MBeanJMXAdapter.getUniqueIDForMember(system.getDistributedMember());
try {
repo.setLocalMonitoringRegion(
- cache.createInternalRegion(ManagementConstants.MONITORING_REGION +
"_" + appender,
- monitoringRegionAttrs, internalArgs));
-
- } catch (TimeoutException | RegionExistsException |
ClassNotFoundException | IOException e) {
+ monitorFactory.create(ManagementConstants.MONITORING_REGION + "_"
+ appender));
+ } catch (TimeoutException | RegionExistsException e) {
throw new ManagementException(e);
}
boolean notifRegionCreated = false;
try {
repo.setLocalNotificationRegion(
- cache.createInternalRegion(ManagementConstants.NOTIFICATION_REGION
+ "_" + appender,
- notifRegionAttrs, internalArgs));
+ notificationFactory.create(ManagementConstants.NOTIFICATION_REGION
+ "_" + appender));
notifRegionCreated = true;
- } catch (TimeoutException | ClassNotFoundException | IOException |
RegionExistsException e) {
+ } catch (TimeoutException | RegionExistsException e) {
throw new ManagementException(e);
} finally {
if (!notifRegionCreated) {
diff --git
a/geode-core/src/main/java/org/apache/geode/management/internal/RestAgent.java
b/geode-core/src/main/java/org/apache/geode/management/internal/RestAgent.java
index 84cce29..286061a 100644
---
a/geode-core/src/main/java/org/apache/geode/management/internal/RestAgent.java
+++
b/geode-core/src/main/java/org/apache/geode/management/internal/RestAgent.java
@@ -24,16 +24,13 @@ import java.util.Map;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.Logger;
-import org.apache.geode.cache.AttributesFactory;
-import org.apache.geode.cache.CacheFactory;
-import org.apache.geode.cache.DataPolicy;
-import org.apache.geode.cache.RegionAttributes;
-import org.apache.geode.cache.Scope;
+import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.internal.HttpService;
import org.apache.geode.distributed.internal.DistributionConfig;
import org.apache.geode.internal.GemFireVersion;
+import org.apache.geode.internal.cache.CacheFactoryStatics;
import org.apache.geode.internal.cache.InternalCache;
-import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.inet.LocalHostUtil;
import org.apache.geode.internal.security.SecurityService;
import org.apache.geode.logging.internal.log4j.api.LogService;
@@ -151,23 +148,16 @@ public class RestAgent {
if (logger.isDebugEnabled()) {
logger.debug("Starting creation of __ParameterizedQueries__ region");
}
- InternalCache cache = (InternalCache) CacheFactory.getAnyInstance();
+ InternalCache cache = CacheFactoryStatics.getAnyInstance();
if (cache != null) {
- final InternalRegionArguments regionArguments = new
InternalRegionArguments();
- regionArguments.setIsUsedForMetaRegion(true);
- final AttributesFactory<String, String> attributesFactory =
- new AttributesFactory<String, String>();
-
- attributesFactory.setConcurrencyChecksEnabled(false);
- attributesFactory.setDataPolicy(DataPolicy.REPLICATE);
- attributesFactory.setKeyConstraint(String.class);
- attributesFactory.setScope(Scope.DISTRIBUTED_ACK);
- attributesFactory.setStatisticsEnabled(false);
- attributesFactory.setValueConstraint(String.class);
-
- final RegionAttributes<String, String> regionAttributes =
attributesFactory.create();
-
- cache.createVMRegion("__ParameterizedQueries__", regionAttributes,
regionArguments);
+ InternalRegionFactory<String, String> factory =
+ cache.createInternalRegionFactory(RegionShortcut.REPLICATE);
+ factory.setConcurrencyChecksEnabled(false);
+ factory.setKeyConstraint(String.class);
+ factory.setStatisticsEnabled(false);
+ factory.setValueConstraint(String.class);
+ factory.setIsUsedForMetaRegion(true);
+ factory.create("__ParameterizedQueries__");
if (logger.isDebugEnabled()) {
logger.debug("Successfully created __ParameterizedQueries__ region");
}
diff --git
a/geode-core/src/main/java/org/apache/geode/management/internal/operation/RegionOperationStateStore.java
b/geode-core/src/main/java/org/apache/geode/management/internal/operation/RegionOperationStateStore.java
index 038184f..cc76049 100644
---
a/geode-core/src/main/java/org/apache/geode/management/internal/operation/RegionOperationStateStore.java
+++
b/geode-core/src/main/java/org/apache/geode/management/internal/operation/RegionOperationStateStore.java
@@ -23,11 +23,9 @@ import java.util.function.Supplier;
import org.apache.geode.annotations.VisibleForTesting;
import org.apache.geode.cache.Region;
-import org.apache.geode.cache.RegionFactory;
import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.internal.cache.InternalCache;
-import org.apache.geode.internal.cache.InternalRegionArguments;
-import org.apache.geode.internal.cache.RegionFactoryImpl;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.management.api.ClusterManagementOperation;
import org.apache.geode.management.runtime.OperationResult;
@@ -64,14 +62,10 @@ public class RegionOperationStateStore
return region;
}
- RegionFactory<String,
OperationState<ClusterManagementOperation<OperationResult>, OperationResult>>
regionFactory =
- cache.createRegionFactory(RegionShortcut.REPLICATE);
-
- InternalRegionArguments internalArgs = new InternalRegionArguments();
- internalArgs.setIsUsedForMetaRegion(true);
- internalArgs.setMetaRegionWithTransactions(false);
- ((RegionFactoryImpl)
regionFactory).setInternalRegionArguments(internalArgs);
-
+ InternalRegionFactory<String,
OperationState<ClusterManagementOperation<OperationResult>, OperationResult>>
regionFactory =
+ cache.createInternalRegionFactory(RegionShortcut.REPLICATE);
+ regionFactory.setIsUsedForMetaRegion(true);
+ regionFactory.setMetaRegionWithTransactions(false);
return regionFactory.create(OPERATION_STATE_REGION_NAME);
}
diff --git
a/geode-core/src/main/java/org/apache/geode/pdx/internal/PeerTypeRegistration.java
b/geode-core/src/main/java/org/apache/geode/pdx/internal/PeerTypeRegistration.java
index 52b480f..74f6a8e 100644
---
a/geode-core/src/main/java/org/apache/geode/pdx/internal/PeerTypeRegistration.java
+++
b/geode-core/src/main/java/org/apache/geode/pdx/internal/PeerTypeRegistration.java
@@ -15,7 +15,6 @@
package org.apache.geode.pdx.internal;
-import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
@@ -27,12 +26,10 @@ import org.apache.logging.log4j.Logger;
import org.apache.geode.InternalGemFireError;
import org.apache.geode.InternalGemFireException;
import org.apache.geode.annotations.VisibleForTesting;
-import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.CacheWriterException;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.EntryEvent;
import org.apache.geode.cache.Region;
-import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.RegionExistsException;
import org.apache.geode.cache.Scope;
import org.apache.geode.cache.TimeoutException;
@@ -51,7 +48,7 @@ import
org.apache.geode.distributed.internal.locks.DLockService;
import org.apache.geode.internal.CopyOnWriteHashSet;
import org.apache.geode.internal.cache.GemFireCacheImpl;
import org.apache.geode.internal.cache.InternalCache;
-import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.TXManagerImpl;
import org.apache.geode.internal.cache.TXStateProxy;
import org.apache.geode.internal.util.concurrent.CopyOnWriteHashMap;
@@ -140,8 +137,7 @@ public class PeerTypeRegistration implements
TypeRegistration {
logger.debug("Flushing TypeRegistry");
}
- @SuppressWarnings("deprecation")
- AttributesFactory<Object, Object> factory = getAttributesFactory();
+ InternalRegionFactory factory = cache.createInternalRegionFactory();
factory.setScope(Scope.DISTRIBUTED_ACK);
if (cache.getPdxPersistent()) {
@@ -198,14 +194,11 @@ public class PeerTypeRegistration implements
TypeRegistration {
});
- RegionAttributes<Object, Object> regionAttrs = factory.create();
-
- InternalRegionArguments internalArgs = new InternalRegionArguments();
- internalArgs.setIsUsedForMetaRegion(true);
- internalArgs.setMetaRegionWithTransactions(true);
+ factory.setIsUsedForMetaRegion(true);
+ factory.setMetaRegionWithTransactions(true);
try {
- idToType = cache.createVMRegion(REGION_NAME, regionAttrs, internalArgs);
- } catch (IOException | TimeoutException | RegionExistsException |
ClassNotFoundException ex) {
+ idToType = factory.create(REGION_NAME);
+ } catch (TimeoutException | RegionExistsException ex) {
throw new PdxInitializationException("Could not create pdx registry",
ex);
}
@@ -781,12 +774,6 @@ public class PeerTypeRegistration implements
TypeRegistration {
}
@VisibleForTesting
- @SuppressWarnings("deprecation")
- protected AttributesFactory<Object, Object> getAttributesFactory() {
- return new AttributesFactory<>();
- }
-
- @VisibleForTesting
public int getTypeToIdSize() {
return reverseMap.typeToIdSize();
}
diff --git
a/geode-core/src/test/java/org/apache/geode/cache/asyncqueue/internal/SerialAsyncEventQueueImplTest.java
b/geode-core/src/test/java/org/apache/geode/cache/asyncqueue/internal/SerialAsyncEventQueueImplTest.java
index 4c4aa2e..c6763ac 100644
---
a/geode-core/src/test/java/org/apache/geode/cache/asyncqueue/internal/SerialAsyncEventQueueImplTest.java
+++
b/geode-core/src/test/java/org/apache/geode/cache/asyncqueue/internal/SerialAsyncEventQueueImplTest.java
@@ -33,6 +33,7 @@ import org.apache.geode.Statistics;
import org.apache.geode.StatisticsFactory;
import org.apache.geode.distributed.DistributedLockService;
import org.apache.geode.internal.cache.InternalCache;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.LocalRegion;
import org.apache.geode.internal.cache.wan.AbstractGatewaySenderEventProcessor;
import org.apache.geode.internal.cache.wan.GatewaySenderAdvisor;
@@ -53,12 +54,15 @@ public class SerialAsyncEventQueueImplTest {
private StatisticsFactory statisticsFactory;
private GatewaySenderAttributes gatewaySenderAttributes;
private StatisticsClock statisticsClock;
+ private InternalRegionFactory regionFactory;
@Before
public void setUp() throws Exception {
cache = Fakes.cache();
when(cache.getRegion(any())).thenReturn(null);
- when(cache.createVMRegion(any(), any(),
any())).thenReturn(mock(LocalRegion.class));
+ regionFactory = mock(InternalRegionFactory.class);
+ when(regionFactory.create(any())).thenReturn(mock(LocalRegion.class));
+ when(cache.createInternalRegionFactory(any())).thenReturn(regionFactory);
statisticsFactory = mock(StatisticsFactory.class);
when(statisticsFactory.createAtomicStatistics(any(),
any())).thenReturn(mock(Statistics.class));
diff --git
a/geode-core/src/test/java/org/apache/geode/internal/cache/RegionFactoryImplTest.java
b/geode-core/src/test/java/org/apache/geode/internal/cache/InternalRegionFactoryTest.java
similarity index 54%
rename from
geode-core/src/test/java/org/apache/geode/internal/cache/RegionFactoryImplTest.java
rename to
geode-core/src/test/java/org/apache/geode/internal/cache/InternalRegionFactoryTest.java
index d881f58..89e3531 100644
---
a/geode-core/src/test/java/org/apache/geode/internal/cache/RegionFactoryImplTest.java
+++
b/geode-core/src/test/java/org/apache/geode/internal/cache/InternalRegionFactoryTest.java
@@ -27,7 +27,7 @@ import org.junit.Test;
import org.apache.geode.cache.Region;
-public class RegionFactoryImplTest {
+public class InternalRegionFactoryTest {
private InternalCache cache;
@Before
@@ -37,21 +37,22 @@ public class RegionFactoryImplTest {
@Test
public void createWithInternalRegionArgumentsCallsCreateVMRegion() throws
Exception {
- RegionFactoryImpl<Object, Object> regionFactory = new
RegionFactoryImpl<>(cache);
- InternalRegionArguments internalRegionArguments =
mock(InternalRegionArguments.class);
- regionFactory.setInternalRegionArguments(internalRegionArguments);
+ InternalRegionFactory<Object, Object> regionFactory = new
InternalRegionFactory<>(cache);
+ regionFactory.setInternalRegion(true);
+ InternalRegionArguments internalRegionArguments =
regionFactory.getInternalRegionArguments();
String regionName = "regionName";
regionFactory.create(regionName);
+ assertThat(internalRegionArguments).isNotNull();
verify(cache).createVMRegion(same(regionName), any(),
same(internalRegionArguments));
}
@Test
public void createWithInternalRegionArgumentsReturnsRegion() throws
Exception {
- RegionFactoryImpl<Object, Object> regionFactory = new
RegionFactoryImpl<>(cache);
- InternalRegionArguments internalRegionArguments =
mock(InternalRegionArguments.class);
- regionFactory.setInternalRegionArguments(internalRegionArguments);
+ InternalRegionFactory<Object, Object> regionFactory = new
InternalRegionFactory<>(cache);
+ regionFactory.setInternalRegion(true);
+ InternalRegionArguments internalRegionArguments =
regionFactory.getInternalRegionArguments();
String regionName = "regionName";
Region<Object, Object> expectedRegion = mock(Region.class);
when(cache.createVMRegion(same(regionName), any(),
same(internalRegionArguments)))
@@ -64,12 +65,39 @@ public class RegionFactoryImplTest {
@Test
public void createWithoutInternalRegionArgumentsCallsCreateRegion() throws
Exception {
- RegionFactoryImpl<Object, Object> regionFactory = new
RegionFactoryImpl<>(cache);
- regionFactory.setInternalRegionArguments(null);
+ InternalRegionFactory<Object, Object> regionFactory = new
InternalRegionFactory<>(cache);
String regionName = "regionName";
regionFactory.create(regionName);
verify(cache).createRegion(same(regionName), any());
}
+
+ @Test
+ public void createSubregionWithInternalRegionArgumentsReturnsRegion() throws
Exception {
+ InternalRegionFactory<Object, Object> regionFactory = new
InternalRegionFactory<>(cache);
+ regionFactory.setInternalRegion(true);
+ InternalRegionArguments internalRegionArguments =
regionFactory.getInternalRegionArguments();
+ String regionName = "regionName";
+ Region<Object, Object> expectedRegion = mock(Region.class);
+ InternalRegion parent = mock(InternalRegion.class);
+ when(parent.createSubregion(same(regionName), any(),
same(internalRegionArguments)))
+ .thenReturn(expectedRegion);
+
+ Region<Object, Object> region = regionFactory.createSubregion(parent,
regionName);
+
+ assertThat(region).isSameAs(expectedRegion);
+ }
+
+ @Test
+ public void
createSubregionWithoutInternalRegionArgumentsCallsParentCreateSubregion()
+ throws Exception {
+ InternalRegionFactory<Object, Object> regionFactory = new
InternalRegionFactory<>(cache);
+ String regionName = "regionName";
+ Region<?, ?> parent = mock(InternalRegion.class);
+
+ regionFactory.createSubregion(parent, regionName);
+
+ verify(parent).createSubregion(same(regionName), any());
+ }
}
diff --git
a/geode-core/src/test/java/org/apache/geode/internal/cache/wan/parallel/ParallelGatewaySenderQueueJUnitTest.java
b/geode-core/src/test/java/org/apache/geode/internal/cache/wan/parallel/ParallelGatewaySenderQueueJUnitTest.java
index 88c3e45..e7ca1a3 100644
---
a/geode-core/src/test/java/org/apache/geode/internal/cache/wan/parallel/ParallelGatewaySenderQueueJUnitTest.java
+++
b/geode-core/src/test/java/org/apache/geode/internal/cache/wan/parallel/ParallelGatewaySenderQueueJUnitTest.java
@@ -42,6 +42,7 @@ import
org.apache.geode.internal.cache.AbstractBucketRegionQueue;
import org.apache.geode.internal.cache.BucketRegionQueue;
import org.apache.geode.internal.cache.DistributedRegion;
import org.apache.geode.internal.cache.GemFireCacheImpl;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.PartitionedRegion;
import org.apache.geode.internal.cache.PartitionedRegionDataStore;
import org.apache.geode.internal.cache.wan.AbstractGatewaySender;
@@ -150,7 +151,9 @@ public class ParallelGatewaySenderQueueJUnitTest {
when(mockMetaRegion.getDataStore()).thenReturn(dataStore);
when(dataStore.getSizeOfLocalPrimaryBuckets()).thenReturn(3);
when(metaRegionFactory.newMetataRegion(any(), any(), any(),
any())).thenReturn(mockMetaRegion);
- when(cache.createVMRegion(any(), any(), any())).thenReturn(mockMetaRegion);
+ InternalRegionFactory regionFactory = mock(InternalRegionFactory.class);
+ when(regionFactory.create(any())).thenReturn(mockMetaRegion);
+ when(cache.createInternalRegionFactory(any())).thenReturn(regionFactory);
queue.addShadowPartitionedRegionForUserPR(mockPR("region1"));
diff --git
a/geode-core/src/test/java/org/apache/geode/management/internal/FederatingManagerTest.java
b/geode-core/src/test/java/org/apache/geode/management/internal/FederatingManagerTest.java
index e6f9601..1b89f79 100644
---
a/geode-core/src/test/java/org/apache/geode/management/internal/FederatingManagerTest.java
+++
b/geode-core/src/test/java/org/apache/geode/management/internal/FederatingManagerTest.java
@@ -42,9 +42,10 @@ import
org.apache.geode.distributed.DistributedSystemDisconnectedException;
import org.apache.geode.distributed.internal.DistributionManager;
import org.apache.geode.distributed.internal.InternalDistributedSystem;
import
org.apache.geode.distributed.internal.membership.InternalDistributedMember;
+import org.apache.geode.internal.cache.HasCachePerfStats;
import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.cache.InternalCacheForClientAccess;
-import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.statistics.StatisticsClock;
import org.apache.geode.management.DistributedSystemMXBean;
import org.apache.geode.test.junit.categories.JMXTest;
@@ -63,6 +64,8 @@ public class FederatingManagerTest {
private StatisticsFactory statisticsFactory;
private StatisticsClock statisticsClock;
private InternalDistributedSystem system;
+ private InternalRegionFactory regionFactory1;
+ private InternalRegionFactory regionFactory2;
@Before
public void setUp() throws Exception {
@@ -77,13 +80,17 @@ public class FederatingManagerTest {
statisticsClock = mock(StatisticsClock.class);
statisticsFactory = mock(StatisticsFactory.class);
system = mock(InternalDistributedSystem.class);
+ regionFactory1 = mock(InternalRegionFactory.class);
+ regionFactory2 = mock(InternalRegionFactory.class);
DistributedSystemMXBean distributedSystemMXBean =
mock(DistributedSystemMXBean.class);
when(cache.getCacheForProcessingClientRequests())
.thenReturn(cacheForClientAccess);
- when(cacheForClientAccess.createInternalRegion(any(), any(), any()))
- .thenReturn(mock(Region.class));
+
when(cacheForClientAccess.createInternalRegionFactory()).thenReturn(regionFactory1)
+ .thenReturn(regionFactory2);
+ when(regionFactory1.create(any())).thenReturn(mock(Region.class));
+ when(regionFactory2.create(any())).thenReturn(mock(Region.class));
when(distributedSystemMXBean.getAlertLevel())
.thenReturn(AlertLevel.WARNING.name());
when(jmxAdapter.getDistributedSystemMXBean())
@@ -100,8 +107,7 @@ public class FederatingManagerTest {
federatingManager.addMemberArtifacts(member(1, 20));
- verify(cacheForClientAccess)
- .createInternalRegion(eq("_monitoringRegion_null<v1>20"), any(),
any());
+ verify(regionFactory1).create(eq("_monitoringRegion_null<v1>20"));
}
@Test
@@ -112,43 +118,35 @@ public class FederatingManagerTest {
federatingManager.addMemberArtifacts(member(2, 40));
- ArgumentCaptor<InternalRegionArguments> captor =
- ArgumentCaptor.forClass(InternalRegionArguments.class);
- verify(cacheForClientAccess)
- .createInternalRegion(eq("_monitoringRegion_null<v2>40"), any(),
captor.capture());
- boolean hasOwnStats =
captor.getValue().getCachePerfStatsHolder().hasOwnStats();
- assertThat(hasOwnStats)
- .isTrue();
+ ArgumentCaptor<HasCachePerfStats> captor =
+ ArgumentCaptor.forClass(HasCachePerfStats.class);
+ verify(regionFactory1).setCachePerfStatsHolder(captor.capture());
+ assertThat(captor.getValue().hasOwnStats()).isTrue();
}
@Test
- public void addMemberArtifactsCreatesNotificationRegion() throws Exception {
+ public void addMemberArtifactsCreatesNotificationRegion() {
FederatingManager federatingManager = new FederatingManager(repo, system,
service, cache,
statisticsFactory, statisticsClock, proxyFactory, messenger,
executorService);
federatingManager.startManager();
federatingManager.addMemberArtifacts(member(3, 60));
- verify(cacheForClientAccess)
- .createInternalRegion(eq("_notificationRegion_null<v3>60"), any(),
any());
+ verify(regionFactory2).create(eq("_notificationRegion_null<v3>60"));
}
@Test
- public void addMemberArtifactsCreatesNotificationRegionWithHasOwnStats()
throws Exception {
+ public void addMemberArtifactsCreatesNotificationRegionWithHasOwnStats() {
FederatingManager federatingManager = new FederatingManager(repo, system,
service, cache,
statisticsFactory, statisticsClock, proxyFactory, messenger,
executorService);
federatingManager.startManager();
federatingManager.addMemberArtifacts(member(4, 80));
- ArgumentCaptor<InternalRegionArguments> captor =
- ArgumentCaptor.forClass(InternalRegionArguments.class);
- verify(cacheForClientAccess)
- .createInternalRegion(eq("_notificationRegion_null<v4>80"), any(),
captor.capture());
-
- InternalRegionArguments internalRegionArguments = captor.getValue();
- assertThat(internalRegionArguments.getCachePerfStatsHolder().hasOwnStats())
- .isTrue();
+ ArgumentCaptor<HasCachePerfStats> captor =
+ ArgumentCaptor.forClass(HasCachePerfStats.class);
+ verify(regionFactory2).setCachePerfStatsHolder(captor.capture());
+ assertThat(captor.getValue().hasOwnStats()).isTrue();
}
@Test
diff --git
a/geode-core/src/test/java/org/apache/geode/management/internal/LocalManagerTest.java
b/geode-core/src/test/java/org/apache/geode/management/internal/LocalManagerTest.java
index 451cc9a..a39c8d0 100644
---
a/geode-core/src/test/java/org/apache/geode/management/internal/LocalManagerTest.java
+++
b/geode-core/src/test/java/org/apache/geode/management/internal/LocalManagerTest.java
@@ -16,7 +16,6 @@ package org.apache.geode.management.internal;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.powermock.api.mockito.PowerMockito.when;
@@ -37,7 +36,7 @@ import
org.apache.geode.distributed.internal.membership.InternalDistributedMembe
import org.apache.geode.internal.cache.HasCachePerfStats;
import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.cache.InternalCacheForClientAccess;
-import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.statistics.StatisticsClock;
import org.apache.geode.management.DistributedSystemMXBean;
@@ -47,6 +46,8 @@ public class LocalManagerTest {
private InternalDistributedSystem system;
private SystemManagementService service;
private InternalCache cache;
+ private InternalRegionFactory regionFactory1;
+ private InternalRegionFactory regionFactory2;
private StatisticsFactory statisticsFactory;
private StatisticsClock statisticsClock;
private InternalCacheForClientAccess cacheForClientAccess;
@@ -57,6 +58,8 @@ public class LocalManagerTest {
system = mock(InternalDistributedSystem.class);
service = mock(SystemManagementService.class);
cache = mock(InternalCache.class);
+ regionFactory1 = mock(InternalRegionFactory.class);
+ regionFactory2 = mock(InternalRegionFactory.class);
statisticsFactory = mock(StatisticsFactory.class);
statisticsClock = mock(StatisticsClock.class);
cacheForClientAccess = mock(InternalCacheForClientAccess.class);
@@ -65,8 +68,10 @@ public class LocalManagerTest {
when(cache.getCacheForProcessingClientRequests())
.thenReturn(cacheForClientAccess);
- when(cacheForClientAccess.createInternalRegion(any(), any(), any()))
- .thenReturn(mock(Region.class));
+ when(cacheForClientAccess.createInternalRegionFactory())
+ .thenReturn(regionFactory1).thenReturn(regionFactory2);
+ when(regionFactory1.create(any())).thenReturn(mock(Region.class));
+ when(regionFactory2.create(any())).thenReturn(mock(Region.class));
when(config.getJmxManagerUpdateRate())
.thenReturn(Integer.MAX_VALUE);
when(distributedSystemMXBean.getAlertLevel())
@@ -86,8 +91,7 @@ public class LocalManagerTest {
localManager.startManager();
-
verify(cacheForClientAccess).createInternalRegion(eq("_monitoringRegion_null<v1>20"),
any(),
- any());
+ verify(regionFactory1).create("_monitoringRegion_null<v1>20");
}
@Test
@@ -99,14 +103,10 @@ public class LocalManagerTest {
localManager.startManager();
- ArgumentCaptor<InternalRegionArguments> captor =
- ArgumentCaptor.forClass(InternalRegionArguments.class);
-
verify(cacheForClientAccess).createInternalRegion(eq("_monitoringRegion_null<v2>40"),
any(),
- captor.capture());
-
- InternalRegionArguments internalRegionArguments = captor.getValue();
- HasCachePerfStats hasCachePerfStats =
internalRegionArguments.getCachePerfStatsHolder();
- assertThat(hasCachePerfStats.hasOwnStats()).isTrue();
+ ArgumentCaptor<HasCachePerfStats> captor =
+ ArgumentCaptor.forClass(HasCachePerfStats.class);
+ verify(regionFactory1).setCachePerfStatsHolder(captor.capture());
+ assertThat(captor.getValue().hasOwnStats()).isTrue();
}
@Test
@@ -118,8 +118,7 @@ public class LocalManagerTest {
localManager.startManager();
-
verify(cacheForClientAccess).createInternalRegion(eq("_notificationRegion_null<v3>60"),
any(),
- any());
+ verify(regionFactory2).create("_notificationRegion_null<v3>60");
}
@Test
@@ -131,14 +130,10 @@ public class LocalManagerTest {
localManager.startManager();
- ArgumentCaptor<InternalRegionArguments> captor =
- ArgumentCaptor.forClass(InternalRegionArguments.class);
-
verify(cacheForClientAccess).createInternalRegion(eq("_notificationRegion_null<v4>80"),
any(),
- captor.capture());
-
- InternalRegionArguments internalRegionArguments = captor.getValue();
- HasCachePerfStats hasCachePerfStats =
internalRegionArguments.getCachePerfStatsHolder();
- assertThat(hasCachePerfStats.hasOwnStats()).isTrue();
+ ArgumentCaptor<HasCachePerfStats> captor =
+ ArgumentCaptor.forClass(HasCachePerfStats.class);
+ verify(regionFactory2).setCachePerfStatsHolder(captor.capture());
+ assertThat(captor.getValue().hasOwnStats()).isTrue();
}
private InternalDistributedMember member(int viewId, int port) {
diff --git
a/geode-core/src/test/java/org/apache/geode/management/internal/operation/RegionOperationStateStoreTest.java
b/geode-core/src/test/java/org/apache/geode/management/internal/operation/RegionOperationStateStoreTest.java
index 5a0676f..9f47b1e 100644
---
a/geode-core/src/test/java/org/apache/geode/management/internal/operation/RegionOperationStateStoreTest.java
+++
b/geode-core/src/test/java/org/apache/geode/management/internal/operation/RegionOperationStateStoreTest.java
@@ -38,7 +38,7 @@ import org.apache.geode.cache.DiskStoreFactory;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.internal.cache.InternalCache;
-import org.apache.geode.internal.cache.RegionFactoryImpl;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.management.api.ClusterManagementOperation;
import org.apache.geode.management.runtime.OperationResult;
@@ -159,8 +159,8 @@ public class RegionOperationStateStoreTest {
when(diskStoreFactory.setDiskDirs(any())).thenReturn(diskStoreFactory);
when(diskStoreFactory.setAutoCompact(true)).thenReturn(diskStoreFactory);
when(diskStoreFactory.setMaxOplogSize(10)).thenReturn(diskStoreFactory);
- RegionFactoryImpl regionFactory = mock(RegionFactoryImpl.class);
-
when(cache.createRegionFactory(eq(RegionShortcut.REPLICATE))).thenReturn(regionFactory);
+ InternalRegionFactory regionFactory = mock(InternalRegionFactory.class);
+
when(cache.createInternalRegionFactory(eq(RegionShortcut.REPLICATE))).thenReturn(regionFactory);
Region region = mock(Region.class);
when(regionFactory.create(OPERATION_STATE_REGION_NAME)).thenReturn(region);
diff --git
a/geode-core/src/test/java/org/apache/geode/pdx/internal/PeerTypeRegistrationTest.java
b/geode-core/src/test/java/org/apache/geode/pdx/internal/PeerTypeRegistrationTest.java
index 9729841..cc59d08 100644
---
a/geode-core/src/test/java/org/apache/geode/pdx/internal/PeerTypeRegistrationTest.java
+++
b/geode-core/src/test/java/org/apache/geode/pdx/internal/PeerTypeRegistrationTest.java
@@ -38,15 +38,16 @@ import org.mockito.internal.util.reflection.FieldSetter;
import org.apache.geode.CancelCriterion;
import org.apache.geode.Statistics;
import org.apache.geode.StatisticsType;
-import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.Region;
+import org.apache.geode.cache.RegionExistsException;
import org.apache.geode.distributed.DistributedLockService;
import org.apache.geode.distributed.internal.DistributionManager;
import org.apache.geode.distributed.internal.InternalDistributedSystem;
import org.apache.geode.internal.cache.CacheConfig;
import org.apache.geode.internal.cache.DiskStoreImpl;
import org.apache.geode.internal.cache.InternalCache;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.TXManagerImpl;
import org.apache.geode.internal.cache.TXStateProxy;
import org.apache.geode.internal.statistics.StatisticsManager;
@@ -64,8 +65,7 @@ public class PeerTypeRegistrationTest {
@SuppressWarnings("unchecked")
private final Region<Object, Object> region = mock(Region.class);
private final TXManagerImpl txManager = mock(TXManagerImpl.class);
- @SuppressWarnings("deprecation")
- private final AttributesFactory factory = mock(AttributesFactory.class);
+ private final InternalRegionFactory factory =
mock(InternalRegionFactory.class);
@Before
public void setUp() throws IOException, ClassNotFoundException {
@@ -74,8 +74,8 @@ public class PeerTypeRegistrationTest {
when(statisticsManager.createAtomicStatistics(any(),
any())).thenReturn(statistics);
when(internalDistributedSystem.getStatisticsManager()).thenReturn(statisticsManager);
when(internalCache.getInternalDistributedSystem()).thenReturn(internalDistributedSystem);
- when(internalCache.createVMRegion(eq(PeerTypeRegistration.REGION_NAME),
any(), any()))
- .thenReturn(region);
+ when(internalCache.createInternalRegionFactory()).thenReturn(factory);
+
when(factory.create(eq(PeerTypeRegistration.REGION_NAME))).thenReturn(region);
when(region.getRegionService()).thenReturn(internalCache);
when(internalCache.getCacheTransactionManager()).thenReturn(txManager);
}
@@ -124,7 +124,7 @@ public class PeerTypeRegistrationTest {
@Test
public void pdxPersistenceIsSetWithUserDefinedDiskStore() throws
NoSuchFieldException {
PeerTypeRegistration peerTypeRegistration = spy(new
PeerTypeRegistration(internalCache));
- doReturn(factory).when(peerTypeRegistration).getAttributesFactory();
+ doReturn(factory).when(internalCache).createRegionFactory();
when(internalCache.getPdxPersistent()).thenReturn(true);
CacheConfig config = mock(CacheConfig.class);
when(internalCache.getCacheConfig()).thenReturn(config);
@@ -142,7 +142,7 @@ public class PeerTypeRegistrationTest {
@Test
public void pdxPersistenceIsSetWithDefaultDiskStore() {
PeerTypeRegistration peerTypeRegistration = spy(new
PeerTypeRegistration(internalCache));
- doReturn(factory).when(peerTypeRegistration).getAttributesFactory();
+ doReturn(factory).when(internalCache).createRegionFactory();
when(internalCache.getPdxPersistent()).thenReturn(true);
CacheConfig config = mock(CacheConfig.class);
when(internalCache.getCacheConfig()).thenReturn(config);
@@ -161,7 +161,7 @@ public class PeerTypeRegistrationTest {
@Test
public void pdxPersistenceIsNotSetWhenPdxPersistenceIsFalse() {
PeerTypeRegistration peerTypeRegistration = spy(new
PeerTypeRegistration(internalCache));
- doReturn(factory).when(peerTypeRegistration).getAttributesFactory();
+ doReturn(factory).when(internalCache).createRegionFactory();
peerTypeRegistration.initialize();
@@ -172,7 +172,7 @@ public class PeerTypeRegistrationTest {
@Test(expected = PdxInitializationException.class)
public void
pdxInitializationExceptionIsThrownInInitializeWhenRegionCreationFails()
throws IOException, ClassNotFoundException {
- doThrow(new IOException()).when(internalCache).createVMRegion(any(),
any(), any());
+ doThrow(new RegionExistsException(region)).when(factory).create(any());
PeerTypeRegistration peerTypeRegistration = new
PeerTypeRegistration(internalCache);
peerTypeRegistration.initialize();
}
diff --git
a/geode-dunit/src/main/java/org/apache/geode/management/internal/cli/commands/ExportLogsDistributedTestBase.java
b/geode-dunit/src/main/java/org/apache/geode/management/internal/cli/commands/ExportLogsDistributedTestBase.java
index 7fb86bb..f9d4c44 100644
---
a/geode-dunit/src/main/java/org/apache/geode/management/internal/cli/commands/ExportLogsDistributedTestBase.java
+++
b/geode-dunit/src/main/java/org/apache/geode/management/internal/cli/commands/ExportLogsDistributedTestBase.java
@@ -248,7 +248,7 @@ public class ExportLogsDistributedTestBase {
}
@Test
- public void exportLogsRegionIsCleanedUpProperly() throws IOException,
ClassNotFoundException {
+ public void exportLogsRegionIsCleanedUpProperly() {
locator.invoke(() -> {
GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
ExportLogsFunction.createOrGetExistingExportLogsRegion(true, cache);
diff --git
a/geode-experimental-driver/src/integrationTest/java/org/apache/geode/experimental/driver/AuthorizationTest.java
b/geode-experimental-driver/src/integrationTest/java/org/apache/geode/experimental/driver/AuthorizationTest.java
index 44f2fe5..b6ba552 100644
---
a/geode-experimental-driver/src/integrationTest/java/org/apache/geode/experimental/driver/AuthorizationTest.java
+++
b/geode-experimental-driver/src/integrationTest/java/org/apache/geode/experimental/driver/AuthorizationTest.java
@@ -29,15 +29,14 @@ import org.junit.experimental.categories.Category;
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.CacheFactory;
-import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.server.CacheServer;
import org.apache.geode.distributed.ConfigurationProperties;
import org.apache.geode.distributed.Locator;
import org.apache.geode.examples.SimpleSecurityManager;
-import org.apache.geode.internal.cache.GemFireCacheImpl;
-import org.apache.geode.internal.cache.InternalRegionArguments;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalCache;
+import org.apache.geode.internal.cache.InternalRegion;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.test.junit.categories.ClientServerTest;
@Category({ClientServerTest.class})
@@ -76,14 +75,11 @@ public class AuthorizationTest {
@Test
public void performOperationsOnInternalRegion() throws Exception {
// we need to use internal APIs to create an "internal" region
- GemFireCacheImpl serverCache = (GemFireCacheImpl) cache;
- InternalRegionArguments internalRegionArguments = new
InternalRegionArguments();
- internalRegionArguments.setIsUsedForPartitionedRegionAdmin(true);
- RegionAttributes<String, String> attributes =
- serverCache.getRegionAttributes(RegionShortcut.REPLICATE.toString());
- LocalRegion serverRegion =
- (LocalRegion) serverCache.createVMRegion("internalRegion", attributes,
- internalRegionArguments);
+ InternalCache serverCache = (InternalCache) cache;
+ InternalRegionFactory<String, String> regionFactory =
+ serverCache.createInternalRegionFactory(RegionShortcut.REPLICATE);
+ regionFactory.setIsUsedForPartitionedRegionAdmin(true);
+ InternalRegion serverRegion = (InternalRegion)
regionFactory.create("internalRegion");
assertThat(serverRegion.isInternalRegion()).isTrue();
CacheServer server = cache.addCacheServer();
diff --git
a/geode-gfsh/src/integrationTest/java/org/apache/geode/management/internal/cli/functions/ExportLogsFunctionIntegrationTest.java
b/geode-gfsh/src/integrationTest/java/org/apache/geode/management/internal/cli/functions/ExportLogsFunctionIntegrationTest.java
index c19205b..7a678de 100644
---
a/geode-gfsh/src/integrationTest/java/org/apache/geode/management/internal/cli/functions/ExportLogsFunctionIntegrationTest.java
+++
b/geode-gfsh/src/integrationTest/java/org/apache/geode/management/internal/cli/functions/ExportLogsFunctionIntegrationTest.java
@@ -64,14 +64,14 @@ public class ExportLogsFunctionIntegrationTest {
}
@Test
- public void createOrGetExistingExportLogsRegionDoesNotBlowUp() throws
Exception {
+ public void createOrGetExistingExportLogsRegionDoesNotBlowUp() {
GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
ExportLogsFunction.createOrGetExistingExportLogsRegion(false, cache);
assertThat(cache.getRegion(ExportLogsFunction.EXPORT_LOGS_REGION)).isNotNull();
}
@Test
- public void destroyExportLogsRegionWorksAsExpectedForInitiatingMember()
throws Exception {
+ public void destroyExportLogsRegionWorksAsExpectedForInitiatingMember() {
GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
ExportLogsFunction.createOrGetExistingExportLogsRegion(true, cache);
assertThat(cache.getRegion(ExportLogsFunction.EXPORT_LOGS_REGION)).isNotNull();
diff --git
a/geode-gfsh/src/main/java/org/apache/geode/management/internal/cli/functions/ExportLogsFunction.java
b/geode-gfsh/src/main/java/org/apache/geode/management/internal/cli/functions/ExportLogsFunction.java
index 2706deb..3e07dcb 100644
---
a/geode-gfsh/src/main/java/org/apache/geode/management/internal/cli/functions/ExportLogsFunction.java
+++
b/geode-gfsh/src/main/java/org/apache/geode/management/internal/cli/functions/ExportLogsFunction.java
@@ -17,7 +17,6 @@ package org.apache.geode.management.internal.cli.functions;
import java.io.File;
import java.io.FileInputStream;
-import java.io.IOException;
import java.io.Serializable;
import java.nio.file.Path;
import java.text.ParseException;
@@ -30,15 +29,13 @@ import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.Logger;
-import org.apache.geode.cache.AttributesFactory;
-import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.Region;
-import org.apache.geode.cache.Scope;
+import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.execute.FunctionContext;
import org.apache.geode.distributed.internal.DistributionConfig;
import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.cache.InternalCacheForClientAccess;
-import org.apache.geode.internal.cache.InternalRegionArguments;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.execute.InternalFunction;
import org.apache.geode.logging.internal.log4j.LogLevel;
import org.apache.geode.logging.internal.log4j.api.LogService;
@@ -46,7 +43,6 @@ import
org.apache.geode.management.internal.cli.commands.ExportLogsCommand;
import org.apache.geode.management.internal.cli.util.ExportLogsCacheWriter;
import org.apache.geode.management.internal.cli.util.LogExporter;
import org.apache.geode.management.internal.cli.util.LogFilter;
-import org.apache.geode.management.internal.configuration.domain.Configuration;
/**
* this function extracts the logs using a LogExporter which creates a zip
file, and then writes the
@@ -120,23 +116,18 @@ public class ExportLogsFunction implements
InternalFunction {
}
public static Region createOrGetExistingExportLogsRegion(boolean
isInitiatingMember,
- InternalCache cache) throws IOException, ClassNotFoundException {
+ InternalCache cache) {
InternalCacheForClientAccess cacheForClientAccess =
cache.getCacheForProcessingClientRequests();
Region exportLogsRegion =
cacheForClientAccess.getInternalRegion(EXPORT_LOGS_REGION);
if (exportLogsRegion == null) {
- AttributesFactory<String, Configuration> regionAttrsFactory = new
AttributesFactory<>();
- regionAttrsFactory.setDataPolicy(DataPolicy.EMPTY);
- regionAttrsFactory.setScope(Scope.DISTRIBUTED_ACK);
-
+ InternalRegionFactory<Object, Object> regionFactory =
+
cacheForClientAccess.createInternalRegionFactory(RegionShortcut.REPLICATE_PROXY);
if (isInitiatingMember) {
- regionAttrsFactory.setCacheWriter(new ExportLogsCacheWriter());
+ regionFactory.setCacheWriter(new ExportLogsCacheWriter());
}
- InternalRegionArguments internalArgs = new InternalRegionArguments();
- internalArgs.setIsUsedForMetaRegion(true);
- exportLogsRegion =
- cacheForClientAccess.createInternalRegion(EXPORT_LOGS_REGION,
regionAttrsFactory.create(),
- internalArgs);
+ regionFactory.setIsUsedForMetaRegion(true);
+ exportLogsRegion = regionFactory.create(EXPORT_LOGS_REGION);
}
return exportLogsRegion;
diff --git
a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/internal/PartitionedRepositoryManagerJUnitTest.java
b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/internal/PartitionedRepositoryManagerJUnitTest.java
index ab99a3a..4a166a4 100644
---
a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/internal/PartitionedRepositoryManagerJUnitTest.java
+++
b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/internal/PartitionedRepositoryManagerJUnitTest.java
@@ -60,6 +60,7 @@ import org.apache.geode.internal.cache.BucketRegion;
import org.apache.geode.internal.cache.CacheDistributionAdvisor;
import org.apache.geode.internal.cache.DistributedRegion;
import org.apache.geode.internal.cache.GemFireCacheImpl;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.cache.PartitionRegionConfig;
import org.apache.geode.internal.cache.PartitionedRegion;
import org.apache.geode.internal.cache.PartitionedRegion.RetryTimeKeeper;
@@ -136,7 +137,9 @@ public class PartitionedRepositoryManagerJUnitTest {
CacheDistributionAdvisor cda = mock(CacheDistributionAdvisor.class);
when(prRoot.getDistributionAdvisor()).thenReturn(cda);
doNothing().when(cda).addMembershipListener(any());
- when(cache.createVMRegion(eq(PR_ROOT_REGION_NAME), any(),
any())).thenReturn(prRoot);
+ InternalRegionFactory regionFactory = mock(InternalRegionFactory.class);
+ when(regionFactory.create(eq(PR_ROOT_REGION_NAME))).thenReturn(prRoot);
+ when(cache.createInternalRegionFactory(any())).thenReturn(regionFactory);
prConfig = Mockito.mock(PartitionRegionConfig.class);
when(prConfig.isColocationComplete()).thenReturn(true);
diff --git
a/geode-redis/src/main/java/org/apache/geode/redis/GeodeRedisServer.java
b/geode-redis/src/main/java/org/apache/geode/redis/GeodeRedisServer.java
index 0c639e5..27748de 100644
--- a/geode-redis/src/main/java/org/apache/geode/redis/GeodeRedisServer.java
+++ b/geode-redis/src/main/java/org/apache/geode/redis/GeodeRedisServer.java
@@ -46,7 +46,6 @@ import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.channel.socket.oio.OioServerSocketChannel;
import io.netty.util.concurrent.Future;
-import org.apache.geode.InternalGemFireError;
import org.apache.geode.LogWriter;
import org.apache.geode.annotations.Experimental;
import org.apache.geode.annotations.internal.MakeNotStatic;
@@ -62,8 +61,7 @@ import org.apache.geode.cache.util.CacheListenerAdapter;
import org.apache.geode.distributed.internal.InternalDistributedSystem;
import org.apache.geode.internal.cache.GemFireCacheImpl;
import org.apache.geode.internal.cache.InternalCache;
-import org.apache.geode.internal.cache.InternalRegionArguments;
-import org.apache.geode.internal.cache.xmlcache.RegionAttributesCreation;
+import org.apache.geode.internal.cache.InternalRegionFactory;
import org.apache.geode.internal.hll.HyperLogLogPlus;
import org.apache.geode.internal.inet.LocalHostUtil;
import org.apache.geode.redis.internal.ByteArrayWrapper;
@@ -420,35 +418,25 @@ public class GeodeRedisServer {
Region<ByteArrayWrapper, ByteArrayWrapper> stringsRegion;
Region<ByteArrayWrapper, HyperLogLogPlus> hLLRegion;
- Region<String, RedisDataType> redisMetaData;
+ Region redisMetaData;
InternalCache gemFireCache = (InternalCache) cache;
- try {
- if ((stringsRegion = cache.getRegion(STRING_REGION)) == null) {
- RegionFactory<ByteArrayWrapper, ByteArrayWrapper> regionFactory =
- gemFireCache.createRegionFactory(this.DEFAULT_REGION_TYPE);
- stringsRegion = regionFactory.create(STRING_REGION);
- }
- if ((hLLRegion = cache.getRegion(HLL_REGION)) == null) {
- RegionFactory<ByteArrayWrapper, HyperLogLogPlus> regionFactory =
- gemFireCache.createRegionFactory(this.DEFAULT_REGION_TYPE);
- hLLRegion = regionFactory.create(HLL_REGION);
- }
- if ((redisMetaData = cache.getRegion(REDIS_META_DATA_REGION)) == null)
{
- RegionAttributesCreation regionAttributesCreation = new
RegionAttributesCreation();
- regionAttributesCreation.addCacheListener(metaListener);
- regionAttributesCreation.setDataPolicy(DataPolicy.REPLICATE);
- InternalRegionArguments ira =
- new
InternalRegionArguments().setInternalRegion(true).setIsUsedForMetaRegion(true);
- redisMetaData =
- gemFireCache.createVMRegion(REDIS_META_DATA_REGION,
regionAttributesCreation, ira);
- }
-
- } catch (IOException | ClassNotFoundException e) {
- // only if loading snapshot, not here
- InternalGemFireError assErr = new InternalGemFireError(
- "unexpected exception");
- assErr.initCause(e);
- throw assErr;
+ if ((stringsRegion = cache.getRegion(STRING_REGION)) == null) {
+ RegionFactory<ByteArrayWrapper, ByteArrayWrapper> regionFactory =
+ gemFireCache.createRegionFactory(this.DEFAULT_REGION_TYPE);
+ stringsRegion = regionFactory.create(STRING_REGION);
+ }
+ if ((hLLRegion = cache.getRegion(HLL_REGION)) == null) {
+ RegionFactory<ByteArrayWrapper, HyperLogLogPlus> regionFactory =
+ gemFireCache.createRegionFactory(this.DEFAULT_REGION_TYPE);
+ hLLRegion = regionFactory.create(HLL_REGION);
+ }
+ if ((redisMetaData = cache.getRegion(REDIS_META_DATA_REGION)) == null) {
+ InternalRegionFactory<String, RedisDataType> redisMetaDataFactory =
+ gemFireCache.createInternalRegionFactory();
+ redisMetaDataFactory.addCacheListener(metaListener);
+ redisMetaDataFactory.setDataPolicy(DataPolicy.REPLICATE);
+
redisMetaDataFactory.setInternalRegion(true).setIsUsedForMetaRegion(true);
+ redisMetaData = redisMetaDataFactory.create(REDIS_META_DATA_REGION);
}
this.keyRegistrar = new KeyRegistrar(redisMetaData);
this.pubSub = new PubSubImpl(new Subscriptions());
