com.gemstone.gemfire.internal.cache.PartitionedRegionCreationJUnitTest Maven / Gradle / Ivy
Show all versions of gemfire-junit Show documentation
/*
* Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you
* may not use this file except in compliance with the License. You
* may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied. See the License for the specific language governing
* permissions and limitations under the License. See accompanying
* LICENSE file.
*/
package com.gemstone.gemfire.internal.cache;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.junit.FixMethodOrder;
import org.junit.runners.MethodSorters;
import junit.framework.TestCase;
import com.gemstone.gemfire.cache.AttributesFactory;
import com.gemstone.gemfire.cache.Cache;
import com.gemstone.gemfire.cache.DataPolicy;
import com.gemstone.gemfire.cache.PartitionAttributesFactory;
import com.gemstone.gemfire.cache.Region;
import com.gemstone.gemfire.cache.RegionAttributes;
import com.gemstone.gemfire.cache.RegionExistsException;
import com.gemstone.gemfire.cache.Scope;
import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
import com.gemstone.gemfire.LogWriter;
/**
* This is a test for creation of Partition
* region(PR).
*
* Following tests are included in PartitionedRegionCreationJUnitTest :
*
*
* 1) testpartionedRegionCreate - Tests the PR creation.
*
*
* 2) testpartionedRegionInitialization - Tests the PR initialization
*
*
* 3) testpartionedRegionRegistration - Tests the PR registration
*
*
* 4) testpartionedRegionBucketToNodeCreate - Tests the PR's BUCKET_2_NODE region creation
*
*
* @author tnegi
*
*/
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class PartitionedRegionCreationJUnitTest extends TestCase
{
static volatile int PRNumber = 0;
static Region root = null;
static volatile boolean increamentFlag = false;
static final int TOTAL_THREADS = 10;
static volatile int TOTAL_PR_CREATED = 0;
static volatile int TOTAL_RETURNS = 0;
static volatile int TOTAL_PR_CREATION_FAIL = 0;
static final Object PR_CREATE = new Object();
static final Object PR_CREATE_FAIL = new Object();
static final Object PR_INCREMENT = new Object();
static final Object PR_TOTAL_RETURNS = new Object();
public boolean PRCreateDone = false;
List PRRegionList = new ArrayList();
LogWriter logger = null;
private Object CREATE_COMPLETE_LOCK = new Object();
private volatile boolean createComplete = false;
public PartitionedRegionCreationJUnitTest(String arg0) {
super(arg0);
}
protected void setUp() throws Exception
{
super.setUp();
TOTAL_RETURNS = 0;
if (logger == null)
logger = PartitionedRegionTestHelper.getLogger();
}
protected void tearDown() throws Exception
{
super.tearDown();
}
/*
* 1)Create 10 thread each. Each thread will try to create PartionedRegion total
* of 5 partitioned region will be created. 5 threads should throw
* RegionExistException.
* 2) Tests for PR scope = GLOBAL and PR scope = LOCAL
* 3) Test for redundancy < 0
* 4) Test for redundancy > 3
* 5) Test for localMaxMemory < 0
*/
public void test000PartitionedRegionCreate()
{
createMultiplePartitionedRegions();
verifyCreateResults();
if (logger.fineEnabled()) {
logger
.fine(" PartitionedRegionCreationTest-testpartionedRegionCreate() Successfully Complete .. ");
}
final String regionname = "testPartionedRegionCreate";
int localMaxMemory = 0;
PartitionedRegion pr = null;
// Test vanilla creation of a Partitioned Region w/o Scope
try {
AttributesFactory af = new AttributesFactory();
af.setDataPolicy(DataPolicy.PARTITION);
RegionAttributes ra = af.create();
Cache cache = PartitionedRegionTestHelper.createCache();
pr = (PartitionedRegion)cache.createRegion(regionname, ra);
} finally {
pr.destroyRegion();
}
// Assert that setting any scope throws IllegalStateException
final Scope[] scopes = { Scope.LOCAL, Scope.DISTRIBUTED_ACK, Scope.DISTRIBUTED_NO_ACK, Scope.GLOBAL };
for (int i=0; i < scopes.length; i++) {
try {
AttributesFactory af = new AttributesFactory();
af.setDataPolicy(DataPolicy.PARTITION);
af.setScope(scopes[i]);
RegionAttributes ra = af.create();
Cache cache = PartitionedRegionTestHelper.createCache();
pr = (PartitionedRegion)cache.createRegion(regionname, ra);
fail("testpartionedRegionCreate() Expected IllegalStateException not thrown for Scope " + scopes[i]);
}
catch (IllegalStateException expected )
{
}
finally {
if (pr != null && !pr.isDestroyed()) {
pr.destroyRegion();
}
}
}
// test for redundancy > 3
int redundancy = 10;
try {
pr = (PartitionedRegion)PartitionedRegionTestHelper
.createPartitionedRegion(regionname, String.valueOf(localMaxMemory),
redundancy);
}
catch (IllegalStateException illex) {
if (logger.fineEnabled()) {
logger
.fine("testpartionedRegionCreate() Got a correct exception-IllegalStateException for redundancy > 3 ");
}
}
// test for redundancy < 0
if (pr!= null && !pr.isDestroyed())
pr.destroyRegion();
redundancy = -5;
try {
pr = (PartitionedRegion)PartitionedRegionTestHelper
.createPartitionedRegion(regionname, String.valueOf(200), redundancy);
fail("testpartionedRegionCreate() Expected IllegalStateException not thrown for redundancy < 0 ");
}
catch (IllegalStateException illex) {
if (logger.fineEnabled()) {
logger
.fine("testpartionedRegionCreate() Got a correct exception-IllegalStateException for redundancy < 0 ");
}
}
// test for localMaxMemory < 0
/*
if (pr!= null && !pr.isDestroyed())
pr.destroyRegion();
;
localMaxMemory = -5;
try {
pr = (PartitionedRegion)PartitionedRegionTestHelper
.createPartitionedRegion(regionname, String.valueOf(localMaxMemory),
2, Scope.DISTRIBUTED_ACK);
fail("testpartionedRegionCreate() Expected IllegalStateException not thrown for localMaxMemory < 0 ");
}
catch (IllegalStateException illex) {
if (logger.fineEnabled()) {
logger
.fine("testpartionedRegionCreate() Got a correct exception-IllegalStateException for localMaxMemory < 0 ");
}
}
*/
}
public void test001PersistentPartitionedRegionCreate()
{
final String regionname = "testPersistentPartionedRegionCreate";
PartitionedRegion pr = null;
// Test vanilla creation of a Partitioned Region w/o Scope
try {
AttributesFactory af = new AttributesFactory();
af.setDataPolicy(DataPolicy.PERSISTENT_PARTITION);
RegionAttributes ra = af.create();
Cache cache = PartitionedRegionTestHelper.createCache();
pr = (PartitionedRegion)cache.createRegion(regionname, ra);
} finally {
if (pr != null) {
pr.destroyRegion();
}
}
// Assert that an accessor (localMaxMem == 0) can't be persistent
try {
AttributesFactory af = new AttributesFactory();
af.setDataPolicy(DataPolicy.PERSISTENT_PARTITION);
af.setPartitionAttributes(new PartitionAttributesFactory().setLocalMaxMemory(0).create());
RegionAttributes ra = af.create();
Cache cache = PartitionedRegionTestHelper.createCache();
pr = (PartitionedRegion)cache.createRegion(regionname, ra);
fail("testpartionedRegionCreate() Expected IllegalStateException not thrown");
} catch (IllegalStateException expected) {
assertEquals("Persistence is not allowed when local-max-memory is zero.",
expected.getMessage());
}
// Assert that a region can't be created
// if configured with a diskStoreName and the disk store has not be created.
try {
AttributesFactory af = new AttributesFactory();
af.setDataPolicy(DataPolicy.PERSISTENT_PARTITION);
af.setDiskStoreName("nonexistentDiskStore");
RegionAttributes ra = af.create();
Cache cache = PartitionedRegionTestHelper.createCache();
pr = (PartitionedRegion)cache.createRegion(regionname, ra);
fail("testpartionedRegionCreate() Expected IllegalStateException not thrown");
} catch (RuntimeException expected) {
assertTrue(expected.getMessage().contains(LocalizedStrings.CacheCreation_DISKSTORE_NOTFOUND_0
.toLocalizedString("nonexistentDiskStore")));
}
// Assert that you can't have a diskStoreName unless you are persistent or overflow.
try {
Cache cache = PartitionedRegionTestHelper.createCache();
cache.createDiskStoreFactory().create("existentDiskStore");
AttributesFactory af = new AttributesFactory();
af.setDataPolicy(DataPolicy.PARTITION);
af.setDiskStoreName("existentDiskStore");
RegionAttributes ra = af.create();
pr = (PartitionedRegion)cache.createRegion(regionname, ra);
fail("testpartionedRegionCreate() Expected IllegalStateException not thrown");
} catch (IllegalStateException expected) {
assertEquals("Only regions with persistence or overflow to disk can specify DiskStore", expected.getMessage());
}
// Assert that setting any scope throws IllegalStateException
final Scope[] scopes = { Scope.LOCAL, Scope.DISTRIBUTED_ACK, Scope.DISTRIBUTED_NO_ACK, Scope.GLOBAL };
for (int i=0; i < scopes.length; i++) {
try {
AttributesFactory af = new AttributesFactory();
af.setDataPolicy(DataPolicy.PERSISTENT_PARTITION);
af.setScope(scopes[i]);
RegionAttributes ra = af.create();
Cache cache = PartitionedRegionTestHelper.createCache();
pr = (PartitionedRegion)cache.createRegion(regionname, ra);
fail("testpartionedRegionCreate() Expected IllegalStateException not thrown for Scope " + scopes[i]);
} catch (IllegalStateException expected) {
}
}
// test for redundancy > 3
try {
pr = (PartitionedRegion)PartitionedRegionTestHelper
.createPartitionedRegion(regionname, String.valueOf(0), 4);
fail("testpartionedRegionCreate() Expected IllegalStateException not thrown for redundancy > 3 ");
}
catch (IllegalStateException illex) {
if (logger.fineEnabled()) {
logger
.fine("testpartionedRegionCreate() Got a correct exception-IllegalStateException for redundancy > 3 ");
}
}
// test for redundancy < 0
try {
pr = (PartitionedRegion)PartitionedRegionTestHelper
.createPartitionedRegion(regionname, String.valueOf(200), -1);
fail("testpartionedRegionCreate() Expected IllegalStateException not thrown for redundancy < 0 ");
}
catch (IllegalStateException illex) {
if (logger.fineEnabled()) {
logger
.fine("testpartionedRegionCreate() Got a correct exception-IllegalStateException for redundancy < 0 ");
}
}
}
/**
* Test for initialization of PartitionedRegion. Following are tested for the
* PartitionedRegion:
*
* (1) Test for Root == null
*
* (2) Test for Root region scope is DIST_ACK
*
* (3) Test if MirrorType.NONE for root region.
*
* (4) Test if PARTITIONED_REGION_CONFIG_NAME exist and isDistributedAck and the
* mirror type is MirrorType.KEYS_VALUES.
*
* @throws RegionExistsException
*/
public void test002PartionedRegionInitialization() throws RegionExistsException
{
String PRName = "testpartionedRegionInitialization";
PartitionedRegionTestHelper.createPartionedRegion(PRName);
Region root = (PartitionedRegionTestHelper
.getExistingRegion(PartitionedRegionHelper.PR_ROOT_REGION_NAME));
if (root == null)
fail("testpartionedRegionInitialization() - the "
+ PartitionedRegionHelper.PR_ROOT_REGION_NAME + " do not exists");
RegionAttributes regionAttribs = root.getAttributes();
Scope scope = regionAttribs.getScope();
if (!scope.isDistributedAck())
fail("testpartionedRegionInitialization() - the "
+ PartitionedRegionHelper.PR_ROOT_REGION_NAME
+ " scope is not distributed_ack");
assertEquals(DataPolicy.REPLICATE, regionAttribs.getDataPolicy());
// Region allPartitionedRegions = root
// .getSubregion(PartitionedRegionHelper.PARTITIONED_REGION_CONFIG_NAME);
// if (allPartitionedRegions == null)
// fail("testpartionedRegionInitialization() - the "
// + PartitionedRegionHelper.PARTITIONED_REGION_CONFIG_NAME
// + " do not exists");
//
// regionAttribs = allPartitionedRegions.getAttributes();
// scope = regionAttribs.getScope();
// if (!scope.isDistributedAck())
// fail("testpartionedRegionInitialization() - the "
// + PartitionedRegionHelper.PARTITIONED_REGION_CONFIG_NAME
// + " scope is not distributed_ack");
// MirrorType mirrortype = regionAttribs.getMirrorType();
// if (mirrortype != MirrorType.KEYS_VALUES)
// fail("testpartionedRegionInitialization() - the "
// + PartitionedRegionHelper.PARTITIONED_REGION_CONFIG_NAME
// + " mirror type is not KEYS_VALUES ");
if (logger.fineEnabled()) {
logger
.fine("testpartionedRegionInitialization() Successfully Complete .. ");
}
// System.out.println("testpartionedRegionInitialization");
}
/**
* Test for partitioned Region registration. All partitioned regions created must
* have a entry in PARTITIONED_REGION_CONFIG_NAME. Every PR has PR name /
* PartitionRegionConfig entry in region PARTITIONED_REGION_CONFIG_NAME
*
*/
public void test003partionedRegionRegistration()
{
createMultiplePartitionedRegions();
Region root = (PartitionedRegionTestHelper
.getExistingRegion(PartitionedRegionHelper.PR_ROOT_REGION_NAME));
//
// Region allPartitionedRegions = root
// .getSubregion(PartitionedRegionHelper.PARTITIONED_REGION_CONFIG_NAME);
Iterator itr = PRRegionList.iterator();
while (itr.hasNext()) {
Region region = (Region)itr.next();
String name = ((PartitionedRegion)region).getRegionIdentifier();
PartitionRegionConfig prConfig = (PartitionRegionConfig)root
.get(name);
if (prConfig == null)
fail("testpartionedRegionRegistration() - PartionedRegion - " + name
+ " configs do not exists in region - "
+ root.getName());
}
if (logger.fineEnabled()) {
logger
.fine(" testpartionedRegionRegistration() Successfully Complete .. ");
}
// System.out.println("testpartionedRegionRegistration");
}
/**
* creates multiple partitioned region from different threads.
*
*/
private void createMultiplePartitionedRegions()
{
if (PRCreateDone)
return;
int numthread = 0;
while (numthread < TOTAL_THREADS) {
PartionedRegionCreateThread pregionThread = new PartionedRegionCreateThread();
pregionThread.start();
numthread++;
}
while (!createComplete) {
synchronized (CREATE_COMPLETE_LOCK) {
if (!createComplete) {
try {
CREATE_COMPLETE_LOCK.wait();
}
catch (Exception ex) { // no action }
}
}
}
}
PRCreateDone = true;
}
/**
* Verifies creation of partitioned region.
*
*/
private void verifyCreateResults()
{
if (TOTAL_RETURNS != TOTAL_THREADS)
fail("Failed -- Total thread returned is not same as number of threads created");
if (TOTAL_PR_CREATED != (TOTAL_THREADS / 2))
fail("Failed -- Total Partioned Region created is not correct");
if (TOTAL_PR_CREATION_FAIL != (TOTAL_THREADS / 2))
fail("Failed -- Total Partioned Region creation failures is not correct");
}
/**
* Thread to create the partitioned region.
*
*/
public class PartionedRegionCreateThread extends Thread
{
public void run()
{
String prName = "PartitionedRegionCreationJUnitTest_" + getPRNumber();
try {
Region region = PartitionedRegionTestHelper
.createPartionedRegion(prName);
PRRegionList.add(region);
if (logger.fineEnabled()) {
logger
.fine("PartitionedRegionCreationJUnitTest - partitioned region -"
+ prName + "Created");
}
updatePRCreate();
}
catch (RegionExistsException rex) {
if (logger.fineEnabled()) {
logger.fine("PartitionedRegionCreationTest - Thread - "
+ Thread.currentThread().getName()
+ " Failed to create a PartitionedRegion. Region already exists");
}
updatePRCreateFail();
}
updateTotalReturns();
}
}
/**
* Increments and returns the PR nmber used for PR creation. Thread safe
* function.
*
* @return the PR number
*/
protected int getPRNumber()
{
int retNum = 0;
synchronized (PR_INCREMENT) {
if (increamentFlag) {
retNum = PRNumber;
PRNumber++;
increamentFlag = false;
}
else {
increamentFlag = true;
}
}
return retNum;
}
protected void updatePRCreate()
{
synchronized (PR_CREATE) {
TOTAL_PR_CREATED++;
}
}
protected void updatePRCreateFail()
{
synchronized (PR_CREATE_FAIL) {
TOTAL_PR_CREATION_FAIL++;
}
}
/**
* Increments total creation thread returns.
*
*/
protected void updateTotalReturns()
{
synchronized (PR_TOTAL_RETURNS) {
TOTAL_RETURNS++;
System.out.println("TOTAL_RETURNS is " + TOTAL_RETURNS);
}
if (TOTAL_RETURNS == TOTAL_THREADS) {
synchronized (CREATE_COMPLETE_LOCK) {
createComplete = true;
CREATE_COMPLETE_LOCK.notifyAll();
}
}
}
}