/*
* 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.cache30;
import static org.apache.geode.distributed.ConfigurationProperties.ROLES;
import static org.junit.Assert.*;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Serializable;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.xml.sax.SAXException;
import com.company.app.DBLoader;
import org.apache.geode.DataSerializable;
import org.apache.geode.DataSerializer;
import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.AttributesMutator;
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.CacheException;
import org.apache.geode.cache.CacheFactory;
import org.apache.geode.cache.CacheListener;
import org.apache.geode.cache.CacheLoader;
import org.apache.geode.cache.CacheLoaderException;
import org.apache.geode.cache.CacheTransactionManager;
import org.apache.geode.cache.CacheWriter;
import org.apache.geode.cache.CacheXmlException;
import org.apache.geode.cache.CustomExpiry;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.Declarable;
import org.apache.geode.cache.DiskStore;
import org.apache.geode.cache.DiskStoreFactory;
import org.apache.geode.cache.DiskWriteAttributesFactory;
import org.apache.geode.cache.DynamicRegionFactory;
import org.apache.geode.cache.EvictionAction;
import org.apache.geode.cache.EvictionAlgorithm;
import org.apache.geode.cache.EvictionAttributes;
import org.apache.geode.cache.ExpirationAction;
import org.apache.geode.cache.ExpirationAttributes;
import org.apache.geode.cache.FixedPartitionAttributes;
import org.apache.geode.cache.InterestPolicy;
import org.apache.geode.cache.LoaderHelper;
import org.apache.geode.cache.LossAction;
import org.apache.geode.cache.MembershipAttributes;
import org.apache.geode.cache.MirrorType;
import org.apache.geode.cache.PartitionAttributes;
import org.apache.geode.cache.PartitionAttributesFactory;
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.ResumptionAction;
import org.apache.geode.cache.Scope;
import org.apache.geode.cache.SubscriptionAttributes;
import org.apache.geode.cache.TransactionListener;
import org.apache.geode.cache.TransactionWriter;
import org.apache.geode.cache.Region.Entry;
import org.apache.geode.cache.client.ClientCache;
import org.apache.geode.cache.client.ClientRegionShortcut;
import org.apache.geode.cache.client.Pool;
import org.apache.geode.cache.client.PoolFactory;
import org.apache.geode.cache.client.PoolManager;
import org.apache.geode.cache.execute.Function;
import org.apache.geode.cache.execute.FunctionService;
import org.apache.geode.cache.server.CacheServer;
import org.apache.geode.cache.server.ClientSubscriptionConfig;
import org.apache.geode.cache.server.ServerLoad;
import org.apache.geode.cache.server.ServerLoadProbeAdapter;
import org.apache.geode.cache.server.ServerMetrics;
import org.apache.geode.cache.util.ObjectSizer;
import org.apache.geode.cache.util.TransactionListenerAdapter;
import org.apache.geode.internal.AvailablePort;
import org.apache.geode.internal.AvailablePortHelper;
import org.apache.geode.internal.InternalDataSerializer;
import org.apache.geode.internal.InternalInstantiator;
import org.apache.geode.internal.cache.DiskWriteAttributesImpl;
import org.apache.geode.internal.cache.DistributedRegion;
import org.apache.geode.internal.cache.FixedPartitionAttributesImpl;
import org.apache.geode.internal.cache.GemFireCacheImpl;
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.functions.TestFunction;
import org.apache.geode.internal.cache.lru.MemLRUCapacityController;
import org.apache.geode.internal.cache.partitioned.fixed.QuarterPartitionResolver;
import org.apache.geode.internal.cache.xmlcache.CacheCreation;
import org.apache.geode.internal.cache.xmlcache.CacheTransactionManagerCreation;
import org.apache.geode.internal.cache.xmlcache.CacheXml;
import org.apache.geode.internal.cache.xmlcache.CacheXmlGenerator;
import org.apache.geode.internal.cache.xmlcache.CacheXmlParser;
import org.apache.geode.internal.cache.xmlcache.ClientCacheCreation;
import org.apache.geode.internal.cache.xmlcache.Declarable2;
import org.apache.geode.internal.cache.xmlcache.FunctionServiceCreation;
import org.apache.geode.internal.cache.xmlcache.RegionAttributesCreation;
import org.apache.geode.internal.cache.xmlcache.RegionCreation;
import org.apache.geode.internal.cache.xmlcache.ResourceManagerCreation;
import org.apache.geode.internal.cache.xmlcache.SerializerCreation;
import org.apache.geode.internal.i18n.LocalizedStrings;
import org.apache.geode.test.dunit.Assert;
import org.apache.geode.test.dunit.Host;
import org.apache.geode.test.dunit.IgnoredException;
import org.apache.geode.test.dunit.LogWriterUtils;
import org.apache.geode.test.dunit.NetworkUtils;
import org.apache.geode.test.dunit.SerializableCallable;
import org.apache.geode.test.dunit.VM;
import org.apache.geode.test.junit.categories.DistributedTest;
import org.apache.geode.util.test.TestUtil;
/**
* Tests 7.0 cache.xml feature : Fixed Partitioning.
*
* @since GemFire 6.6
*/
public abstract class CacheXml66DUnitTest extends CacheXmlTestCase {
//////// Constructors
public CacheXml66DUnitTest() {
super();
}
// ////// Helper methods
protected abstract String getGemFireVersion();
private final static String ALIAS1;
private final static String ALIAS2;
static {
String tmp_alias1 = "localhost";
String tmp_alias2 = "localhost";
// try {
// tmp_alias1 = getServerHostName(Host.getHost(0));
// InetSocketAddress addr = createINSA(tmp_alias1, 10000);
// tmp_alias2 = addr.getHostName();
// }
// catch (IllegalArgumentException suppress) {
// // The runnables dont have a Host object initialized, but they dont need
// // access to the aliases so its ok to suppress this.
// }
// finally {
ALIAS1 = tmp_alias1;
ALIAS2 = tmp_alias2;
// }
}
private static InetSocketAddress createINSA(String host, int port) {
try {
InetAddress hostAddr = InetAddress.getByName(host);
return new InetSocketAddress(hostAddr, port);
} catch (UnknownHostException cause) {
IllegalArgumentException ex = new IllegalArgumentException("Unknown host " + host);
ex.initCause(cause);
throw ex;
}
}
/**
* test for checking default value of PR_Single_Hop feature. Test for checking default value of
* multiuser-authentication attribute.
*/
@Test
public void testDefaultConnectionPool() throws CacheException {
getSystem();
CacheCreation cache = new CacheCreation();
PoolFactory f = cache.createPoolFactory();
f.addLocator(ALIAS2, 3777);
f.create("mypool");
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setPoolName("mypool");
cache.createVMRegion("rootNORMAL", attrs);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region r = c.getRegion("rootNORMAL");
assertNotNull(r);
assertEquals("mypool", r.getAttributes().getPoolName());
Pool cp = PoolManager.find("mypool");
assertNotNull(cp);
assertEquals(1, cp.getLocators().size());
assertEquals(0, cp.getServers().size());
assertEquals(createINSA(ALIAS2, 3777), cp.getLocators().get(0));
assertEquals(PoolFactory.DEFAULT_FREE_CONNECTION_TIMEOUT, cp.getFreeConnectionTimeout());
assertEquals(PoolFactory.DEFAULT_LOAD_CONDITIONING_INTERVAL, cp.getLoadConditioningInterval());
assertEquals(PoolFactory.DEFAULT_SOCKET_BUFFER_SIZE, cp.getSocketBufferSize());
assertEquals(PoolFactory.DEFAULT_THREAD_LOCAL_CONNECTIONS, cp.getThreadLocalConnections());
assertEquals(PoolFactory.DEFAULT_READ_TIMEOUT, cp.getReadTimeout());
assertEquals(PoolFactory.DEFAULT_MIN_CONNECTIONS, cp.getMinConnections());
assertEquals(PoolFactory.DEFAULT_MAX_CONNECTIONS, cp.getMaxConnections());
assertEquals(PoolFactory.DEFAULT_RETRY_ATTEMPTS, cp.getRetryAttempts());
assertEquals(PoolFactory.DEFAULT_IDLE_TIMEOUT, cp.getIdleTimeout());
assertEquals(PoolFactory.DEFAULT_PING_INTERVAL, cp.getPingInterval());
assertEquals(PoolFactory.DEFAULT_STATISTIC_INTERVAL, cp.getStatisticInterval());
assertEquals(PoolFactory.DEFAULT_SERVER_GROUP, cp.getServerGroup());
assertEquals(PoolFactory.DEFAULT_SUBSCRIPTION_ENABLED, cp.getSubscriptionEnabled());
assertEquals(PoolFactory.DEFAULT_PR_SINGLE_HOP_ENABLED, cp.getPRSingleHopEnabled());
assertEquals(PoolFactory.DEFAULT_SUBSCRIPTION_REDUNDANCY, cp.getSubscriptionRedundancy());
assertEquals(PoolFactory.DEFAULT_SUBSCRIPTION_MESSAGE_TRACKING_TIMEOUT,
cp.getSubscriptionMessageTrackingTimeout());
assertEquals(PoolFactory.DEFAULT_SUBSCRIPTION_ACK_INTERVAL, cp.getSubscriptionAckInterval());
assertEquals(PoolFactory.DEFAULT_MULTIUSER_AUTHENTICATION, cp.getMultiuserAuthentication());
}
@Test
public void testDiskStore() throws CacheException {
CacheCreation cache = new CacheCreation();
DiskStoreFactory dsf = cache.createDiskStoreFactory();
File[] dirs1 = new File[] {new File("").getAbsoluteFile()};
DiskStore ds1 =
dsf.setAllowForceCompaction(true).setAutoCompact(true).setCompactionThreshold(100)
.setMaxOplogSize(2).setTimeInterval(10).setWriteBufferSize(15).setQueueSize(12)
.setDiskDirsAndSizes(dirs1, new int[] {1024 * 20}).create(getUniqueName() + 1);
File[] dirs2 = new File[] {new File("").getAbsoluteFile()};
DiskStore ds2 =
dsf.setAllowForceCompaction(false).setAutoCompact(false).setCompactionThreshold(99)
.setMaxOplogSize(1).setTimeInterval(9).setWriteBufferSize(14).setQueueSize(11)
.setDiskDirsAndSizes(dirs2, new int[] {1024 * 40}).create(getUniqueName() + 2);
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_ACK);
attrs.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
attrs.setDiskStoreName(getUniqueName() + 1);
attrs.setDiskSynchronous(true);
RegionCreation root = (RegionCreation) cache.createRegion("root", attrs);
{
attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_ACK);
attrs.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
attrs.setDiskStoreName(getUniqueName() + 2);
Region subwithdiskstore = root.createSubregion("subwithdiskstore", attrs);
}
{
attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_ACK);
attrs.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
Region subwithdefaultdiskstore = root.createSubregion("subwithdefaultdiskstore", attrs);
}
testXml(cache);
}
/**
* test for enabling PRsingleHop feature. Test for enabling multiuser-authentication attribute.
*/
@Test
public void testExplicitConnectionPool() throws CacheException {
getSystem();
CacheCreation cache = new CacheCreation();
PoolFactory f = cache.createPoolFactory();
f.addServer(ALIAS2, 3777).addServer(ALIAS1, 3888);
f.setFreeConnectionTimeout(12345).setLoadConditioningInterval(12345).setSocketBufferSize(12345)
.setThreadLocalConnections(true).setPRSingleHopEnabled(true).setReadTimeout(12345)
.setMinConnections(12346).setMaxConnections(12347).setRetryAttempts(12348)
.setIdleTimeout(12349).setPingInterval(12350).setStatisticInterval(12351)
.setServerGroup("mygroup")
// commented this out until queues are implemented
// .setQueueEnabled(true)
.setSubscriptionRedundancy(12345).setSubscriptionMessageTrackingTimeout(12345)
.setSubscriptionAckInterval(333).setMultiuserAuthentication(true);
f.create("mypool");
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setPoolName("mypool");
attrs.setDataPolicy(DataPolicy.EMPTY); // required for multiuser mode
cache.createVMRegion("rootNORMAL", attrs);
IgnoredException.addIgnoredException("Connection refused: connect");
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region r = c.getRegion("rootNORMAL");
assertNotNull(r);
assertEquals("mypool", r.getAttributes().getPoolName());
Pool cp = PoolManager.find("mypool");
assertNotNull(cp);
assertEquals(0, cp.getLocators().size());
assertEquals(2, cp.getServers().size());
assertEquals(createINSA(ALIAS2, 3777), cp.getServers().get(0));
assertEquals(createINSA(ALIAS1, 3888), cp.getServers().get(1));
assertEquals(12345, cp.getFreeConnectionTimeout());
assertEquals(12345, cp.getLoadConditioningInterval());
assertEquals(12345, cp.getSocketBufferSize());
assertEquals(true, cp.getThreadLocalConnections());
assertEquals(true, cp.getPRSingleHopEnabled());
assertEquals(12345, cp.getReadTimeout());
assertEquals(12346, cp.getMinConnections());
assertEquals(12347, cp.getMaxConnections());
assertEquals(12348, cp.getRetryAttempts());
assertEquals(12349, cp.getIdleTimeout());
assertEquals(12350, cp.getPingInterval());
assertEquals(12351, cp.getStatisticInterval());
assertEquals("mygroup", cp.getServerGroup());
// commented this out until queues are implemented
// assertIndexDetailsEquals(true, cp.getQueueEnabled());
assertEquals(12345, cp.getSubscriptionRedundancy());
assertEquals(12345, cp.getSubscriptionMessageTrackingTimeout());
assertEquals(333, cp.getSubscriptionAckInterval());
assertEquals(true, cp.getMultiuserAuthentication());
}
@Test
public void testDiskStoreValidation() throws CacheException {
CacheCreation cache = new CacheCreation();
DiskStoreFactory dsf = cache.createDiskStoreFactory();
DiskStore ds1 = dsf.create(getUniqueName());
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_ACK);
attrs.setDataPolicy(DataPolicy.REPLICATE);
attrs.setDiskStoreName(getUniqueName());
RegionCreation root;
try {
root = (RegionCreation) cache.createRegion("root", attrs);
} catch (IllegalStateException e) {
assertTrue(e.getMessage().contains(
LocalizedStrings.DiskStore_IS_USED_IN_NONPERSISTENT_REGION.toLocalizedString()));
} catch (Exception ex) {
Assert.fail("Unexpected exception", ex);
}
EvictionAttributes ea =
EvictionAttributes.createLRUEntryAttributes(1000, EvictionAction.OVERFLOW_TO_DISK);
attrs.setEvictionAttributes(ea);
try {
root = (RegionCreation) cache.createRegion("root", attrs);
} catch (IllegalStateException e) {
Assert.fail("With eviction of overflow to disk, region can specify disk store name", e);
} catch (Exception ex) {
Assert.fail("Unexpected exception", ex);
}
File dir = new File("testDiskStoreValidation");
dir.mkdir();
dir.deleteOnExit();
File[] dirs2 = new File[] {dir, new File("").getAbsoluteFile()};
try {
AttributesFactory factory = new AttributesFactory();
factory.setDiskDirs(dirs2);
factory.setDiskStoreName(getUniqueName());
RegionAttributes ra = factory.create();
} catch (IllegalStateException e) {
assertTrue(e.getMessage().contains(
LocalizedStrings.DiskStore_Deprecated_API_0_Cannot_Mix_With_DiskStore_1.toLocalizedString(
new Object[] {"setDiskDirs or setDiskWriteAttributes", getUniqueName()})));
} catch (Exception ex) {
Assert.fail("Unexpected exception", ex);
}
try {
AttributesFactory factory = new AttributesFactory();
factory.setDiskStoreName(getUniqueName());
factory.setDiskDirs(dirs2);
RegionAttributes ra = factory.create();
} catch (IllegalStateException e) {
assertTrue(e.getMessage()
.contains(LocalizedStrings.DiskStore_Deprecated_API_0_Cannot_Mix_With_DiskStore_1
.toLocalizedString(new Object[] {"setDiskDirs", getUniqueName()})));
} catch (Exception ex) {
Assert.fail("Unexpected exception", ex);
}
testXml(cache);
}
@Test
public void testDiskStoreFactory() throws CacheException {
CacheCreation cache = new CacheCreation();
DiskStoreFactory dsf = cache.createDiskStoreFactory();
DiskStore ds1;
try {
dsf.setDiskDirs(new File[] {new File("non_exist_dir")});
ds1 = dsf.create(getUniqueName());
// NOT required any more as we create the disk store directory during disk-store creation
// fail("Expected IllegalStateException");
} catch (IllegalArgumentException e) {
// got expected exception
}
dsf.setDiskDirs(new File[] {new File(".")});
ds1 = dsf.create(getUniqueName());
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_ACK);
attrs.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
attrs.setDiskStoreName(getUniqueName());
AttributesFactory factory = new AttributesFactory(attrs);
RegionAttributes ra = factory.create();
RegionCreation root;
try {
root = (RegionCreation) cache.createRegion("root", ra);
} catch (Exception ex) {
Assert.fail("Unexpected exception", ex);
}
factory = new AttributesFactory();
factory.setDiskStoreName(getUniqueName());
factory.setScope(Scope.DISTRIBUTED_ACK);
factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
ra = factory.create();
RegionCreation root2;
try {
root2 = (RegionCreation) cache.createRegion("root2", ra);
} catch (Exception ex) {
Assert.fail("Unexpected exception", ex);
}
factory = new AttributesFactory();
factory.setDiskStoreName(null);
factory.setScope(Scope.DISTRIBUTED_ACK);
factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
ra = factory.create();
RegionCreation root3;
try {
root3 = (RegionCreation) cache.createRegion("root3", ra);
} catch (Exception ex) {
Assert.fail("Unexpected exception", ex);
}
testXml(cache);
}
@Test
public void testRedefineOfDefaultDiskStore() throws CacheException {
CacheCreation cache = new CacheCreation();
DiskStoreFactory dsf = cache.createDiskStoreFactory();
dsf.setAutoCompact(!DiskStoreFactory.DEFAULT_AUTO_COMPACT);
DiskStore ds1 = dsf.create(DiskStoreFactory.DEFAULT_DISK_STORE_NAME);
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_ACK);
attrs.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
AttributesFactory factory = new AttributesFactory(attrs);
RegionAttributes ra = factory.create();
RegionCreation root;
try {
root = (RegionCreation) cache.createRegion("root", ra);
} catch (Exception ex) {
Assert.fail("Unexpected exception", ex);
}
testXml(cache);
Cache c = getCache();
assertNotNull(c);
DiskStore ds2 = c.findDiskStore(DiskStoreFactory.DEFAULT_DISK_STORE_NAME);
assertNotNull(ds2);
assertEquals(ds1.getAutoCompact(), ds2.getAutoCompact());
}
/**
* Make sure you can create a persistent partitioned region from xml.
*/
@Test
public void testPersistentPartition() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.PERSISTENT_PARTITION);
cache.createRegion("parRoot", attrs);
Region r = cache.getRegion("parRoot");
assertEquals(DataPolicy.PERSISTENT_PARTITION, r.getAttributes().getDataPolicy());
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region region = c.getRegion("parRoot");
assertNotNull(region);
assertEquals(DataPolicy.PERSISTENT_PARTITION, region.getAttributes().getDataPolicy());
// since CacheTestCase remoteTearDown does not destroy PartitionedRegion
region.localDestroyRegion();
}
@Test
public void testBridgeAttributesRelatedToHAOverFlow65() throws CacheException {
CacheCreation cache = new CacheCreation();
cache.setMessageSyncInterval(3445);
CacheServer bs = cache.addCacheServer();
ClientSubscriptionConfig csc = bs.getClientSubscriptionConfig();
csc.setEvictionPolicy("entry");
cache.getLogger().config("EvictionPolicy : " + csc.getEvictionPolicy());
csc.setCapacity(501);
cache.getLogger().config("EvictionCapacity : " + csc.getCapacity());
File overflowDirectory = new File("overFlow");
overflowDirectory.mkdirs();
DiskStoreFactory dsf = cache.createDiskStoreFactory();
File[] dirs1 = new File[] {overflowDirectory};
DiskStore ds1 = dsf.setDiskDirs(dirs1).create(getUniqueName());
csc.setDiskStoreName(getUniqueName());
try {
csc.setOverflowDirectory("overFlow");
} catch (IllegalStateException e) {
assertTrue(e.getMessage()
.contains(LocalizedStrings.DiskStore_Deprecated_API_0_Cannot_Mix_With_DiskStore_1
.toLocalizedString(new Object[] {"setOverflowDirectory", getUniqueName()})));
} catch (Exception ex) {
Assert.fail("Unexpected exception", ex);
}
cache.getLogger().config("Eviction disk store : " + csc.getDiskStoreName());
bs.setPort(AvailablePortHelper.getRandomAvailableTCPPort());
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.NORMAL);
cache.createVMRegion("rootNORMAL", attrs);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
CacheServer server = (CacheServer) cache.getCacheServers().iterator().next();
assertNotNull(server);
ClientSubscriptionConfig chaqf = server.getClientSubscriptionConfig();
assertEquals("entry", chaqf.getEvictionPolicy());
assertEquals(501, chaqf.getCapacity());
DiskStore dsi = cache.findDiskStore(chaqf.getDiskStoreName());
assertEquals("overFlow", dsi.getDiskDirs()[0].toString());
}
@Test
public void testClientSubscriptionQueueUsingDefaultDS() throws CacheException {
CacheCreation cache = new CacheCreation();
cache.setMessageSyncInterval(3445);
CacheServer bs = cache.addCacheServer();
ClientSubscriptionConfig csc = bs.getClientSubscriptionConfig();
csc.setEvictionPolicy("entry");
cache.getLogger().config("EvictionPolicy : " + csc.getEvictionPolicy());
csc.setCapacity(501);
// don't set diskstore or overflowdir
cache.getLogger().config("EvictionCapacity : " + csc.getCapacity());
cache.getLogger().config("Eviction disk store : " + csc.getDiskStoreName());
bs.setPort(AvailablePortHelper.getRandomAvailableTCPPort());
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.NORMAL);
cache.createVMRegion("rootNORMAL", attrs);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
CacheServer server = (CacheServer) cache.getCacheServers().iterator().next();
assertNotNull(server);
ClientSubscriptionConfig chaqf = server.getClientSubscriptionConfig();
assertEquals("entry", chaqf.getEvictionPolicy());
assertEquals(501, chaqf.getCapacity());
File curDir = new File(".").getAbsoluteFile();
File lockFile = new File(curDir, "DRLK_IF" + GemFireCacheImpl.DEFAULT_DS_NAME + ".lk");
assertTrue(lockFile.exists());
}
/**
* Tests that a region created with a named attributes set programmatically for delta propogation
* has the correct attributes.
*
*/
@Test
public void testTransactionWriter() throws CacheException {
CacheCreation creation = new CacheCreation();
CacheTransactionManagerCreation ctmc = new CacheTransactionManagerCreation();
ctmc.setWriter(new TestTransactionWriter());
creation.addCacheTransactionManagerCreation(ctmc);
testXml(creation);
Cache c = getCache();
assertTrue(c instanceof GemFireCacheImpl);
c.loadCacheXml(generate(creation));
TransactionWriter tw = c.getCacheTransactionManager().getWriter();
assertTrue("tw should be TransactionWriter, but it is:" + tw,
tw instanceof TestTransactionWriter);
}
/**
* Tests that a region created with a named attributes with diskstore
*/
@Test
public void testDiskStoreInTemplates() throws CacheException {
File dir = new File("west");
dir.mkdir();
dir.deleteOnExit();
dir = new File("east");
dir.mkdir();
dir.deleteOnExit();
setXmlFile(findFile("ewtest.xml"));
String regionName_west = "orders/west";
String regionName_east = "orders/east";
Cache cache = getCache();
// verify diskstores
DiskStore ds = cache.findDiskStore("persistentDiskStore1");
assertNotNull(ds);
assertEquals(500, ds.getQueueSize());
File[] dirs = ds.getDiskDirs();
assertEquals("west", dirs[0].getPath());
ds = cache.findDiskStore("persistentDiskStore2");
assertNotNull(ds);
assertEquals(500, ds.getQueueSize());
dirs = ds.getDiskDirs();
assertEquals("east", dirs[0].getPath());
// verify templates
assertNotNull(cache.getRegionAttributes("nack"));
RegionAttributes attrs = cache.getRegionAttributes("persistent");
assertEquals(DataPolicy.PERSISTENT_REPLICATE, attrs.getDataPolicy());
assertEquals(false, attrs.isDiskSynchronous());
assertEquals("persistentDiskStore1", attrs.getDiskStoreName());
Region region = cache.getRegion(regionName_west);
assertNotNull(region);
attrs = region.getAttributes();
assertEquals(DataPolicy.PERSISTENT_REPLICATE, attrs.getDataPolicy());
assertEquals(false, attrs.isDiskSynchronous());
assertEquals("persistentDiskStore1", attrs.getDiskStoreName());
region = cache.getRegion(regionName_east);
assertNotNull(region);
// Make sure that attributes can be "overridden"
attrs = region.getAttributes();
assertEquals(DataPolicy.PERSISTENT_REPLICATE, attrs.getDataPolicy());
assertEquals(false, attrs.isDiskSynchronous());
assertEquals("persistentDiskStore2", attrs.getDiskStoreName());
// bug 41934
String regionName_datap = "data-p";
region = cache.getRegion(regionName_datap);
assertNotNull(region);
attrs = region.getAttributes();
PartitionAttributes pa = attrs.getPartitionAttributes();
assertEquals(1, pa.getRedundantCopies());
assertEquals(3, pa.getTotalNumBuckets());
assertEquals(DataPolicy.PERSISTENT_PARTITION, attrs.getDataPolicy());
}
@Test
public void testBackupFiles() throws CacheException {
CacheCreation cache = new CacheCreation();
File backup1 = new File("/back/me/up");
File backup2 = new File("/me/too/please");
cache.addBackup(backup1);
cache.addBackup(backup2);
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
assertEquals(Arrays.asList(new File[] {backup1, backup2}), c.getBackupFiles());
}
@Test
public void testClientCache() throws CacheException {
ClientCacheCreation cache = new ClientCacheCreation();
cache.setCopyOnRead(true);
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
assertEquals(true, c.getCopyOnRead());
assertEquals(true, c.isClient());
for (ClientRegionShortcut pra : ClientRegionShortcut.values()) {
assertNotNull(c.getRegionAttributes(pra.name()));
}
assertEquals(ClientRegionShortcut.values().length, c.listRegionAttributes().size());
}
@Test
public void testNormalCache() throws CacheException {
CacheCreation cache = new CacheCreation();
cache.setCopyOnRead(true);
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
assertEquals(true, c.getCopyOnRead());
assertEquals(false, c.isClient());
for (RegionShortcut pra : RegionShortcut.values()) {
assertNotNull(c.getRegionAttributes(pra.name()));
}
assertEquals(RegionShortcut.values().length, c.listRegionAttributes().size());
}
@Test
public void testPARTITION() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("partition", "PARTITION");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("partition");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PARTITION, ra.getDataPolicy());
assertNotNull(ra.getPartitionAttributes());
assertEquals(0, ra.getPartitionAttributes().getRedundantCopies());
}
@Test
public void testPARTITION_REDUNDANT() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("rpartition", "PARTITION_REDUNDANT");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("rpartition");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PARTITION, ra.getDataPolicy());
assertNotNull(ra.getPartitionAttributes());
assertEquals(1, ra.getPartitionAttributes().getRedundantCopies());
}
@Test
public void testPARTITION_PERSISTENT() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("ppartition", "PARTITION_PERSISTENT");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("ppartition");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PERSISTENT_PARTITION, ra.getDataPolicy());
assertNotNull(ra.getPartitionAttributes());
assertEquals(0, ra.getPartitionAttributes().getRedundantCopies());
}
@Test
public void testPARTITION_REDUNDANT_PERSISTENT() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root =
(RegionCreation) cache.createRegion("prpartition", "PARTITION_REDUNDANT_PERSISTENT");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("prpartition");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PERSISTENT_PARTITION, ra.getDataPolicy());
assertNotNull(ra.getPartitionAttributes());
assertEquals(1, ra.getPartitionAttributes().getRedundantCopies());
}
@Test
public void testPARTITION_OVERFLOW() throws CacheException {
CacheCreation cache = new CacheCreation();
ResourceManagerCreation rmc = new ResourceManagerCreation();
rmc.setEvictionHeapPercentage(55.0f);
rmc.setCriticalHeapPercentage(80.0f);
cache.setResourceManagerCreation(rmc);
RegionCreation root =
(RegionCreation) cache.createRegion("partitionoverflow", "PARTITION_OVERFLOW");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("partitionoverflow");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PARTITION, ra.getDataPolicy());
assertNotNull(ra.getPartitionAttributes());
assertEquals(0, ra.getPartitionAttributes().getRedundantCopies());
assertEquals(EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK),
ra.getEvictionAttributes());
assertEquals(55.0f, c.getResourceManager().getEvictionHeapPercentage(), 0);
assertEquals(80.0f, c.getResourceManager().getCriticalHeapPercentage(), 0);
}
@Test
public void testPARTITION_REDUNDANT_OVERFLOW() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root =
(RegionCreation) cache.createRegion("rpartitionoverflow", "PARTITION_REDUNDANT_OVERFLOW");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("rpartitionoverflow");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PARTITION, ra.getDataPolicy());
assertNotNull(ra.getPartitionAttributes());
assertEquals(1, ra.getPartitionAttributes().getRedundantCopies());
assertEquals(EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK),
ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testPARTITION_PERSISTENT_OVERFLOW() throws CacheException {
CacheCreation cache = new CacheCreation();
ResourceManagerCreation rmc = new ResourceManagerCreation();
rmc.setCriticalHeapPercentage(80.0f);
cache.setResourceManagerCreation(rmc);
RegionCreation root =
(RegionCreation) cache.createRegion("ppartitionoverflow", "PARTITION_PERSISTENT_OVERFLOW");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("ppartitionoverflow");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PERSISTENT_PARTITION, ra.getDataPolicy());
assertNotNull(ra.getPartitionAttributes());
assertEquals(0, ra.getPartitionAttributes().getRedundantCopies());
assertEquals(EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK),
ra.getEvictionAttributes());
assertEquals(80.0f, c.getResourceManager().getCriticalHeapPercentage(), 0);
assertEquals(75.0f, c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testPARTITION_REDUNDANT_PERSISTENT_OVERFLOW() throws CacheException {
CacheCreation cache = new CacheCreation();
ResourceManagerCreation rmc = new ResourceManagerCreation();
rmc.setEvictionHeapPercentage(0.0f); // test bug 42130
cache.setResourceManagerCreation(rmc);
RegionCreation root = (RegionCreation) cache.createRegion("prpartitionoverflow",
"PARTITION_REDUNDANT_PERSISTENT_OVERFLOW");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("prpartitionoverflow");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PERSISTENT_PARTITION, ra.getDataPolicy());
assertNotNull(ra.getPartitionAttributes());
assertEquals(1, ra.getPartitionAttributes().getRedundantCopies());
assertEquals(EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK),
ra.getEvictionAttributes());
assertEquals(0.0f, c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testPARTITION_HEAP_LRU() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("partitionlru", "PARTITION_HEAP_LRU");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("partitionlru");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PARTITION, ra.getDataPolicy());
assertNotNull(ra.getPartitionAttributes());
assertEquals(0, ra.getPartitionAttributes().getRedundantCopies());
assertEquals(EvictionAttributes.createLRUHeapAttributes(), ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testPARTITION_REDUNDANT_HEAP_LRU() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root =
(RegionCreation) cache.createRegion("rpartitionlru", "PARTITION_REDUNDANT_HEAP_LRU");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("rpartitionlru");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PARTITION, ra.getDataPolicy());
assertNotNull(ra.getPartitionAttributes());
assertEquals(1, ra.getPartitionAttributes().getRedundantCopies());
assertEquals(EvictionAttributes.createLRUHeapAttributes(), ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testREPLICATE() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("replicate", "REPLICATE");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("replicate");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.REPLICATE, ra.getDataPolicy());
assertEquals(Scope.DISTRIBUTED_ACK, ra.getScope());
}
@Test
public void testREPLICATE_PERSISTENT() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("preplicate", "REPLICATE_PERSISTENT");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("preplicate");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PERSISTENT_REPLICATE, ra.getDataPolicy());
assertEquals(Scope.DISTRIBUTED_ACK, ra.getScope());
}
@Test
public void testREPLICATE_OVERFLOW() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root =
(RegionCreation) cache.createRegion("replicateoverflow", "REPLICATE_OVERFLOW");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("replicateoverflow");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.REPLICATE, ra.getDataPolicy());
assertEquals(Scope.DISTRIBUTED_ACK, ra.getScope());
assertEquals(EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK),
ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testREPLICATE_PERSISTENT_OVERFLOW() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root =
(RegionCreation) cache.createRegion("preplicateoverflow", "REPLICATE_PERSISTENT_OVERFLOW");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("preplicateoverflow");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PERSISTENT_REPLICATE, ra.getDataPolicy());
assertEquals(Scope.DISTRIBUTED_ACK, ra.getScope());
assertEquals(EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK),
ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testREPLICATE_HEAP_LRU() throws CacheException, IOException {
CacheCreation cache = new CacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("replicatelru", "REPLICATE_HEAP_LRU");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("replicatelru");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PRELOADED, ra.getDataPolicy());
assertEquals(new SubscriptionAttributes(InterestPolicy.ALL), ra.getSubscriptionAttributes());
assertEquals(Scope.DISTRIBUTED_ACK, ra.getScope());
assertEquals(EvictionAttributes.createLRUHeapAttributes(), ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testLOCAL() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("local", "LOCAL");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("local");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.NORMAL, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
}
@Test
public void testLOCAL_PERSISTENT() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("plocal", "LOCAL_PERSISTENT");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("plocal");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PERSISTENT_REPLICATE, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
}
@Test
public void testLOCAL_HEAP_LRU() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("locallru", "LOCAL_HEAP_LRU");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("locallru");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.NORMAL, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
assertEquals(EvictionAttributes.createLRUHeapAttributes(), ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testLOCAL_OVERFLOW() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("localoverflow", "LOCAL_OVERFLOW");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("localoverflow");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.NORMAL, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
assertEquals(EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK),
ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testLOCAL_PERSISTENT_OVERFLOW() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root =
(RegionCreation) cache.createRegion("cpolocal", "LOCAL_PERSISTENT_OVERFLOW");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("cpolocal");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PERSISTENT_REPLICATE, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
assertEquals(EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK),
ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testPARTITION_PROXY() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("partitionProxy", "PARTITION_PROXY");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("partitionProxy");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PARTITION, ra.getDataPolicy());
assertNotNull(ra.getPartitionAttributes());
assertEquals(0, ra.getPartitionAttributes().getRedundantCopies());
assertEquals(0, ra.getPartitionAttributes().getLocalMaxMemory());
}
@Test
public void testPARTITION_PROXY_REDUNDANT() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root =
(RegionCreation) cache.createRegion("rpartitionProxy", "PARTITION_PROXY_REDUNDANT");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("rpartitionProxy");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PARTITION, ra.getDataPolicy());
assertNotNull(ra.getPartitionAttributes());
assertEquals(1, ra.getPartitionAttributes().getRedundantCopies());
assertEquals(0, ra.getPartitionAttributes().getLocalMaxMemory());
}
@Test
public void testREPLICATE_PROXY() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("replicateProxy", "REPLICATE_PROXY");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
Region r = c.getRegion("replicateProxy");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.EMPTY, ra.getDataPolicy());
assertEquals(Scope.DISTRIBUTED_ACK, ra.getScope());
}
@Test
public void testPROXY() throws CacheException {
ClientCacheCreation cache = new ClientCacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("proxy", "PROXY");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
assertEquals(true, c.isClient());
Region r = c.getRegion("proxy");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.EMPTY, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
assertEquals("DEFAULT", ra.getPoolName());
}
@Test
public void testCACHING_PROXY() throws CacheException {
ClientCacheCreation cache = new ClientCacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("cproxy", "CACHING_PROXY");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
assertEquals(true, c.isClient());
Region r = c.getRegion("cproxy");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.NORMAL, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
assertEquals("DEFAULT", ra.getPoolName());
}
@Test
public void testCACHING_PROXY_HEAP_LRU() throws CacheException {
ClientCacheCreation cache = new ClientCacheCreation();
RegionCreation root =
(RegionCreation) cache.createRegion("cproxylru", "CACHING_PROXY_HEAP_LRU");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
assertEquals(true, c.isClient());
Region r = c.getRegion("cproxylru");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.NORMAL, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
assertEquals("DEFAULT", ra.getPoolName());
assertEquals(EvictionAttributes.createLRUHeapAttributes(), ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testCACHING_PROXY_OVERFLOW() throws CacheException {
ClientCacheCreation cache = new ClientCacheCreation();
RegionCreation root =
(RegionCreation) cache.createRegion("cproxyoverflow", "CACHING_PROXY_OVERFLOW");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
assertEquals(true, c.isClient());
Region r = c.getRegion("cproxyoverflow");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.NORMAL, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
assertEquals("DEFAULT", ra.getPoolName());
assertEquals(EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK),
ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testClientLOCAL() throws CacheException {
ClientCacheCreation cache = new ClientCacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("local", "LOCAL");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
assertEquals(true, c.isClient());
Region r = c.getRegion("local");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.NORMAL, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
assertEquals(null, ra.getPoolName());
}
@Test
public void testClientLOCAL_HEAP_LRU() throws CacheException {
ClientCacheCreation cache = new ClientCacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("locallru", "LOCAL_HEAP_LRU");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
assertEquals(true, c.isClient());
Region r = c.getRegion("locallru");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.NORMAL, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
assertEquals(null, ra.getPoolName());
assertEquals(EvictionAttributes.createLRUHeapAttributes(), ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testClientLOCAL_OVERFLOW() throws CacheException {
ClientCacheCreation cache = new ClientCacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("localoverflow", "LOCAL_OVERFLOW");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
assertEquals(true, c.isClient());
Region r = c.getRegion("localoverflow");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.NORMAL, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
assertEquals(null, ra.getPoolName());
assertEquals(EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK),
ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
@Test
public void testClientLOCAL_PERSISTENT() throws CacheException {
ClientCacheCreation cache = new ClientCacheCreation();
RegionCreation root = (RegionCreation) cache.createRegion("cplocal", "LOCAL_PERSISTENT");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
assertEquals(true, c.isClient());
Region r = c.getRegion("cplocal");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PERSISTENT_REPLICATE, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
assertEquals(null, ra.getPoolName());
}
@Test
public void testClientLOCAL_PERSISTENT_OVERFLOW() throws CacheException {
ClientCacheCreation cache = new ClientCacheCreation();
RegionCreation root =
(RegionCreation) cache.createRegion("cpolocal", "LOCAL_PERSISTENT_OVERFLOW");
testXml(cache);
GemFireCacheImpl c = (GemFireCacheImpl) getCache();
assertEquals(true, c.isClient());
Region r = c.getRegion("cpolocal");
assertNotNull(r);
RegionAttributes ra = r.getAttributes();
assertEquals(DataPolicy.PERSISTENT_REPLICATE, ra.getDataPolicy());
assertEquals(Scope.LOCAL, ra.getScope());
assertEquals(null, ra.getPoolName());
assertEquals(EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK),
ra.getEvictionAttributes());
assertEquals(LocalRegion.DEFAULT_HEAPLRU_EVICTION_HEAP_PERCENTAGE,
c.getResourceManager().getEvictionHeapPercentage(), 0);
}
/**
* Tests that a partitioned region is created with FixedPartitionAttributes set programatically
* and correct cache.xml is generated with the same FixedPartitionAttributes
*
*/
@Test
public void testFixedPartitioning() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation();
FixedPartitionAttributes fpa1 = FixedPartitionAttributes.createFixedPartition("Q1");
FixedPartitionAttributes fpa2 = FixedPartitionAttributes.createFixedPartition("Q2", true);
FixedPartitionAttributes fpa3 = FixedPartitionAttributes.createFixedPartition("Q3", 3);
FixedPartitionAttributes fpa4 = FixedPartitionAttributes.createFixedPartition("Q4", false, 3);
List<FixedPartitionAttributes> fpattrsList = new ArrayList<FixedPartitionAttributes>();
fpattrsList.add(fpa1);
fpattrsList.add(fpa2);
fpattrsList.add(fpa3);
fpattrsList.add(fpa4);
QuarterPartitionResolver resolver = new QuarterPartitionResolver();
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setRedundantCopies(1).setPartitionResolver(resolver).addFixedPartitionAttributes(fpa1)
.addFixedPartitionAttributes(fpa2).addFixedPartitionAttributes(fpa3)
.addFixedPartitionAttributes(fpa4);
attrs.setPartitionAttributes(paf.create());
cache.createRegion("Quarter", attrs);
Region r = cache.getRegion("Quarter");
validateAttributes(r, fpattrsList, resolver, false);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region region = c.getRegion("Quarter");
assertNotNull(region);
validateAttributes(region, fpattrsList, resolver, false);
}
@Test
public void testFixedPartitioning_colocation_WithAttributes() throws CacheException {
CacheCreation cache = new CacheCreation();
FixedPartitionAttributes fpa1 = FixedPartitionAttributes.createFixedPartition("Q1");
FixedPartitionAttributes fpa2 = FixedPartitionAttributes.createFixedPartition("Q2", true);
FixedPartitionAttributes fpa3 = FixedPartitionAttributes.createFixedPartition("Q3", 3);
FixedPartitionAttributes fpa4 = FixedPartitionAttributes.createFixedPartition("Q4", false, 3);
List<FixedPartitionAttributes> fpattrsList = new ArrayList<FixedPartitionAttributes>();
fpattrsList.add(fpa1);
fpattrsList.add(fpa2);
fpattrsList.add(fpa3);
fpattrsList.add(fpa4);
QuarterPartitionResolver resolver = new QuarterPartitionResolver();
Region customerRegion = null;
Region orderRegion = null;
{
RegionAttributesCreation attrs = new RegionAttributesCreation();
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setRedundantCopies(1).setPartitionResolver(resolver).addFixedPartitionAttributes(fpa1)
.addFixedPartitionAttributes(fpa2).addFixedPartitionAttributes(fpa3)
.addFixedPartitionAttributes(fpa4);
attrs.setPartitionAttributes(paf.create());
cache.createRegion("Customer", attrs);
}
customerRegion = cache.getRegion("Customer");
validateAttributes(customerRegion, fpattrsList, resolver, false);
try {
RegionAttributesCreation attrs = new RegionAttributesCreation();
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setRedundantCopies(1).setPartitionResolver(resolver).addFixedPartitionAttributes(fpa1)
.addFixedPartitionAttributes(fpa2).addFixedPartitionAttributes(fpa3)
.addFixedPartitionAttributes(fpa4).setColocatedWith("Customer");
attrs.setPartitionAttributes(paf.create());
cache.createRegion("Order", attrs);
orderRegion = cache.getRegion("Order");
validateAttributes(orderRegion, fpattrsList, resolver, true);
} catch (Exception illegal) {
if (!((illegal instanceof IllegalStateException) && (illegal.getMessage()
.contains("can not be specified in PartitionAttributesFactory")))) {
Assert.fail("Expected IllegalStateException ", illegal);
}
RegionAttributesCreation attrs = new RegionAttributesCreation();
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setRedundantCopies(1).setPartitionResolver(resolver).setColocatedWith("Customer");
attrs.setPartitionAttributes(paf.create());
cache.createRegion("Order", attrs);
orderRegion = cache.getRegion("Order");
validateAttributes(orderRegion, fpattrsList, resolver, true);
}
testXml(cache);
Cache c = getCache();
assertNotNull(c);
customerRegion = c.getRegion("Customer");
assertNotNull(customerRegion);
validateAttributes(customerRegion, fpattrsList, resolver, false);
orderRegion = c.getRegion("Order");
assertNotNull(orderRegion);
validateAttributes(orderRegion, fpattrsList, resolver, true);
}
private void validateAttributes(Region region, List<FixedPartitionAttributes> fpattrsList,
QuarterPartitionResolver resolver, boolean isColocated) {
RegionAttributes regionAttrs = region.getAttributes();
PartitionAttributes pa = regionAttrs.getPartitionAttributes();
assertEquals(pa.getRedundantCopies(), 1);
assertNotNull(pa.getPartitionResolver().getClass());
assertEquals(pa.getPartitionResolver(), resolver);
List<FixedPartitionAttributesImpl> fixedPartitionsList = pa.getFixedPartitionAttributes();
if (isColocated) {
assertNull(fixedPartitionsList);
assertNotNull(pa.getColocatedWith());
} else {
assertNull(pa.getColocatedWith());
assertEquals(fixedPartitionsList.size(), 4);
assertEquals(fixedPartitionsList.containsAll(fpattrsList), true);
for (FixedPartitionAttributes fpa : fixedPartitionsList) {
if (fpa.getPartitionName().equals("Q1")) {
assertEquals(fpa.getNumBuckets(), 1);
assertEquals(fpa.isPrimary(), false);
}
if (fpa.getPartitionName().equals("Q2")) {
assertEquals(fpa.getNumBuckets(), 1);
assertEquals(fpa.isPrimary(), true);
}
if (fpa.getPartitionName().equals("Q3")) {
assertEquals(fpa.getNumBuckets(), 3);
assertEquals(fpa.isPrimary(), false);
}
if (fpa.getPartitionName().equals("Q4")) {
assertEquals(fpa.getNumBuckets(), 3);
assertEquals(fpa.isPrimary(), false);
}
}
}
}
@Test
public void testPdxDefaults() {
CacheCreation creation = new CacheCreation();
testXml(creation);
Cache c = getCache();
assertTrue(c instanceof GemFireCacheImpl);
c.loadCacheXml(generate(creation));
assertEquals(null, c.getPdxDiskStore());
assertEquals(null, c.getPdxSerializer());
assertEquals(false, c.getPdxPersistent());
assertEquals(false, c.getPdxReadSerialized());
assertEquals(false, c.getPdxIgnoreUnreadFields());
}
@Test
public void testPdxAttributes() {
CacheCreation creation = new CacheCreation();
creation.setPdxPersistent(true);
creation.setPdxReadSerialized(true);
creation.setPdxIgnoreUnreadFields(true);
creation.setPdxDiskStore("my_disk_store");
TestPdxSerializer serializer = new TestPdxSerializer();
Properties props = new Properties();
props.setProperty("hello", "there");
serializer.init(props);
creation.setPdxSerializer(serializer);
testXml(creation);
Cache c = getCache();
assertTrue(c instanceof GemFireCacheImpl);
c.loadCacheXml(generate(creation));
assertEquals("my_disk_store", c.getPdxDiskStore());
assertEquals(serializer, c.getPdxSerializer());
assertEquals(true, c.getPdxPersistent());
assertEquals(true, c.getPdxReadSerialized());
assertEquals(true, c.getPdxIgnoreUnreadFields());
// test that we can override the cache.xml attributes
{
closeCache();
CacheFactory cf = new CacheFactory();
cf.setPdxDiskStore("new disk store");
c = getCache(cf);
assertTrue(c instanceof GemFireCacheImpl);
c.loadCacheXml(generate(creation));
assertEquals("new disk store", c.getPdxDiskStore());
assertEquals(serializer, c.getPdxSerializer());
assertEquals(true, c.getPdxPersistent());
assertEquals(true, c.getPdxReadSerialized());
assertEquals(true, c.getPdxIgnoreUnreadFields());
}
{
closeCache();
CacheFactory cf = new CacheFactory();
cf.setPdxPersistent(false);
cf.setPdxIgnoreUnreadFields(false);
c = getCache(cf);
assertTrue(c instanceof GemFireCacheImpl);
c.loadCacheXml(generate(creation));
assertEquals("my_disk_store", c.getPdxDiskStore());
assertEquals(serializer, c.getPdxSerializer());
assertEquals(false, c.getPdxPersistent());
assertEquals(true, c.getPdxReadSerialized());
assertEquals(false, c.getPdxIgnoreUnreadFields());
}
{
closeCache();
CacheFactory cf = new CacheFactory();
cf.setPdxSerializer(null);
c = getCache(cf);
assertTrue(c instanceof GemFireCacheImpl);
c.loadCacheXml(generate(creation));
assertEquals("my_disk_store", c.getPdxDiskStore());
assertEquals(null, c.getPdxSerializer());
assertEquals(true, c.getPdxPersistent());
assertEquals(true, c.getPdxReadSerialized());
assertEquals(true, c.getPdxIgnoreUnreadFields());
}
{
closeCache();
CacheFactory cf = new CacheFactory();
cf.setPdxReadSerialized(false);
c = getCache(cf);
assertTrue(c instanceof GemFireCacheImpl);
c.loadCacheXml(generate(creation));
assertEquals("my_disk_store", c.getPdxDiskStore());
assertEquals(serializer, c.getPdxSerializer());
assertEquals(true, c.getPdxPersistent());
assertEquals(false, c.getPdxReadSerialized());
assertEquals(true, c.getPdxIgnoreUnreadFields());
}
}
@Test
public void testTXManagerOnClientCache() {
ClientCacheCreation cc = new ClientCacheCreation();
// CacheCreation cc = new CacheCreation();
CacheTransactionManagerCreation txMgrCreation = new CacheTransactionManagerCreation();
txMgrCreation.addListener(new TestTXListener());
cc.addCacheTransactionManagerCreation(txMgrCreation);
testXml(cc);
Cache c = getCache();
assertTrue(c instanceof ClientCache);
c.loadCacheXml(generate(cc));
ClientCache clientC = (ClientCache) c;
CacheTransactionManager mgr = clientC.getCacheTransactionManager();
assertNotNull(mgr);
assertTrue(mgr.getListeners()[0] instanceof TestTXListener);
}
@Test
public void testNoTXWriterOnClient() {
// test writer is not created
ClientCacheCreation cc = new ClientCacheCreation();
CacheTransactionManagerCreation txMgrCreation = new CacheTransactionManagerCreation();
txMgrCreation.setWriter(new TestTransactionWriter());
cc.addCacheTransactionManagerCreation(txMgrCreation);
IgnoredException expectedException = IgnoredException
.addIgnoredException(LocalizedStrings.TXManager_NO_WRITER_ON_CLIENT.toLocalizedString());
try {
testXml(cc);
fail("expected exception not thrown");
} catch (IllegalStateException e) {
} finally {
expectedException.remove();
}
}
public static class TestTXListener extends TransactionListenerAdapter implements Declarable {
public void init(Properties props) {}
@Override
public boolean equals(Object other) {
return other instanceof TestTXListener;
}
}
/**
* Tests that a region created with a named attributes set programmatically for delta propogation
* has the correct attributes.
*
*/
@Test
public void testRegionAttributesForRegionEntryCloning() throws CacheException {
final String rNameBase = getUniqueName();
final String r1 = rNameBase + "1";
// Setting multi-cast via nested region attributes
CacheCreation creation = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(creation);
attrs.setScope(Scope.LOCAL);
attrs.setEarlyAck(false);
attrs.setCloningEnable(false);
attrs.setMulticastEnabled(true);
creation.createRegion(r1, attrs);
testXml(creation);
Cache c = getCache();
assertTrue(c instanceof GemFireCacheImpl);
c.loadCacheXml(generate(creation));
Region reg1 = c.getRegion(r1);
assertNotNull(reg1);
assertEquals(Scope.LOCAL, reg1.getAttributes().getScope());
assertFalse(reg1.getAttributes().getEarlyAck());
assertTrue(reg1.getAttributes().getMulticastEnabled());
assertFalse(reg1.getAttributes().getCloningEnabled());
// changing Clonned setting
reg1.getAttributesMutator().setCloningEnabled(true);
assertTrue(reg1.getAttributes().getCloningEnabled());
reg1.getAttributesMutator().setCloningEnabled(false);
assertFalse(reg1.getAttributes().getCloningEnabled());
// for sub region - a child attribute should be inherited
String sub = "subRegion";
RegionAttributesCreation attrsSub = new RegionAttributesCreation(creation);
attrsSub.setScope(Scope.LOCAL);
reg1.createSubregion(sub, attrsSub);
Region subRegion = reg1.getSubregion(sub);
assertFalse(subRegion.getAttributes().getCloningEnabled());
subRegion.getAttributesMutator().setCloningEnabled(true);
assertTrue(subRegion.getAttributes().getCloningEnabled());
}
/**
* Tests that a region created with a named attributes set programatically for recovery-delay has
* the correct attributes.
*
*/
@Test
public void testRecoveryDelayAttributes() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setRedundantCopies(1);
paf.setTotalMaxMemory(500);
paf.setLocalMaxMemory(100);
paf.setRecoveryDelay(33);
paf.setStartupRecoveryDelay(270);
attrs.setPartitionAttributes(paf.create());
cache.createRegion("parRoot", attrs);
Region r = cache.getRegion("parRoot");
assertEquals(r.getAttributes().getPartitionAttributes().getRedundantCopies(), 1);
assertEquals(r.getAttributes().getPartitionAttributes().getLocalMaxMemory(), 100);
assertEquals(r.getAttributes().getPartitionAttributes().getTotalMaxMemory(), 500);
assertEquals(33, r.getAttributes().getPartitionAttributes().getRecoveryDelay());
assertEquals(270, r.getAttributes().getPartitionAttributes().getStartupRecoveryDelay());
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region region = c.getRegion("parRoot");
assertNotNull(region);
RegionAttributes regionAttrs = region.getAttributes();
PartitionAttributes pa = regionAttrs.getPartitionAttributes();
assertEquals(pa.getRedundantCopies(), 1);
assertEquals(pa.getLocalMaxMemory(), 100);
assertEquals(pa.getTotalMaxMemory(), 500);
assertEquals(33, r.getAttributes().getPartitionAttributes().getRecoveryDelay());
assertEquals(270, r.getAttributes().getPartitionAttributes().getStartupRecoveryDelay());
}
/**
* Tests that a region created with a named attributes set programmatically for recovery-delay has
* the correct attributes.
*
*/
@Test
public void testDefaultRecoveryDelayAttributes() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setRedundantCopies(1);
paf.setTotalMaxMemory(500);
paf.setLocalMaxMemory(100);
attrs.setPartitionAttributes(paf.create());
cache.createRegion("parRoot", attrs);
Region r = cache.getRegion("parRoot");
assertEquals(r.getAttributes().getPartitionAttributes().getRedundantCopies(), 1);
assertEquals(r.getAttributes().getPartitionAttributes().getLocalMaxMemory(), 100);
assertEquals(r.getAttributes().getPartitionAttributes().getTotalMaxMemory(), 500);
assertEquals(-1, r.getAttributes().getPartitionAttributes().getRecoveryDelay());
assertEquals(0, r.getAttributes().getPartitionAttributes().getStartupRecoveryDelay());
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region region = c.getRegion("parRoot");
assertNotNull(region);
RegionAttributes regionAttrs = region.getAttributes();
PartitionAttributes pa = regionAttrs.getPartitionAttributes();
assertEquals(pa.getRedundantCopies(), 1);
assertEquals(pa.getLocalMaxMemory(), 100);
assertEquals(pa.getTotalMaxMemory(), 500);
assertEquals(-1, r.getAttributes().getPartitionAttributes().getRecoveryDelay());
assertEquals(0, r.getAttributes().getPartitionAttributes().getStartupRecoveryDelay());
}
/**
* Test the ResourceManager element's critical-heap-percentage and eviction-heap-percentage
* attributes
*
* @throws Exception
*/
@Test
public void testResourceManagerThresholds() throws Exception {
CacheCreation cache = new CacheCreation();
final float low = 90.0f;
final float high = 95.0f;
Cache c;
ResourceManagerCreation rmc = new ResourceManagerCreation();
rmc.setEvictionHeapPercentage(low);
rmc.setCriticalHeapPercentage(high);
cache.setResourceManagerCreation(rmc);
testXml(cache);
{
c = getCache();
assertEquals(low, c.getResourceManager().getEvictionHeapPercentage(), 0);
assertEquals(high, c.getResourceManager().getCriticalHeapPercentage(), 0);
}
closeCache();
rmc = new ResourceManagerCreation();
// Set them to similar values
rmc.setEvictionHeapPercentage(low);
rmc.setCriticalHeapPercentage(low + 1);
cache.setResourceManagerCreation(rmc);
testXml(cache);
{
c = getCache();
assertEquals(low, c.getResourceManager().getEvictionHeapPercentage(), 0);
assertEquals(low + 1, c.getResourceManager().getCriticalHeapPercentage(), 0);
}
closeCache();
rmc = new ResourceManagerCreation();
rmc.setEvictionHeapPercentage(high);
rmc.setCriticalHeapPercentage(low);
cache.setResourceManagerCreation(rmc);
IgnoredException expectedException = IgnoredException.addIgnoredException(
LocalizedStrings.MemoryMonitor_EVICTION_PERCENTAGE_LTE_CRITICAL_PERCENTAGE
.toLocalizedString());
try {
testXml(cache);
assertTrue(false);
} catch (IllegalArgumentException expected) {
} finally {
expectedException.remove();
closeCache();
}
// Disable eviction
rmc = new ResourceManagerCreation();
rmc.setEvictionHeapPercentage(0);
rmc.setCriticalHeapPercentage(low);
cache.setResourceManagerCreation(rmc);
testXml(cache);
{
c = getCache();
assertEquals(0f, c.getResourceManager().getEvictionHeapPercentage(), 0);
assertEquals(low, c.getResourceManager().getCriticalHeapPercentage(), 0);
}
closeCache();
// Disable refusing ops in "red zone"
rmc = new ResourceManagerCreation();
rmc.setEvictionHeapPercentage(low);
rmc.setCriticalHeapPercentage(0);
cache.setResourceManagerCreation(rmc);
testXml(cache);
{
c = getCache();
assertEquals(low, c.getResourceManager().getEvictionHeapPercentage(), 0);
assertEquals(0f, c.getResourceManager().getCriticalHeapPercentage(), 0);
}
closeCache();
// Disable both
rmc = new ResourceManagerCreation();
rmc.setEvictionHeapPercentage(0);
rmc.setCriticalHeapPercentage(0);
cache.setResourceManagerCreation(rmc);
testXml(cache);
c = getCache();
assertEquals(0f, c.getResourceManager().getEvictionHeapPercentage(), 0);
assertEquals(0f, c.getResourceManager().getCriticalHeapPercentage(), 0);
}
// A bunch of classes for use in testing the serialization schtuff
public static class DS1 implements DataSerializable {
public void fromData(DataInput in) throws IOException, ClassNotFoundException {}
public void toData(DataOutput out) throws IOException {}
};
public static class DS2 implements DataSerializable {
public void fromData(DataInput in) throws IOException, ClassNotFoundException {}
public void toData(DataOutput out) throws IOException {}
};
public static class NotDataSerializable implements Serializable {
}
public static class GoodSerializer extends DataSerializer {
public GoodSerializer() {}
@Override
public Object fromData(DataInput in) throws IOException, ClassNotFoundException {
return null;
}
@Override
public int getId() {
return 101;
}
@Override
public Class[] getSupportedClasses() {
return new Class[] {DS1.class};
}
@Override
public boolean toData(Object o, DataOutput out) throws IOException {
return false;
}
}
public static class BadSerializer extends DataSerializer {
@Override
public Object fromData(DataInput in) throws IOException, ClassNotFoundException {
return null;
}
@Override
public int getId() {
return 101;
}
@Override
public Class[] getSupportedClasses() {
return null;
}
@Override
public boolean toData(Object o, DataOutput out) throws IOException {
return false;
}
}
@Test
public void testSerializationRegistration() {
CacheCreation cc = new CacheCreation();
SerializerCreation sc = new SerializerCreation();
cc.setSerializerCreation(sc);
sc.registerInstantiator(DS1.class, 15);
sc.registerInstantiator(DS2.class, 16);
sc.registerSerializer(GoodSerializer.class);
testXml(cc);
// Now make sure all of the classes were registered....
assertEquals(15, InternalInstantiator.getClassId(DS1.class));
assertEquals(16, InternalInstantiator.getClassId(DS2.class));
assertEquals(GoodSerializer.class, InternalDataSerializer.getSerializer(101).getClass());
sc = new SerializerCreation();
sc.registerInstantiator(NotDataSerializable.class, 15);
closeCache();
cc.setSerializerCreation(sc);
IgnoredException expectedException =
IgnoredException.addIgnoredException("While reading Cache XML file");
try {
testXml(cc);
fail("Instantiator should not have registered due to bad class.");
} catch (Exception e) {
} finally {
expectedException.remove();
}
sc = new SerializerCreation();
sc.registerSerializer(BadSerializer.class);
closeCache();
cc.setSerializerCreation(sc);
IgnoredException expectedException1 =
IgnoredException.addIgnoredException("While reading Cache XML file");
try {
testXml(cc);
fail("Serializer should not have registered due to bad class.");
} catch (Exception e) {
} finally {
expectedException1.remove();
}
}
/**
* Tests that a region created with a named attributes set programmatically for partition-resolver
* has the correct attributes.
*
*/
@Test
public void testPartitionedRegionAttributesForCustomPartitioning() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
CacheXMLPartitionResolver partitionResolver = new CacheXMLPartitionResolver();
Properties params = new Properties();
params.setProperty("initial-index-value", "1000");
params.setProperty("secondary-index-value", "5000");
partitionResolver.init(params);
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setRedundantCopies(1);
paf.setTotalMaxMemory(500);
paf.setLocalMaxMemory(100);
paf.setPartitionResolver(partitionResolver);
attrs.setPartitionAttributes(paf.create());
cache.createRegion("parRoot", attrs);
Region r = cache.getRegion("parRoot");
assertEquals(r.getAttributes().getPartitionAttributes().getRedundantCopies(), 1);
assertEquals(r.getAttributes().getPartitionAttributes().getLocalMaxMemory(), 100);
assertEquals(r.getAttributes().getPartitionAttributes().getTotalMaxMemory(), 500);
assertEquals(r.getAttributes().getPartitionAttributes().getPartitionResolver(),
partitionResolver);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region region = c.getRegion("parRoot");
assertNotNull(region);
RegionAttributes regionAttrs = region.getAttributes();
PartitionAttributes pa = regionAttrs.getPartitionAttributes();
assertEquals(pa.getRedundantCopies(), 1);
assertEquals(pa.getLocalMaxMemory(), 100);
assertEquals(pa.getTotalMaxMemory(), 500);
assertNotNull(pa.getPartitionResolver().getClass());
assertEquals(pa.getPartitionResolver(), partitionResolver);
}
/**
* Tests that a cache created with FunctionService and registered FabricFunction has correct
* registered Function
*
*/
@Test
public void testCacheCreationWithFuntionService() throws CacheException {
CacheCreation cache = new CacheCreation();
FunctionServiceCreation fsc = new FunctionServiceCreation();
TestFunction function1 = new TestFunction(true, TestFunction.TEST_FUNCTION2);
TestFunction function2 = new TestFunction(true, TestFunction.TEST_FUNCTION3);
TestFunction function3 = new TestFunction(true, TestFunction.TEST_FUNCTION4);
fsc.registerFunction(function1);
fsc.registerFunction(function2);
fsc.registerFunction(function3);
fsc.create();
cache.setFunctionServiceCreation(fsc);
testXml(cache);
getCache();
Map<String, Function> functionIdMap = FunctionService.getRegisteredFunctions();
assertEquals(3, functionIdMap.size());
assertTrue(function1.equals(functionIdMap.get(function1.getId())));
assertTrue(function2.equals(functionIdMap.get(function2.getId())));
assertTrue(function3.equals(functionIdMap.get(function3.getId())));
}
/**
* Tests that a Partitioned Region can be created with a named attributes set programmatically for
* ExpirationAttributes
*
*/
@Test
public void testPartitionedRegionAttributesForExpiration() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setStatisticsEnabled(true);
RegionAttributes rootAttrs = null;
ExpirationAttributes expiration = new ExpirationAttributes(60, ExpirationAction.DESTROY);
CacheXMLPartitionResolver partitionResolver = new CacheXMLPartitionResolver();
Properties params = new Properties();
params.setProperty("initial-index-value", "1000");
params.setProperty("secondary-index-value", "5000");
partitionResolver.init(params);
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setRedundantCopies(1);
paf.setTotalMaxMemory(500);
paf.setLocalMaxMemory(100);
paf.setPartitionResolver(partitionResolver);
AttributesFactory fac = new AttributesFactory(attrs);
fac.setEntryTimeToLive(expiration);
fac.setEntryIdleTimeout(expiration);
fac.setPartitionAttributes(paf.create());
rootAttrs = fac.create();
cache.createRegion("parRoot", rootAttrs);
Region r = cache.getRegion("parRoot");
assertNotNull(r);
assertEquals(r.getAttributes().getPartitionAttributes().getRedundantCopies(), 1);
assertEquals(r.getAttributes().getPartitionAttributes().getLocalMaxMemory(), 100);
assertEquals(r.getAttributes().getPartitionAttributes().getTotalMaxMemory(), 500);
assertEquals(r.getAttributes().getPartitionAttributes().getPartitionResolver(),
partitionResolver);
assertEquals(r.getAttributes().getEntryIdleTimeout().getTimeout(), expiration.getTimeout());
assertEquals(r.getAttributes().getEntryTimeToLive().getTimeout(), expiration.getTimeout());
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region region = c.getRegion("parRoot");
assertNotNull(region);
RegionAttributes regionAttrs = region.getAttributes();
PartitionAttributes pa = regionAttrs.getPartitionAttributes();
assertEquals(pa.getRedundantCopies(), 1);
assertEquals(pa.getLocalMaxMemory(), 100);
assertEquals(pa.getTotalMaxMemory(), 500);
assertNotNull(pa.getPartitionResolver().getClass());
assertEquals(pa.getPartitionResolver(), partitionResolver);
assertEquals(regionAttrs.getEntryIdleTimeout().getTimeout(), expiration.getTimeout());
assertEquals(regionAttrs.getEntryTimeToLive().getTimeout(), expiration.getTimeout());
}
/**
* Tests that a Partitioned Region can be created with a named attributes set programmatically for
* ExpirationAttributes
*
*/
@Test
public void testPartitionedRegionAttributesForEviction() throws CacheException {
final int redundantCopies = 1;
CacheCreation cache = new CacheCreation();
if (getGemFireVersion().equals(CacheXml.VERSION_6_0)) {
ResourceManagerCreation rm = new ResourceManagerCreation();
rm.setCriticalHeapPercentage(95);
cache.setResourceManagerCreation(rm);
}
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setStatisticsEnabled(true);
RegionAttributes rootAttrs = null;
ExpirationAttributes expiration = new ExpirationAttributes(60, ExpirationAction.DESTROY);
CacheXMLPartitionResolver partitionResolver = new CacheXMLPartitionResolver();
Properties params = new Properties();
params.setProperty("initial-index-value", "1000");
params.setProperty("secondary-index-value", "5000");
partitionResolver.init(params);
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setRedundantCopies(redundantCopies);
paf.setTotalMaxMemory(500);
paf.setLocalMaxMemory(100);
paf.setPartitionResolver(partitionResolver);
AttributesFactory fac = new AttributesFactory(attrs);
// TODO mthomas 01/20/09 Move test back to using LRUHeap when config issues have settled
// if (getGemFireVersion().equals(CacheXml.GEMFIRE_6_0)) {
// fac.setEvictionAttributes(EvictionAttributes.createLRUHeapAttributes(null,
// EvictionAction.OVERFLOW_TO_DISK));
// } else {
fac.setEvictionAttributes(
EvictionAttributes.createLRUMemoryAttributes(100, null, EvictionAction.OVERFLOW_TO_DISK));
// }
fac.setEntryTimeToLive(expiration);
fac.setEntryIdleTimeout(expiration);
DiskWriteAttributesFactory dwaf = new DiskWriteAttributesFactory();
dwaf.setSynchronous(true);
/*
* fac.setDiskWriteAttributes(dwaf.create()); File[] diskDirs = new File[1]; diskDirs[0] = new
* File("overflowDir/" + "_" + OSProcess.getId()); diskDirs[0].mkdirs();
* fac.setDiskDirs(diskDirs);
*/
fac.setPartitionAttributes(paf.create());
rootAttrs = fac.create();
cache.createRegion("parRoot", rootAttrs);
Region r = cache.getRegion("parRoot");
assertNotNull(r);
assertEquals(r.getAttributes().getPartitionAttributes().getRedundantCopies(), redundantCopies);
assertEquals(r.getAttributes().getPartitionAttributes().getLocalMaxMemory(), 100);
assertEquals(r.getAttributes().getPartitionAttributes().getTotalMaxMemory(), 500);
assertEquals(r.getAttributes().getPartitionAttributes().getPartitionResolver(),
partitionResolver);
assertEquals(r.getAttributes().getEntryIdleTimeout().getTimeout(), expiration.getTimeout());
assertEquals(r.getAttributes().getEntryTimeToLive().getTimeout(), expiration.getTimeout());
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region region = c.getRegion("parRoot");
assertNotNull(region);
RegionAttributes regionAttrs = region.getAttributes();
PartitionAttributes pa = regionAttrs.getPartitionAttributes();
EvictionAttributes ea = regionAttrs.getEvictionAttributes();
assertEquals(pa.getRedundantCopies(), 1);
assertEquals(pa.getLocalMaxMemory(), 100);
assertEquals(pa.getTotalMaxMemory(), 500);
assertNotNull(pa.getPartitionResolver().getClass());
assertEquals(pa.getPartitionResolver(), partitionResolver);
assertEquals(regionAttrs.getEntryIdleTimeout().getTimeout(), expiration.getTimeout());
assertEquals(regionAttrs.getEntryTimeToLive().getTimeout(), expiration.getTimeout());
// TODO mthomas 01/20/09 Move test back to using LRUHeap when config issues have settled
// if (getGemFireVersion().equals(CacheXml.GEMFIRE_6_0)) {
// assertIndexDetailsEquals(ea.getAlgorithm(),EvictionAlgorithm.LRU_HEAP);
// } else {
assertEquals(ea.getAlgorithm(), EvictionAlgorithm.LRU_MEMORY);
// }
assertEquals(ea.getAction(), EvictionAction.OVERFLOW_TO_DISK);
}
@Test
public void testPartitionedRegionAttributesForCoLocation() {
closeCache();
CacheCreation cache = new CacheCreation();
RegionAttributesCreation custAttrs = new RegionAttributesCreation(cache);
RegionAttributesCreation orderAttrs = new RegionAttributesCreation(cache);
PartitionAttributesFactory custPaf = new PartitionAttributesFactory();
PartitionAttributesFactory orderPaf = new PartitionAttributesFactory();
custPaf.setRedundantCopies(1);
custPaf.setTotalMaxMemory(500);
custPaf.setLocalMaxMemory(100);
custAttrs.setPartitionAttributes(custPaf.create());
cache.createRegion("Customer", custAttrs);
orderPaf.setRedundantCopies(1);
orderPaf.setTotalMaxMemory(500);
orderPaf.setLocalMaxMemory(100);
orderPaf.setColocatedWith("Customer");
orderAttrs.setPartitionAttributes(orderPaf.create());
cache.createRegion("Order", orderAttrs);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region cust = c.getRegion(Region.SEPARATOR + "Customer");
assertNotNull(cust);
Region order = c.getRegion(Region.SEPARATOR + "Order");
assertNotNull(order);
String coLocatedRegion = order.getAttributes().getPartitionAttributes().getColocatedWith();
assertEquals("Customer", coLocatedRegion);
}
@Test
public void testPartitionedRegionAttributesForCoLocation2() {
closeCache();
setXmlFile(findFile("coLocation.xml"));
Cache c = getCache();
assertNotNull(c);
Region cust = c.getRegion(Region.SEPARATOR + "Customer");
assertNotNull(cust);
Region order = c.getRegion(Region.SEPARATOR + "Order");
assertNotNull(order);
assertTrue(cust.getAttributes().getPartitionAttributes().getColocatedWith() == null);
assertTrue(
order.getAttributes().getPartitionAttributes().getColocatedWith().equals("Customer"));
}
@Test
public void testPartitionedRegionAttributesForMemLruWithoutMaxMem() throws CacheException {
final int redundantCopies = 1;
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setStatisticsEnabled(true);
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setRedundantCopies(redundantCopies);
paf.setTotalMaxMemory(500);
paf.setLocalMaxMemory(100);
AttributesFactory fac = new AttributesFactory(attrs);
fac.setEvictionAttributes(
EvictionAttributes.createLRUMemoryAttributes(null, EvictionAction.LOCAL_DESTROY));
fac.setPartitionAttributes(paf.create());
cache.createRegion("parRoot", fac.create());
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region region = c.getRegion("parRoot");
assertNotNull(region);
RegionAttributes regionAttrs = region.getAttributes();
PartitionAttributes pa = regionAttrs.getPartitionAttributes();
EvictionAttributes ea = regionAttrs.getEvictionAttributes();
assertEquals(pa.getRedundantCopies(), 1);
assertEquals(pa.getLocalMaxMemory(), 100);
assertEquals(pa.getTotalMaxMemory(), 500);
assertEquals(ea.getAlgorithm(), EvictionAlgorithm.LRU_MEMORY);
assertEquals(ea.getAction(), EvictionAction.LOCAL_DESTROY);
assertEquals(ea.getMaximum(), pa.getLocalMaxMemory());
}
@Test
public void testPartitionedRegionAttributesForMemLruWithMaxMem() throws CacheException {
final int redundantCopies = 1;
final int maxMem = 25;
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setStatisticsEnabled(true);
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setRedundantCopies(redundantCopies);
paf.setTotalMaxMemory(500);
paf.setLocalMaxMemory(100);
AttributesFactory fac = new AttributesFactory(attrs);
fac.setEvictionAttributes(
EvictionAttributes.createLRUMemoryAttributes(maxMem, null, EvictionAction.LOCAL_DESTROY));
fac.setPartitionAttributes(paf.create());
cache.createRegion("parRoot", fac.create());
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region region = c.getRegion("parRoot");
assertNotNull(region);
RegionAttributes regionAttrs = region.getAttributes();
PartitionAttributes pa = regionAttrs.getPartitionAttributes();
EvictionAttributes ea = regionAttrs.getEvictionAttributes();
assertEquals(pa.getRedundantCopies(), 1);
assertEquals(pa.getLocalMaxMemory(), 100);
assertEquals(pa.getTotalMaxMemory(), 500);
assertEquals(ea.getAlgorithm(), EvictionAlgorithm.LRU_MEMORY);
assertEquals(ea.getAction(), EvictionAction.LOCAL_DESTROY);
assertNotSame(ea.getMaximum(), maxMem);
assertEquals(ea.getMaximum(), pa.getLocalMaxMemory());
}
@Test
public void testReplicatedRegionAttributesForMemLruWithoutMaxMem() throws CacheException {
final int redundantCopies = 1;
CacheCreation cache = new CacheCreation();
AttributesFactory fac = new AttributesFactory();
fac.setDataPolicy(DataPolicy.REPLICATE);
fac.setEvictionAttributes(
EvictionAttributes.createLRUMemoryAttributes(null, EvictionAction.OVERFLOW_TO_DISK));
cache.createRegion("parRoot", fac.create());
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region region = c.getRegion("parRoot");
assertNotNull(region);
RegionAttributes regionAttrs = region.getAttributes();
EvictionAttributes ea = regionAttrs.getEvictionAttributes();
assertEquals(ea.getAlgorithm(), EvictionAlgorithm.LRU_MEMORY);
assertEquals(ea.getAction(), EvictionAction.OVERFLOW_TO_DISK);
assertEquals(ea.getMaximum(), MemLRUCapacityController.DEFAULT_MAXIMUM_MEGABYTES);
}
@Test
public void testReplicatedRegionAttributesForMemLruWithMaxMem() throws CacheException {
final int redundantCopies = 1;
final int maxMem = 25;
CacheCreation cache = new CacheCreation();
AttributesFactory fac = new AttributesFactory();
fac.setDataPolicy(DataPolicy.REPLICATE);
fac.setEvictionAttributes(EvictionAttributes.createLRUMemoryAttributes(maxMem, null,
EvictionAction.OVERFLOW_TO_DISK));
cache.createRegion("parRoot", fac.create());
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region region = c.getRegion("parRoot");
assertNotNull(region);
RegionAttributes regionAttrs = region.getAttributes();
EvictionAttributes ea = regionAttrs.getEvictionAttributes();
assertEquals(ea.getAlgorithm(), EvictionAlgorithm.LRU_MEMORY);
assertEquals(ea.getAction(), EvictionAction.OVERFLOW_TO_DISK);
assertEquals(ea.getMaximum(), maxMem);
}
/**
* Tests the groups subelement on bridge-server.
*/
@Test
public void testDefaultCacheServerGroups() throws CacheException {
CacheCreation cache = new CacheCreation();
CacheServer bs = cache.addCacheServer();
bs.setPort(AvailablePortHelper.getRandomAvailableTCPPort());
bs.setGroups(CacheServer.DEFAULT_GROUPS);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
CacheServer server = (CacheServer) cache.getCacheServers().iterator().next();
assertNotNull(server);
assertEquals(CacheServer.DEFAULT_GROUPS, server.getGroups());
}
@Test
public void testOneCacheServerGroups() throws CacheException {
CacheCreation cache = new CacheCreation();
CacheServer bs = cache.addCacheServer();
bs.setPort(AvailablePortHelper.getRandomAvailableTCPPort());
String[] groups = new String[] {"group1"};
bs.setGroups(groups);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
CacheServer server = (CacheServer) cache.getCacheServers().iterator().next();
assertNotNull(server);
assertEquals(Arrays.asList(groups), Arrays.asList(server.getGroups()));
}
@Test
public void testTwoCacheServerGroups() throws CacheException {
CacheCreation cache = new CacheCreation();
CacheServer bs = cache.addCacheServer();
bs.setPort(AvailablePortHelper.getRandomAvailableTCPPort());
String[] groups = new String[] {"group1", "group2"};
bs.setGroups(groups);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
CacheServer server = (CacheServer) cache.getCacheServers().iterator().next();
assertNotNull(server);
assertEquals(Arrays.asList(groups), Arrays.asList(server.getGroups()));
}
@Test
public void testDefaultCacheServerBindAddress() throws CacheException {
CacheCreation cache = new CacheCreation();
CacheServer bs = cache.addCacheServer();
bs.setPort(AvailablePortHelper.getRandomAvailableTCPPort());
testXml(cache);
Cache c = getCache();
assertNotNull(c);
CacheServer server = (CacheServer) cache.getCacheServers().iterator().next();
assertNotNull(server);
assertEquals(CacheServer.DEFAULT_BIND_ADDRESS, server.getBindAddress());
}
@Test
public void testCacheServerBindAddress() throws CacheException {
CacheCreation cache = new CacheCreation();
CacheServer bs = cache.addCacheServer();
bs.setPort(AvailablePortHelper.getRandomAvailableTCPPort());
final String BA = ALIAS1;
bs.setBindAddress(BA);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
CacheServer server = (CacheServer) cache.getCacheServers().iterator().next();
assertNotNull(server);
assertEquals(BA, server.getBindAddress());
}
@Test
public void testCacheServerHostnameForClients() throws CacheException {
CacheCreation cache = new CacheCreation();
CacheServer bs = cache.addCacheServer();
bs.setPort(AvailablePortHelper.getRandomAvailableTCPPort());
final String BA = ALIAS1;
bs.setBindAddress(BA);
bs.setHostnameForClients("clientHostName");
testXml(cache);
Cache c = getCache();
assertNotNull(c);
CacheServer server = (CacheServer) cache.getCacheServers().iterator().next();
assertNotNull(server);
assertEquals(BA, server.getBindAddress());
assertEquals("clientHostName", server.getHostnameForClients());
}
@Test
public void testTwoConnectionPools() throws CacheException {
getSystem();
CacheCreation cache = new CacheCreation();
PoolFactory f = cache.createPoolFactory();
f.addLocator(ALIAS2, 3777).create("mypool");
f.reset().addLocator(ALIAS1, 3888).create("mypool2");
try {
f.create("mypool");
fail("expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
f.create("mypool2");
fail("expected IllegalStateException");
} catch (IllegalStateException expected) {
}
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setPoolName("mypool");
cache.createVMRegion("rootNORMAL", attrs);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
Region r = c.getRegion("rootNORMAL");
assertNotNull(r);
assertEquals("mypool", r.getAttributes().getPoolName());
Pool cp = PoolManager.find("mypool");
assertNotNull(cp);
assertEquals(0, cp.getServers().size());
assertEquals(1, cp.getLocators().size());
assertEquals(createINSA(ALIAS2, 3777), cp.getLocators().get(0));
cp = PoolManager.find("mypool2");
assertNotNull(cp);
assertEquals(0, cp.getServers().size());
assertEquals(1, cp.getLocators().size());
assertEquals(createINSA(ALIAS1, 3888), cp.getLocators().get(0));
}
@Test
public void testNoConnectionPools() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setPoolName("mypool");
cache.createVMRegion("rootNORMAL", attrs);
IgnoredException expectedException = IgnoredException.addIgnoredException(
LocalizedStrings.AbstractRegion_THE_CONNECTION_POOL_0_HAS_NOT_BEEN_CREATED
.toLocalizedString("mypool"));
try {
testXml(cache);
fail("expected IllegalStateException");
} catch (IllegalStateException expected) {
} finally {
expectedException.remove();
}
}
@Test
public void testAlreadyExistingPool() throws CacheException {
getSystem();
PoolFactoryImpl f = (PoolFactoryImpl) PoolManager.createFactory();
f.setStartDisabled(true).addLocator(ALIAS2, 12345).create("mypool");
try {
// now make sure declarative cache can't create the same pool
CacheCreation cache = new CacheCreation();
cache.createPoolFactory().addLocator(ALIAS2, 12345).create("mypool");
IgnoredException expectedException = IgnoredException.addIgnoredException(
LocalizedStrings.PoolManagerImpl_POOL_NAMED_0_ALREADY_EXISTS.toLocalizedString("mypool"));
try {
testXml(cache);
fail("expected IllegalStateException");
} catch (IllegalStateException expected) {
} finally {
expectedException.remove();
}
} finally {
PoolManager.close();
}
}
@Test
public void testDynamicRegionFactoryConnectionPool() throws CacheException, IOException {
IgnoredException.addIgnoredException("Connection reset");
IgnoredException.addIgnoredException("SocketTimeoutException");
IgnoredException.addIgnoredException("ServerConnectivityException");
IgnoredException.addIgnoredException("Socket Closed");
getSystem();
VM vm0 = Host.getHost(0).getVM(0);
final int port = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET);
vm0.invoke(new SerializableCallable("Create cache server") {
public Object call() throws IOException {
DynamicRegionFactory.get().open();
Cache cache = getCache();
CacheServer bridge = cache.addCacheServer();
bridge.setPort(port);
bridge.setNotifyBySubscription(true);
bridge.start();
return null;
}
});
CacheCreation cache = new CacheCreation();
cache.createPoolFactory().addServer(NetworkUtils.getServerHostName(vm0.getHost()), port)
.setSubscriptionEnabled(true).create("connectionPool");
cache.setDynamicRegionFactoryConfig(
new DynamicRegionFactory.Config(null, "connectionPool", false, false));
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
cache.createRegion("root", attrs);
// note that testXml can't check if they are same because enabling
// dynamic regions causes a meta region to be produced.
testXml(cache, false);
assertEquals(false, DynamicRegionFactory.get().getConfig().getRegisterInterest());
assertEquals(false, DynamicRegionFactory.get().getConfig().getPersistBackup());
assertEquals(true, DynamicRegionFactory.get().isOpen());
assertEquals(null, DynamicRegionFactory.get().getConfig().getDiskDir());
assertEquals("connectionPool", DynamicRegionFactory.get().getConfig().getPoolName());
Region dr = getCache().getRegion("__DynamicRegions");
if (dr != null) {
dr.localDestroyRegion();
}
}
/**
* Tests the client subscription attributes (<code>eviction-policy</code>, <code>capacity</code>
* and <code>overflow-directory</code>) related to client subscription config in gemfire
* cache-server framework
*
* @throws CacheException
* @since GemFire 5.7
*/
@Test
public void testBridgeAttributesRelatedToHAOverFlow() throws CacheException {
CacheCreation cache = new CacheCreation();
cache.setMessageSyncInterval(3445);
CacheServer bs = cache.addCacheServer();
ClientSubscriptionConfig csc = bs.getClientSubscriptionConfig();
csc.setEvictionPolicy("entry");
cache.getLogger().config("EvictionPolicy : " + csc.getEvictionPolicy());
csc.setCapacity(501);
cache.getLogger().config("EvictionCapacity : " + csc.getCapacity());
csc.setOverflowDirectory("overFlow");
cache.getLogger().config("EvictionOverflowDirectory : " + csc.getOverflowDirectory());
bs.setPort(AvailablePortHelper.getRandomAvailableTCPPort());
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.NORMAL);
cache.createVMRegion("rootNORMAL", attrs);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
CacheServer server = (CacheServer) cache.getCacheServers().iterator().next();
assertNotNull(server);
ClientSubscriptionConfig chaqf = server.getClientSubscriptionConfig();
assertEquals("entry", chaqf.getEvictionPolicy());
assertEquals(501, chaqf.getCapacity());
assertEquals("overFlow", chaqf.getOverflowDirectory());
}
@Test
public void testBridgeLoadProbe() {
CacheCreation cache = new CacheCreation();
CacheServer server = cache.addCacheServer();
server.setPort(AvailablePortHelper.getRandomAvailableTCPPort());
server.setLoadProbe(new MyLoadProbe());
testXml(cache);
Cache c = getCache();
server = c.getCacheServers().get(0);
assertEquals(MyLoadProbe.class, server.getLoadProbe().getClass());
}
@Test
public void testLoadPollInterval() {
CacheCreation cache = new CacheCreation();
CacheServer server = cache.addCacheServer();
server.setPort(AvailablePortHelper.getRandomAvailableTCPPort());
server.setLoadPollInterval(12345);
testXml(cache);
Cache c = getCache();
server = c.getCacheServers().get(0);
assertEquals(12345, server.getLoadPollInterval());
}
public static class MyLoadProbe extends ServerLoadProbeAdapter implements Declarable {
public ServerLoad getLoad(ServerMetrics metrics) {
return null;
}
public void init(Properties props) {}
public boolean equals(Object o) {
return o instanceof MyLoadProbe;
}
}
static public class Expiry1 implements CustomExpiry, Declarable {
public ExpirationAttributes getExpiry(Entry entry) {
return null;
}
public void init(Properties props) {}
public void close() {}
}
static public class Expiry2 implements CustomExpiry, Declarable {
public ExpirationAttributes getExpiry(Entry entry) {
return null;
}
public void init(Properties props) {}
public void close() {}
}
static public class Expiry3 implements CustomExpiry, Declarable {
public ExpirationAttributes getExpiry(Entry entry) {
return null;
}
public void init(Properties props) {}
public void close() {}
}
static public class Expiry4 implements CustomExpiry, Declarable {
public ExpirationAttributes getExpiry(Entry entry) {
return null;
}
public void init(Properties props) {}
public void close() {}
}
static public class Expiry5 implements CustomExpiry, Declarable2 {
public ExpirationAttributes getExpiry(Entry entry) {
return null;
}
public void init(Properties props) {}
public void close() {}
/*
* (non-Javadoc)
*
* @see org.apache.geode.internal.cache.xmlcache.Declarable2#getConfig()
*/
public Properties getConfig() {
Properties p = new Properties();
p.put("prop1", "val1");
p.put("prop2", "val2");
return p;
}
}
/**
* Test both customEntryIdleTime and customEntryTimeToLife
*/
@Test
public void testCustomEntryXml() {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_NO_ACK);
RegionCreation root = (RegionCreation) cache.createRegion("root", attrs);
{
attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_NO_ACK);
attrs.setInitialCapacity(142);
attrs.setLoadFactor(42.42f);
attrs.setStatisticsEnabled(true);
attrs.setCustomEntryIdleTimeout(new Expiry1());
attrs.setCustomEntryTimeToLive(new Expiry5());
root.createSubregion("one", attrs);
}
{
attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_ACK);
attrs.setInitialCapacity(242);
attrs.setStatisticsEnabled(true);
attrs.setCustomEntryIdleTimeout(new Expiry2());
Region region = root.createSubregion("two", attrs);
{
attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_ACK);
attrs.setLoadFactor(43.43f);
attrs.setStatisticsEnabled(true);
attrs.setCustomEntryIdleTimeout(new Expiry3());
attrs.setCustomEntryTimeToLive(new Expiry4());
region.createSubregion("three", attrs);
}
}
testXml(cache);
}
@Test
public void testPreloadDataPolicy() throws CacheException {
CacheCreation cache = new CacheCreation();
{
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.NORMAL);
cache.createRegion("rootNORMAL", attrs);
}
{
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.NORMAL);
attrs.setSubscriptionAttributes(new SubscriptionAttributes(InterestPolicy.ALL));
cache.createRegion("rootNORMAL_ALL", attrs);
}
{
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setMirrorType(MirrorType.KEYS_VALUES);
cache.createRegion("rootREPLICATE", attrs);
}
{
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
cache.createRegion("rootPERSISTENT_REPLICATE", attrs);
}
{
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.EMPTY);
cache.createRegion("rootEMPTY", attrs);
}
{
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.EMPTY);
attrs.setSubscriptionAttributes(new SubscriptionAttributes(InterestPolicy.ALL));
cache.createRegion("rootEMPTY_ALL", attrs);
}
{
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.PRELOADED);
attrs.setSubscriptionAttributes(new SubscriptionAttributes(InterestPolicy.ALL));
cache.createRegion("rootPRELOADED_ALL", attrs);
}
testXml(cache);
}
/**
* Test EnableSubscriptionConflation region attribute
*
* @since GemFire 5.7
*/
@Test
public void testEnableSubscriptionConflationAttribute() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setEnableSubscriptionConflation(true);
cache.createRegion("root", attrs);
testXml(cache);
assertEquals(true, cache.getRegion("root").getAttributes().getEnableSubscriptionConflation());
}
/**
* Tests that a region created with a named attributes has the correct attributes.
*/
@Test
public void testPartitionedRegionXML() throws CacheException {
setXmlFile(findFile("partitionedRegion51.xml"));
final String regionName = "pRoot";
Cache cache = getCache();
Region region = cache.getRegion(regionName);
assertNotNull(region);
Host host = Host.getHost(0);
final VM vm0 = host.getVM(0);
final VM vm1 = host.getVM(1);
CacheSerializableRunnable init =
new CacheSerializableRunnable("initUsingPartitionedRegionXML") {
public void run2() throws CacheException {
final Cache c;
try {
lonerDistributedSystem = false;
c = getCache();
} finally {
lonerDistributedSystem = true;
}
Region r = c.getRegion(regionName);
assertNotNull(r);
RegionAttributes attrs = r.getAttributes();
assertNotNull(attrs.getPartitionAttributes());
PartitionAttributes pa = attrs.getPartitionAttributes();
assertEquals(pa.getRedundantCopies(), 1);
assertEquals(pa.getLocalMaxMemory(), 32);
assertEquals(pa.getTotalMaxMemory(), 96);
assertEquals(pa.getTotalNumBuckets(), 119);
r = c.getRegion("bug37905");
assertTrue("region should have been an instance of PartitionedRegion but was not",
r instanceof PartitionedRegion);
}
};
init.run2();
vm0.invoke(init);
vm1.invoke(init);
vm0.invoke(new CacheSerializableRunnable("putUsingPartitionedRegionXML1") {
public void run2() throws CacheException {
final String val = "prValue0";
final Integer key = new Integer(10);
Cache c = getCache();
Region r = c.getRegion(regionName);
assertNotNull(r);
r.put(key, val);
assertEquals(val, r.get(key));
}
});
vm1.invoke(new CacheSerializableRunnable("putUsingPartitionedRegionXML2") {
public void run2() throws CacheException {
final String val = "prValue1";
final Integer key = new Integer(14);
Cache c = getCache();
Region r = c.getRegion(regionName);
assertNotNull(r);
r.put(key, val);
assertEquals(val, r.get(key));
}
});
}
/**
* Tests the <code>message-sync-interval</code> attribute of attribute is related to HA of
* client-queues in gemfire ca framework. This attribute is the frequency at which a messent by
* the primary cache-server node to all the secondary cache-server nodes to remove the events
* which have already been dispatched from the queue
*
* @throws CacheException
*/
@Test
public void testMessageSyncInterval() throws CacheException {
CacheCreation cache = new CacheCreation();
cache.setMessageSyncInterval(123);
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.NORMAL);
cache.createVMRegion("rootNORMAL", attrs);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
assertEquals(123, c.getMessageSyncInterval());
}
/**
* Tests the bridge-server attributes (<code>maximum-message-count</code> and
* <code>message-time-to-live</code>) related to HA of client-queues in gemfire cache-server
* framework
*
* @throws CacheException
*/
@Test
public void testBridgeAttributesRelatedToClientQueuesHA() throws CacheException {
CacheCreation cache = new CacheCreation();
cache.setMessageSyncInterval(3445);
CacheServer bs = cache.addCacheServer();
bs.setMaximumMessageCount(12345);
bs.setMessageTimeToLive(56789);
bs.setPort(AvailablePortHelper.getRandomAvailableTCPPort());
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.NORMAL);
cache.createVMRegion("rootNORMAL", attrs);
testXml(cache);
Cache c = getCache();
assertNotNull(c);
CacheServer server = (CacheServer) cache.getCacheServers().iterator().next();
assertNotNull(server);
assertEquals(12345, server.getMaximumMessageCount());
assertEquals(56789, server.getMessageTimeToLive());
}
/**
* Tests that a region created with a named attributes has the correct attributes.
*
* This tests currently fails due to (what seem to me as) limitations in the XML generator and the
* comparison of the XML. I have run this test by hand and looked at the generated XML and there
* were no significant problems, however because of the limitations, I am disabling this test, but
* leaving the functionality for future comparisons (by hand of course). -- Mitch Thomas
* 01/18/2006
*/
@Test
public void testPartitionedRegionInstantiation() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setLocalMaxMemory(4).setTotalNumBuckets(17).setTotalMaxMemory(8);
attrs.setPartitionAttributes(paf.create());
cache.createRegion("pRoot", attrs);
}
/**
* Tests the bridge-server attributes (<code>max-threads</code>
*
* @throws CacheException
*/
@Test
public void testBridgeMaxThreads() throws CacheException {
CacheCreation cache = new CacheCreation();
CacheServer bs = cache.addCacheServer();
bs.setMaxThreads(37);
bs.setMaxConnections(999);
bs.setPort(AvailablePortHelper.getRandomAvailableTCPPort());
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.NORMAL);
cache.createVMRegion("rootNORMAL", attrs);
testXml(cache);
}
/**
* Tests that loading cache XML with multi-cast set will set the multi-cast
*/
@Test
public void testRegionMulticastSetViaCacheXml() throws CacheException {
final String rNameBase = getUniqueName();
final String r1 = rNameBase + "1";
final String r2 = rNameBase + "2";
final String r3 = rNameBase + "3";
// Setting multi-cast via nested region attributes
CacheCreation creation = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(creation);
attrs.setScope(Scope.LOCAL);
attrs.setEarlyAck(false);
attrs.setMulticastEnabled(true);
creation.createRegion(r1, attrs);
// Setting multi-cast via named region attributes
final String attrId = "region_attrs_with_multicast";
attrs = new RegionAttributesCreation(creation);
attrs.setId(attrId);
attrs.setScope(Scope.DISTRIBUTED_NO_ACK);
attrs.setEarlyAck(false);
attrs.setMulticastEnabled(true);
creation.setRegionAttributes(attrs.getId(), attrs);
attrs = new RegionAttributesCreation(creation);
attrs.setRefid(attrId);
creation.createRegion(r3, attrs);
testXml(creation);
creation = new CacheCreation();
attrs = new RegionAttributesCreation(creation);
attrs.setScope(Scope.DISTRIBUTED_ACK);
attrs.setEarlyAck(false);
attrs.setMulticastEnabled(true);
creation.createRegion(r2, attrs);
Cache c = getCache();
assertTrue(c instanceof GemFireCacheImpl);
c.loadCacheXml(generate(creation));
{
Region reg1 = c.getRegion(r1);
assertNotNull(reg1);
assertEquals(Scope.LOCAL, reg1.getAttributes().getScope());
assertFalse(reg1.getAttributes().getEarlyAck());
assertTrue(reg1.getAttributes().getMulticastEnabled());
}
{
Region reg2 = c.getRegion(r2);
assertNotNull(reg2);
assertEquals(Scope.DISTRIBUTED_ACK, reg2.getAttributes().getScope());
assertFalse(reg2.getAttributes().getEarlyAck());
assertTrue(reg2.getAttributes().getMulticastEnabled());
}
{
Region reg3 = c.getRegion(r3);
assertNotNull(reg3);
assertEquals(Scope.DISTRIBUTED_NO_ACK, reg3.getAttributes().getScope());
assertFalse(reg3.getAttributes().getEarlyAck());
assertTrue(reg3.getAttributes().getMulticastEnabled());
}
}
@Test
public void testRollOplogs() throws CacheException {
CacheCreation cache = new CacheCreation();
// Set properties for Asynch writes
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
RegionCreation root = (RegionCreation) cache.createRegion("root", attrs);
{
attrs = new RegionAttributesCreation(cache);
DiskWriteAttributesFactory dwaf = new DiskWriteAttributesFactory();
dwaf.setSynchronous(true);
dwaf.setRollOplogs(true);
attrs.setDiskWriteAttributes(dwaf.create());
root.createSubregion("sync", attrs);
}
{
attrs = new RegionAttributesCreation(cache);
DiskWriteAttributesFactory dwaf = new DiskWriteAttributesFactory();
dwaf.setTimeInterval(123L);
dwaf.setBytesThreshold(456L);
dwaf.setRollOplogs(false);
attrs.setDiskWriteAttributes(dwaf.create());
root.createSubregion("async", attrs);
}
testXml(cache);
}
@Test
public void testMaxOplogSize() throws CacheException {
CacheCreation cache = new CacheCreation();
// Set properties for Asynch writes
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
RegionCreation root = (RegionCreation) cache.createRegion("root", attrs);
{
attrs = new RegionAttributesCreation(cache);
DiskWriteAttributesFactory dwaf = new DiskWriteAttributesFactory();
dwaf.setSynchronous(true);
dwaf.setMaxOplogSize(1);
attrs.setDiskWriteAttributes(dwaf.create());
root.createSubregion("sync", attrs);
}
{
attrs = new RegionAttributesCreation(cache);
DiskWriteAttributesFactory dwaf = new DiskWriteAttributesFactory();
dwaf.setTimeInterval(123L);
dwaf.setBytesThreshold(456L);
dwaf.setMaxOplogSize(1);
attrs.setDiskWriteAttributes(dwaf.create());
root.createSubregion("async", attrs);
}
testXml(cache);
}
@Test
public void testDataPolicy() throws CacheException {
CacheCreation cache = new CacheCreation();
{
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.NORMAL);
cache.createRegion("rootNORMAL", attrs);
}
{
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.NORMAL);
attrs.setSubscriptionAttributes(new SubscriptionAttributes(InterestPolicy.ALL));
cache.createRegion("rootNORMAL_ALL", attrs);
}
{
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setMirrorType(MirrorType.KEYS_VALUES);
cache.createRegion("rootREPLICATE", attrs);
}
{
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
cache.createRegion("rootPERSISTENT_REPLICATE", attrs);
}
{
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.EMPTY);
cache.createRegion("rootEMPTY", attrs);
}
{
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setDataPolicy(DataPolicy.EMPTY);
attrs.setSubscriptionAttributes(new SubscriptionAttributes(InterestPolicy.ALL));
cache.createRegion("rootEMPTY_ALL", attrs);
}
testXml(cache);
}
/**
* These properties, if any, will be added to the properties used for getSystem calls
*/
protected Properties xmlProps = null;
public Properties getDistributedSystemProperties() {
Properties props = super.getDistributedSystemProperties();
if (this.xmlProps != null) {
for (Iterator iter = this.xmlProps.entrySet().iterator(); iter.hasNext();) {
Map.Entry entry = (Map.Entry) iter.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
props.setProperty(key, value);
}
}
return props;
}
/**
* Test xml support of MembershipAttributes.
*/
@Test
public void testMembershipAttributes() throws Exception {
final String MY_ROLES = "Foo, Bip, BAM";
final String[][] roles = new String[][] {{"Foo"}, {"Bip", "BAM"}};
final LossAction[] policies =
(LossAction[]) LossAction.VALUES.toArray(new LossAction[LossAction.VALUES.size()]);
final ResumptionAction[] actions = (ResumptionAction[]) ResumptionAction.VALUES
.toArray(new ResumptionAction[ResumptionAction.VALUES.size()]);
CacheCreation cache = new CacheCreation();
// for each policy, try each action and each role...
for (int policy = 0; policy < policies.length; policy++) {
for (int action = 0; action < actions.length; action++) {
for (int role = 0; role < roles.length; role++) {
String[] theRoles = roles[role];
LossAction thePolicy = policies[policy];
ResumptionAction theAction = actions[action];
// if (theRoles.length == 0 && (thePolicy != LossAction.NONE || theAction !=
// ResumptionAction.NONE
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
MembershipAttributes ra = new MembershipAttributes(theRoles, thePolicy, theAction);
attrs.setMembershipAttributes(ra);
String region = "rootMEMBERSHIP_ATTRIBUTES_" + policy + "_" + action + "_" + role;
cache.createRegion(region, attrs);
}
}
}
{
// make our system play the roles used by this test so the create regions
// will not think the a required role is missing
Properties config = new Properties();
config.setProperty(ROLES, MY_ROLES);
this.xmlProps = config;
}
DistributedRegion.ignoreReconnect = true;
try {
testXml(cache);
} finally {
this.xmlProps = null;
try {
preTearDown();
} finally {
DistributedRegion.ignoreReconnect = false;
}
}
}
/**
* Tests multiple cache listeners on one region
*
* @since GemFire 5.0
*/
@Test
public void testMultipleCacheListener() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
CacheListener l1 = new MyTestCacheListener();
CacheListener l2 = new MySecondTestCacheListener();
attrs.addCacheListener(l1);
attrs.addCacheListener(l2);
cache.createRegion("root", attrs);
testXml(cache);
{
Cache c = getCache();
Region r = c.getRegion("root");
assertEquals(Arrays.asList(new CacheListener[] {l1, l2}),
Arrays.asList(r.getAttributes().getCacheListeners()));
AttributesMutator am = r.getAttributesMutator();
am.removeCacheListener(l2);
assertEquals(Arrays.asList(new CacheListener[] {l1}),
Arrays.asList(r.getAttributes().getCacheListeners()));
am.removeCacheListener(l1);
assertEquals(Arrays.asList(new CacheListener[] {}),
Arrays.asList(r.getAttributes().getCacheListeners()));
am.addCacheListener(l1);
assertEquals(Arrays.asList(new CacheListener[] {l1}),
Arrays.asList(r.getAttributes().getCacheListeners()));
am.addCacheListener(l1);
assertEquals(Arrays.asList(new CacheListener[] {l1}),
Arrays.asList(r.getAttributes().getCacheListeners()));
am.addCacheListener(l2);
assertEquals(Arrays.asList(new CacheListener[] {l1, l2}),
Arrays.asList(r.getAttributes().getCacheListeners()));
am.removeCacheListener(l1);
assertEquals(Arrays.asList(new CacheListener[] {l2}),
Arrays.asList(r.getAttributes().getCacheListeners()));
am.removeCacheListener(l1);
assertEquals(Arrays.asList(new CacheListener[] {l2}),
Arrays.asList(r.getAttributes().getCacheListeners()));
am.initCacheListeners(new CacheListener[] {l1, l2});
assertEquals(Arrays.asList(new CacheListener[] {l1, l2}),
Arrays.asList(r.getAttributes().getCacheListeners()));
}
}
/**
* A <code>CacheListener</code> that is <code>Declarable</code>, but not <code>Declarable2</code>.
*/
public static class MySecondTestCacheListener extends TestCacheListener implements Declarable {
public void init(Properties props) {}
public boolean equals(Object o) {
return o instanceof MySecondTestCacheListener;
}
}
@Test
public void testHeapLRUEviction() throws Exception {
final String name = getUniqueName();
beginCacheXml();
AttributesFactory factory = new AttributesFactory();
factory.setScope(Scope.LOCAL);
EvictionAttributes ev =
EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK);
factory.setEvictionAttributes(ev);
// RegionAttributes atts = factory.create();
createRegion(name, factory.create());
finishCacheXml(getUniqueName(), getUseSchema(), getGemFireVersion());
Region r = getRootRegion().getSubregion(name);
EvictionAttributes hlea = r.getAttributes().getEvictionAttributes();
assertEquals(EvictionAction.OVERFLOW_TO_DISK, hlea.getAction());
}
/**
* Tests multiple transaction listeners
*
* @since GemFire 5.0
*/
@Test
public void testMultipleTXListener() throws CacheException {
CacheCreation cache = new CacheCreation();
CacheTransactionManagerCreation txMgrCreation = new CacheTransactionManagerCreation();
TransactionListener l1 = new MyTestTransactionListener();
TransactionListener l2 = new MySecondTestTransactionListener();
txMgrCreation.addListener(l1);
txMgrCreation.addListener(l2);
cache.addCacheTransactionManagerCreation(txMgrCreation);
testXml(cache);
{
CacheTransactionManager tm = getCache().getCacheTransactionManager();
assertEquals(Arrays.asList(new TransactionListener[] {l1, l2}),
Arrays.asList(tm.getListeners()));
tm.removeListener(l2);
assertEquals(Arrays.asList(new TransactionListener[] {l1}), Arrays.asList(tm.getListeners()));
tm.removeListener(l1);
assertEquals(Arrays.asList(new TransactionListener[] {}), Arrays.asList(tm.getListeners()));
tm.addListener(l1);
assertEquals(Arrays.asList(new TransactionListener[] {l1}), Arrays.asList(tm.getListeners()));
tm.addListener(l1);
assertEquals(Arrays.asList(new TransactionListener[] {l1}), Arrays.asList(tm.getListeners()));
tm.addListener(l2);
assertEquals(Arrays.asList(new TransactionListener[] {l1, l2}),
Arrays.asList(tm.getListeners()));
tm.removeListener(l1);
assertEquals(Arrays.asList(new TransactionListener[] {l2}), Arrays.asList(tm.getListeners()));
tm.removeListener(l1);
assertEquals(Arrays.asList(new TransactionListener[] {l2}), Arrays.asList(tm.getListeners()));
tm.initListeners(new TransactionListener[] {l1, l2});
assertEquals(Arrays.asList(new TransactionListener[] {l1, l2}),
Arrays.asList(tm.getListeners()));
}
}
/**
* A <code>TransactionListener</code> that is <code>Declarable</code>, but not
* <code>Declarable2</code>.
*/
public static class MySecondTestTransactionListener extends TestTransactionListener
implements Declarable {
public void init(Properties props) {}
public boolean equals(Object o) {
return o instanceof MySecondTestTransactionListener;
}
}
public void setBridgeAttributes(CacheServer bridge1) {
bridge1.setPort(0);
bridge1.setMaxConnections(100);
bridge1.setMaximumTimeBetweenPings(12345);
bridge1.setNotifyBySubscription(true);
bridge1.setSocketBufferSize(98765);
}
/**
* Tests that named region attributes are registered when the cache is created.
*/
@Test
public void testRegisteringNamedRegionAttributes() {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs;
String id1 = "id1";
attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_ACK);
attrs.setMirrorType(MirrorType.KEYS);
cache.setRegionAttributes(id1, attrs);
String id2 = "id2";
attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_NO_ACK);
attrs.setMirrorType(MirrorType.KEYS_VALUES);
attrs.setConcurrencyLevel(15);
cache.setRegionAttributes(id2, attrs);
String id3 = "id3";
attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.LOCAL);
attrs.setValueConstraint(Integer.class);
cache.setRegionAttributes(id3, attrs);
testXml(cache);
}
/**
* Tests that a region created with a named attributes has the correct attributes.
*/
@Test
public void testNamedAttributes() throws CacheException {
setXmlFile(findFile("namedAttributes.xml"));
Class keyConstraint = String.class;
Class valueConstraint = Integer.class;
String id = "id1";
String regionName = "root";
Cache cache = getCache();
RegionAttributes attrs = cache.getRegionAttributes(id);
assertEquals(keyConstraint, attrs.getKeyConstraint());
assertEquals(valueConstraint, attrs.getValueConstraint());
assertEquals(45, attrs.getEntryIdleTimeout().getTimeout());
assertEquals(ExpirationAction.INVALIDATE, attrs.getEntryIdleTimeout().getAction());
Region region = cache.getRegion(regionName);
assertNotNull(region);
attrs = region.getAttributes();
assertEquals(keyConstraint, attrs.getKeyConstraint());
assertEquals(valueConstraint, attrs.getValueConstraint());
assertEquals(45, attrs.getEntryIdleTimeout().getTimeout());
assertEquals(ExpirationAction.INVALIDATE, attrs.getEntryIdleTimeout().getAction());
// Make sure that attributes can be "overridden"
Region subregion = region.getSubregion("subregion");
assertNotNull(subregion);
attrs = subregion.getAttributes();
assertEquals(keyConstraint, attrs.getKeyConstraint());
assertEquals(Long.class, attrs.getValueConstraint());
assertEquals(90, attrs.getEntryIdleTimeout().getTimeout());
assertEquals(ExpirationAction.DESTROY, attrs.getEntryIdleTimeout().getAction());
// Make sure that a named region attributes used in a region
// declaration is registered
assertNotNull(cache.getRegionAttributes("id2"));
}
/**
* Tests that trying to parse an XML file that declares a region whose attributes refer to an
* unknown named region attributes throws an {@link IllegalStateException}.
*/
@Test
public void testUnknownNamedAttributes() {
setXmlFile(findFile("unknownNamedAttributes.xml"));
IgnoredException expectedException = IgnoredException.addIgnoredException(
LocalizedStrings.RegionAttributesCreation_CANNOT_REFERENCE_NONEXISTING_REGION_ATTRIBUTES_NAMED_0
.toLocalizedString());
try {
getCache();
fail("Should have thrown an IllegalStateException");
} catch (IllegalStateException ex) {
// pass...
} finally {
expectedException.remove();
}
}
/**
* Tests to make sure that we cannot create the same region multiple times in a
* <code>cache.xml</code> file.
*/
@Test
public void testCreateSameRegionTwice() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
String name = "root";
cache.createRegion(name, attrs);
try {
cache.createRegion(name, attrs);
fail("Should have thrown a RegionExistsException");
} catch (RegionExistsException ex) {
// pass...
}
setXmlFile(findFile("sameRootRegion.xml"));
IgnoredException expectedException =
IgnoredException.addIgnoredException("While reading Cache XML file");
try {
getCache();
fail("Should have thrown a CacheXmlException");
} catch (CacheXmlException ex) {
Throwable cause = ex.getCause();
assertTrue(cause instanceof SAXException);
cause = ((SAXException) cause).getException();
if (!(cause instanceof RegionExistsException)) {
Assert.fail("Expected a RegionExistsException, not a " + cause.getClass().getName(), cause);
}
} finally {
expectedException.remove();
}
}
/**
* Tests to make sure that we cannot create the same subregion multiple times in a
* <code>cache.xml</code> file.
*/
@Test
public void testCreateSameSubregionTwice() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
String name = this.getUniqueName();
Region root = cache.createRegion("root", attrs);
root.createSubregion(name, attrs);
try {
root.createSubregion(name, attrs);
fail("Should have thrown a RegionExistsException");
} catch (RegionExistsException ex) {
// pass...
}
setXmlFile(findFile("sameSubregion.xml"));
IgnoredException expectedException =
IgnoredException.addIgnoredException("While reading Cache XML file");
try {
getCache();
fail("Should have thrown a CacheXmlException");
} catch (CacheXmlException ex) {
Throwable cause = ex.getCause();
assertTrue(cause instanceof SAXException);
cause = ((SAXException) cause).getException();
if (!(cause instanceof RegionExistsException)) {
Assert.fail("Expected a RegionExistsException, not a " + cause.getClass().getName(), cause);
}
} finally {
expectedException.remove();
}
}
/**
* Generates XML from the given <code>CacheCreation</code> and returns an <code>InputStream</code>
* for reading that XML.
*/
public InputStream generate(CacheCreation creation) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
final boolean useSchema = getUseSchema();
final String version = getGemFireVersion();
PrintWriter pw = new PrintWriter(new OutputStreamWriter(baos), true);
CacheXmlGenerator.generate(creation, pw, useSchema, version);
pw.close();
byte[] bytes = baos.toByteArray();
return new ByteArrayInputStream(bytes);
}
/**
* Tests that loading cache XML effects mutable cache attributes.
*/
@Test
public void testModifyCacheAttributes() throws CacheException {
boolean copyOnRead1 = false;
boolean isServer1 = true;
int lockLease1 = 123;
int lockTimeout1 = 345;
int searchTimeout1 = 567;
CacheCreation creation = new CacheCreation();
creation.setCopyOnRead(copyOnRead1);
creation.setIsServer(isServer1);
creation.setLockLease(lockLease1);
creation.setLockTimeout(lockTimeout1);
creation.setSearchTimeout(searchTimeout1);
testXml(creation);
Cache cache = getCache();
assertEquals(copyOnRead1, cache.getCopyOnRead());
assertEquals(isServer1, cache.isServer());
assertEquals(lockLease1, cache.getLockLease());
assertEquals(lockTimeout1, cache.getLockTimeout());
assertEquals(searchTimeout1, cache.getSearchTimeout());
boolean copyOnRead2 = true;
boolean isServer2 = false;
int lockLease2 = 234;
int lockTimeout2 = 456;
int searchTimeout2 = 678;
creation = new CacheCreation();
creation.setCopyOnRead(copyOnRead2);
creation.setIsServer(isServer2);
creation.setLockLease(lockLease2);
creation.setLockTimeout(lockTimeout2);
creation.setSearchTimeout(searchTimeout2);
cache.loadCacheXml(generate(creation));
assertEquals(copyOnRead2, cache.getCopyOnRead());
assertEquals(isServer2, cache.isServer());
assertEquals(lockLease2, cache.getLockLease());
assertEquals(lockTimeout2, cache.getLockTimeout());
assertEquals(searchTimeout2, cache.getSearchTimeout());
}
/**
* Tests that loading cache XML can create a region.
*/
@Test
public void testAddRegionViaCacheXml() throws CacheException {
CacheCreation creation = new CacheCreation();
testXml(creation);
Cache cache = getCache();
assertTrue(cache.rootRegions().isEmpty());
creation = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(creation);
attrs.setScope(Scope.GLOBAL);
attrs.setKeyConstraint(Integer.class);
attrs.setCacheListener(new MyTestCacheListener());
Region root = creation.createRegion("root", attrs);
attrs = new RegionAttributesCreation(creation);
attrs.setScope(Scope.LOCAL);
attrs.setEarlyAck(true);
attrs.setValueConstraint(String.class);
Region subregion = root.createSubregion("subregion", attrs);
cache.loadCacheXml(generate(creation));
root = cache.getRegion("root");
assertNotNull(root);
assertEquals(Scope.GLOBAL, root.getAttributes().getScope());
assertEquals(Integer.class, root.getAttributes().getKeyConstraint());
assertTrue(root.getAttributes().getCacheListener() instanceof MyTestCacheListener);
subregion = root.getSubregion("subregion");
assertNotNull(subregion);
assertEquals(Scope.LOCAL, subregion.getAttributes().getScope());
assertTrue(subregion.getAttributes().getEarlyAck());
assertFalse(subregion.getAttributes().getMulticastEnabled());
assertEquals(String.class, subregion.getAttributes().getValueConstraint());
// Create a subregion of a region that already exists
creation = new CacheCreation();
attrs = new RegionAttributesCreation(creation);
root = creation.createRegion("root", attrs);
attrs = new RegionAttributesCreation(creation);
attrs.setScope(Scope.DISTRIBUTED_ACK);
attrs.setEarlyAck(false);
attrs.setValueConstraint(Long.class);
Region subregion2 = root.createSubregion("subregion2", attrs);
cache.loadCacheXml(generate(creation));
subregion2 = root.getSubregion("subregion2");
assertNotNull(subregion2);
assertEquals(Scope.DISTRIBUTED_ACK, subregion2.getAttributes().getScope());
assertTrue(!subregion2.getAttributes().getEarlyAck());
assertEquals(Long.class, subregion2.getAttributes().getValueConstraint());
}
/**
* Tests that loading cache XML can modify a region.
*/
@Test
public void testModifyRegionViaCacheXml() throws CacheException {
CacheCreation creation = new CacheCreation();
int timeout1a = 123;
ExpirationAction action1a = ExpirationAction.LOCAL_DESTROY;
int timeout1b = 456;
ExpirationAction action1b = ExpirationAction.DESTROY;
RegionAttributesCreation attrs = new RegionAttributesCreation(creation);
attrs.setStatisticsEnabled(true);
attrs.setEntryIdleTimeout(new ExpirationAttributes(timeout1a, action1a));
Region root = creation.createRegion("root", attrs);
attrs = new RegionAttributesCreation(creation);
attrs.setStatisticsEnabled(true);
attrs.setEntryIdleTimeout(new ExpirationAttributes(timeout1b, action1b));
Region subregion = root.createSubregion("subregion", attrs);
testXml(creation);
Cache cache = getCache();
root = cache.getRegion("root");
assertEquals(timeout1a, root.getAttributes().getEntryIdleTimeout().getTimeout());
assertEquals(action1a, root.getAttributes().getEntryIdleTimeout().getAction());
subregion = root.getSubregion("subregion");
assertEquals(timeout1b, subregion.getAttributes().getEntryIdleTimeout().getTimeout());
assertEquals(action1b, subregion.getAttributes().getEntryIdleTimeout().getAction());
creation = new CacheCreation();
int timeout2a = 234;
ExpirationAction action2a = ExpirationAction.LOCAL_INVALIDATE;
int timeout2b = 567;
ExpirationAction action2b = ExpirationAction.INVALIDATE;
attrs = new RegionAttributesCreation(creation);
attrs.setStatisticsEnabled(true);
attrs.setEntryIdleTimeout(new ExpirationAttributes(timeout2a, action2a));
attrs.setCacheListener(new MyTestCacheListener());
root = creation.createRegion("root", attrs);
attrs = new RegionAttributesCreation(creation);
attrs.setStatisticsEnabled(true);
attrs.setEntryIdleTimeout(new ExpirationAttributes(timeout2b, action2b));
subregion = root.createSubregion("subregion", attrs);
cache.loadCacheXml(generate(creation));
root = cache.getRegion("root");
subregion = root.getSubregion("subregion");
assertEquals(timeout2a, root.getAttributes().getEntryIdleTimeout().getTimeout());
assertEquals(action2a, root.getAttributes().getEntryIdleTimeout().getAction());
assertTrue(root.getAttributes().getCacheListener() instanceof MyTestCacheListener);
assertEquals(timeout2b, subregion.getAttributes().getEntryIdleTimeout().getTimeout());
assertEquals(action2b, subregion.getAttributes().getEntryIdleTimeout().getAction());
}
/**
* Tests that loading cache XML can add/update entries to a region.
*/
@Test
public void testAddEntriesViaCacheXml() throws CacheException {
String key1 = "KEY1";
String value1 = "VALUE1";
CacheCreation creation = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(creation);
attrs.setScope(Scope.LOCAL);
Region root = creation.createRegion("root", attrs);
root.put(key1, value1);
testXml(creation);
Cache cache = getCache();
root = cache.getRegion("root");
assertEquals(1, root.entries(false).size());
assertEquals(value1, root.get(key1));
creation = new CacheCreation();
attrs = new RegionAttributesCreation(creation);
attrs.setScope(Scope.LOCAL);
String value2 = "VALUE2";
String key2 = "KEY2";
String value3 = "VALUE3";
root = creation.createRegion("root", attrs);
root.put(key1, value2);
root.put(key2, value3);
cache.loadCacheXml(generate(creation));
root = cache.getRegion("root");
assertEquals(2, root.entries(false).size());
assertEquals(value2, root.get(key1));
assertEquals(value3, root.get(key2));
}
// this tests an aspect of the CapacityController interface, which is no longer
// available as of 5.0
// public void testHeapLRUCapacityController() throws Exception {
// final String name = getUniqueName();
// beginCacheXml();
// AttributesFactory factory = new AttributesFactory();
// factory.setScope(Scope.LOCAL);
// factory.setCapacityController(new HeapLRUCapacityController(42, 32,
// LRUAlgorithm.OVERFLOW_TO_DISK));
// createRegion(name, factory.create());
// finishCacheXml(getUniqueName());
//
// Region r = getRootRegion().getSubregion(name);
//
// HeapLRUCapacityController hlcc = (HeapLRUCapacityController)
// r.getAttributes().getCapacityController();
// assertIndexDetailsEquals(hlcc.getEvictionAction(), LRUAlgorithm.OVERFLOW_TO_DISK);
//
// Properties p = hlcc.getProperties();
// assertIndexDetailsEquals(42,
// Integer.parseInt(p.getProperty(HeapLRUCapacityController.HEAP_PERCENTAGE)));
// assertIndexDetailsEquals(32,
// Long.parseLong(p.getProperty(HeapLRUCapacityController.EVICTOR_INTERVAL)));
// assertIndexDetailsEquals(LRUAlgorithm.OVERFLOW_TO_DISK,
// p.getProperty(HeapLRUCapacityController.EVICTION_ACTION));
// }
/**
* Test Publisher region attribute
*
* @since GemFire 4.2.3
* @deprecated as of GemFire 6.5.
*/
@Test
public void testPublisherAttribute() throws CacheException {
// CacheCreation cache = new CacheCreation();
// RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
// attrs.setPublisher(true);
// cache.createRegion("root", attrs);
// testXml(cache);
// assertIndexDetailsEquals(true, cache.getRegion("root").getAttributes().getPublisher());
}
/**
* Test EnableBridgeConflation region attribute
*
* @since GemFire 4.2
*/
@Test
public void testEnableBridgeConflationAttribute() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setEnableBridgeConflation(true);
cache.createRegion("root", attrs);
testXml(cache);
assertEquals(true, cache.getRegion("root").getAttributes().getEnableBridgeConflation());
}
/**
* Test EnableAsyncConflation region attribute
*
* @since GemFire 4.2
*/
@Test
public void testEnableAsyncConflationAttribute() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setEnableAsyncConflation(true);
cache.createRegion("root", attrs);
testXml(cache);
assertEquals(true, cache.getRegion("root").getAttributes().getEnableAsyncConflation());
}
/**
* @since GemFire 4.3
*/
@Test
public void testDynamicRegionFactoryDefault() throws CacheException {
CacheCreation cache = new CacheCreation();
cache.setDynamicRegionFactoryConfig(new DynamicRegionFactory.Config());
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
cache.createRegion("root", attrs);
// note that testXml can't check if they are same because enabling
// dynamic regions causes a meta region to be produced.
testXml(cache, false);
assertEquals(true, DynamicRegionFactory.get().getConfig().getRegisterInterest());
assertEquals(true, DynamicRegionFactory.get().getConfig().getPersistBackup());
assertEquals(true, DynamicRegionFactory.get().isOpen());
assertEquals(null, DynamicRegionFactory.get().getConfig().getDiskDir());
Region dr = getCache().getRegion("__DynamicRegions");
if (dr != null) {
dr.localDestroyRegion();
}
}
@Test
public void testDynamicRegionFactoryNonDefault() throws CacheException {
CacheCreation cache = new CacheCreation();
cache.setDynamicRegionFactoryConfig(
new DynamicRegionFactory.Config((File) null, null, false, false));
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
cache.createRegion("root", attrs);
// note that testXml can't check if they are same because enabling
// dynamic regions causes a meta region to be produced.
testXml(cache, false);
assertEquals(false, DynamicRegionFactory.get().getConfig().getRegisterInterest());
assertEquals(false, DynamicRegionFactory.get().getConfig().getPersistBackup());
assertEquals(true, DynamicRegionFactory.get().isOpen());
assertEquals(null, DynamicRegionFactory.get().getConfig().getDiskDir());
Region dr = getCache().getRegion("__DynamicRegions");
if (dr != null) {
dr.localDestroyRegion();
}
}
/**
* @since GemFire 4.3
*/
@Test
public void testDynamicRegionFactoryDiskDir() throws CacheException {
CacheCreation cache = new CacheCreation();
File f = new File("diskDir");
f.mkdirs();
cache.setDynamicRegionFactoryConfig(new DynamicRegionFactory.Config(f, null, true, true));
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
cache.createRegion("root", attrs);
// note that testXml can't check if they are same because enabling
// dynamic regions causes a meta region to be produced.
testXml(cache, false);
assertEquals(true, DynamicRegionFactory.get().isOpen());
assertEquals(f.getAbsoluteFile(), DynamicRegionFactory.get().getConfig().getDiskDir());
Region dr = getCache().getRegion("__DynamicRegions");
if (dr != null) {
dr.localDestroyRegion();
}
}
/**
* Tests the cache server attribute
*
* @since GemFire 4.0
*/
@Test
public void testServer() {
CacheCreation cache = new CacheCreation();
cache.setIsServer(true);
assertTrue(cache.isServer());
testXml(cache);
}
/**
* Tests declarative bridge servers
*
* @since GemFire 4.0
*/
@Test
public void testBridgeServers() {
CacheCreation cache = new CacheCreation();
CacheServer bridge1 = cache.addCacheServer();
setBridgeAttributes(bridge1);
CacheServer bridge2 = cache.addCacheServer();
setBridgeAttributes(bridge2);
testXml(cache);
}
/**
* Tests the is-lock-grantor attribute in xml.
*/
@Test
public void testIsLockGrantorAttribute() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setLockGrantor(true);
attrs.setScope(Scope.GLOBAL);
attrs.setMirrorType(MirrorType.KEYS_VALUES);
cache.createRegion("root", attrs);
testXml(cache);
assertEquals(true, cache.getRegion("root").getAttributes().isLockGrantor());
}
/**
* Tests a cache listener with no parameters
*
* @since GemFire 4.0
*/
@Test
public void testTransactionListener() {
CacheCreation cache = new CacheCreation();
CacheTransactionManagerCreation txMgrCreation = new CacheTransactionManagerCreation();
txMgrCreation.setListener(new MyTestTransactionListener());
cache.addCacheTransactionManagerCreation(txMgrCreation);
testXml(cache);
}
/**
* Tests transaction manager with no listener
*
* @since GemFire 4.0
*/
@Test
public void testCacheTransactionManager() {
CacheCreation cache = new CacheCreation();
CacheTransactionManagerCreation txMgrCreation = new CacheTransactionManagerCreation();
cache.addCacheTransactionManagerCreation(txMgrCreation);
testXml(cache);
}
/**
* Tests the value constraints region attribute that was added in GemFire 4.0.
*
* @since GemFire 4.1
*/
@Test
public void testConstrainedValues() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setValueConstraint(String.class);
cache.createRegion("root", attrs);
testXml(cache);
}
/**
* Tests creating a cache with a non-existent XML file
*/
@Test
public void testNonExistentFile() throws IOException {
// System.out.println("testNonExistentFile - start: " + System.currentTimeMillis());
File nonExistent = new File(this.getName() + ".xml");
nonExistent.delete();
// System.out.println("testNonExistentFile - deleted: " + System.currentTimeMillis());
setXmlFile(nonExistent);
// System.out.println("testNonExistentFile - set: " + System.currentTimeMillis());
IgnoredException expectedException = IgnoredException.addIgnoredException(
LocalizedStrings.GemFireCache_DECLARATIVE_CACHE_XML_FILERESOURCE_0_DOES_NOT_EXIST
.toLocalizedString(nonExistent.getPath()));
try {
getCache();
fail("Should have thrown a CacheXmlException");
} catch (CacheXmlException ex) {
// System.out.println("testNonExistentFile - caught: " + System.currentTimeMillis());
// pass...
} finally {
expectedException.remove();
}
}
/**
* Tests creating a cache with a XML file that is a directory
*/
@Test
public void testXmlFileIsDirectory() {
File dir = new File(this.getName() + "dir");
dir.mkdirs();
dir.deleteOnExit();
setXmlFile(dir);
IgnoredException expectedException = IgnoredException.addIgnoredException(
LocalizedStrings.GemFireCache_DECLARATIVE_XML_FILE_0_IS_NOT_A_FILE.toLocalizedString(dir));
try {
getCache();
fail("Should have thrown a CacheXmlException");
} catch (CacheXmlException ex) {
// pass...
} finally {
expectedException.remove();
}
}
/**
* Tests creating a cache with the default lock-timeout, lock-lease, and search-timeout.
*/
@Test
public void testDefaultCache() {
CacheCreation cache = new CacheCreation();
testXml(cache);
}
/**
* Tests creating a cache with non-default lock-timeout, lock-lease, and search-timeout.
*/
@Test
public void testNonDefaultCache() {
CacheCreation cache = new CacheCreation();
cache.setLockTimeout(42);
cache.setLockLease(43);
cache.setSearchTimeout(44);
if (getGemFireVersion().compareTo(CacheXml.VERSION_4_0) >= 0) {
cache.setCopyOnRead(true);
}
testXml(cache);
}
/**
* Tests creating a cache with entries defined in the root region
*/
@Test
public void testEntriesInRootRegion() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionCreation root =
(RegionCreation) cache.createRegion("root", new RegionAttributesCreation(cache));
root.put("KEY1", "VALUE1");
root.put("KEY2", "VALUE2");
root.put("KEY3", "VALUE3");
testXml(cache);
}
/**
* Tests creating a cache whose keys are constrained
*/
@Test
public void testConstrainedKeys() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setKeyConstraint(String.class);
cache.createRegion("root", attrs);
testXml(cache);
}
/**
* Tests creating a cache with a various {@link ExpirationAttributes}.
*/
@Test
public void testExpirationAttriubutes() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setStatisticsEnabled(true);
{
ExpirationAttributes expire = new ExpirationAttributes(42, ExpirationAction.INVALIDATE);
attrs.setRegionTimeToLive(expire);
}
{
ExpirationAttributes expire = new ExpirationAttributes(43, ExpirationAction.DESTROY);
attrs.setRegionIdleTimeout(expire);
}
{
ExpirationAttributes expire = new ExpirationAttributes(44, ExpirationAction.LOCAL_INVALIDATE);
attrs.setEntryTimeToLive(expire);
}
{
ExpirationAttributes expire = new ExpirationAttributes(45, ExpirationAction.LOCAL_DESTROY);
attrs.setEntryIdleTimeout(expire);
}
cache.createRegion("root", attrs);
testXml(cache);
}
/**
* Tests a cache loader an interesting combination of declarables
*/
@Test
public void testCacheLoaderWithDeclarables() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
CacheLoaderWithDeclarables loader = new CacheLoaderWithDeclarables();
attrs.setCacheLoader(loader);
cache.createRegion("root", attrs);
testXml(cache);
}
/**
* Tests a cache writer with no parameters
*/
@Test
public void testCacheWriter() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
CacheWriter writer = new MyTestCacheWriter();
attrs.setCacheWriter(writer);
cache.createRegion("root", attrs);
testXml(cache);
}
/**
* Tests a cache listener with no parameters
*/
@Test
public void testCacheListener() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
CacheListener listener = new MyTestCacheListener();
attrs.setCacheListener(listener);
cache.createRegion("root", attrs);
testXml(cache);
}
/**
* Tests a region with non-default region attributes
*/
@Test
public void testNonDefaultRegionAttributes() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_NO_ACK);
attrs.setMirrorType(MirrorType.KEYS_VALUES);
attrs.setInitialCapacity(142);
attrs.setLoadFactor(42.42f);
attrs.setStatisticsEnabled(false);
cache.createRegion("root", attrs);
testXml(cache);
}
/**
* Tests parsing a malformed XML file
*/
@Test
public void testMalformed() {
setXmlFile(findFile("malformed.xml"));
IgnoredException expectedException =
IgnoredException.addIgnoredException("While reading Cache XML file");
try {
getCache();
fail("Should have thrown a CacheXmlException");
} catch (CacheXmlException ex) {
assertTrue(ex.getCause() instanceof SAXException);
} finally {
expectedException.remove();
}
}
/**
* Tests parsing an XML file with a bad integer
*/
@Test
public void testBadInt() {
setXmlFile(findFile("badInt.xml"));
IgnoredException expectedException =
IgnoredException.addIgnoredException("While reading Cache XML file");
try {
getCache();
fail("Should have thrown a CacheXmlException");
} catch (CacheXmlException ex) {
Throwable cause = ex.getCause();
assertNotNull("Expected a cause", cause);
assertTrue("Didn't expect cause:" + cause + " (a " + cause.getClass().getName() + ")",
cause instanceof NumberFormatException);
} finally {
expectedException.remove();
}
}
/**
* Tests parsing an XML file with a bad float
*/
@Test
public void testBadFloat() {
setXmlFile(findFile("badFloat.xml"));
IgnoredException expectedException =
IgnoredException.addIgnoredException("While reading Cache XML file");
try {
getCache();
fail("Should have thrown a CacheXmlException");
} catch (CacheXmlException ex) {
assertTrue(ex.getCause() instanceof NumberFormatException);
} finally {
expectedException.remove();
}
}
/**
* Tests parsing an XML file with a bad scope. This error should be caught by the XML parser.
*/
@Test
public void testBadScope() {
setXmlFile(findFile("badScope.xml"));
IgnoredException expectedException =
IgnoredException.addIgnoredException("While reading Cache XML file");
try {
getCache();
fail("Should have thrown a CacheXmlException");
} catch (CacheXmlException ex) {
assertTrue(ex.getCause() instanceof SAXException);
} finally {
expectedException.remove();
}
}
/**
* Tests parsing an XML file with a non-existent key constraint class.
*/
@Test
public void testBadKeyConstraintClass() {
setXmlFile(findFile("badKeyConstraintClass.xml"));
IgnoredException expectedException =
IgnoredException.addIgnoredException("While reading Cache XML file");
try {
getCache();
fail("Should have thrown a CacheXmlException");
} catch (CacheXmlException ex) {
assertTrue(ex.getCause() instanceof ClassNotFoundException);
} finally {
expectedException.remove();
}
}
/**
* Tests parsing an XML file that specifies a cache listener that is not {@link Declarable}.
*/
@Test
public void testCallbackNotDeclarable() {
setXmlFile(findFile("callbackNotDeclarable.xml"));
IgnoredException expectedException =
IgnoredException.addIgnoredException("While reading Cache XML file");
try {
getCache();
fail("Should have thrown a CacheXmlException");
} catch (CacheXmlException ex) {
Throwable cause = ex.getCause();
assertNull(/*
* "Didn't expect a cause of " + cause + " (a " + cause.getClass().getName() + ")"
* + " from " + ex,
*/
cause);
} finally {
expectedException.remove();
}
}
/**
* Tests parsing an XML file that specifies a cache listener whose constructor throws an
* {@linkplain AssertionError exception}.
*/
@Test
public void testCallbackWithException() {
setXmlFile(findFile("callbackWithException.xml"));
IgnoredException expectedException =
IgnoredException.addIgnoredException("While reading Cache XML file");
try {
getCache();
fail("Should have thrown a CacheXmlException");
} catch (CacheXmlException ex) {
if (!(ex.getCause() instanceof AssertionError)) {
throw ex;
}
} finally {
expectedException.remove();
}
}
/**
* Tests parsing an XML file that specifies a cache listener that is not a
* <code>CacheLoader</code>.
*/
@Test
public void testLoaderNotLoader() {
setXmlFile(findFile("loaderNotLoader.xml"));
IgnoredException expectedException =
IgnoredException.addIgnoredException("While reading Cache XML file");
try {
getCache();
fail("Should have thrown a CacheXmlException");
} catch (CacheXmlException ex) {
Throwable cause = ex.getCause();
assertNull("Didn't expect a " + cause, cause);
} finally {
expectedException.remove();
}
}
/**
* Tests nested regions
*/
@Test
public void testNestedRegions() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_NO_ACK);
RegionCreation root = (RegionCreation) cache.createRegion("root", attrs);
{
attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_NO_ACK);
attrs.setMirrorType(MirrorType.KEYS_VALUES);
attrs.setInitialCapacity(142);
attrs.setLoadFactor(42.42f);
attrs.setStatisticsEnabled(false);
root.createSubregion("one", attrs);
}
{
attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.DISTRIBUTED_ACK);
attrs.setMirrorType(MirrorType.KEYS);
attrs.setInitialCapacity(242);
Region region = root.createSubregion("two", attrs);
{
attrs = new RegionAttributesCreation(cache);
attrs.setScope(Scope.GLOBAL);
attrs.setLoadFactor(43.43f);
region.createSubregion("three", attrs);
}
}
testXml(cache);
}
/**
* Tests whether or not XML attributes can appear in any order. See bug 30050.
*/
@Test
public void testAttributesUnordered() {
setXmlFile(findFile("attributesUnordered.xml"));
getCache();
}
/**
* Tests disk directories
*/
@Test
public void testDiskDirs() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
File[] dirs = new File[] {new File(this.getUniqueName() + "-dir1"),
new File(this.getUniqueName() + "-dir2")};
for (int i = 0; i < dirs.length; i++) {
dirs[i].mkdirs();
dirs[i].deleteOnExit();
}
int[] diskSizes = {DiskWriteAttributesImpl.DEFAULT_DISK_DIR_SIZE,
DiskWriteAttributesImpl.DEFAULT_DISK_DIR_SIZE};
attrs.setDiskDirsAndSize(dirs, diskSizes);
cache.createRegion("root", attrs);
testXml(cache);
}
/**
* Tests the <code>overflowThreshold</code> and <code>persistBackup</code> related attributes
*/
@Test
public void testOverflowAndBackup() throws CacheException {
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setMirrorType(MirrorType.KEYS_VALUES);
attrs.setPersistBackup(true);
cache.createRegion("root", attrs);
testXml(cache);
}
/**
* Tests <code>DiskWriteAttributes</code>
*/
@Test
public void testDiskWriteAttributes() throws CacheException {
CacheCreation cache = new CacheCreation();
// Set properties for Asynch writes
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
RegionCreation root = (RegionCreation) cache.createRegion("root", attrs);
{
attrs = new RegionAttributesCreation(cache);
DiskWriteAttributesFactory dwaf = new DiskWriteAttributesFactory();
dwaf.setSynchronous(true);
attrs.setDiskWriteAttributes(dwaf.create());
root.createSubregion("sync", attrs);
}
{
attrs = new RegionAttributesCreation(cache);
DiskWriteAttributesFactory dwaf = new DiskWriteAttributesFactory();
dwaf.setTimeInterval(123L);
dwaf.setBytesThreshold(456L);
attrs.setDiskWriteAttributes(dwaf.create());
root.createSubregion("async", attrs);
}
testXml(cache);
}
/**
* Tests to make sure that the example cache.xml file in the API documentation conforms to the
* DTD.
*
* @since GemFire 3.2.1
*/
@Test
@Ignore
public void testExampleCacheXmlFile() throws Exception {
// Check for old example files
String dirName = "examples_" + this.getGemFireVersion();
File dir = null;
try {
dir = findFile(dirName);
} catch (AssertionError e) {
// ignore, no directory.
}
if (dir != null && dir.exists()) {
File[] xmlFiles = dir.listFiles(new FilenameFilter() {
public boolean accept(File dir, String name) {
return name.endsWith(".xml");
}
});
assertTrue("No XML files in " + dirName, xmlFiles.length > 0);
for (int i = 0; i < xmlFiles.length; i++) {
File xmlFile = xmlFiles[i];
LogWriterUtils.getLogWriter().info("Parsing " + xmlFile);
FileInputStream fis = new FileInputStream(xmlFile);
CacheXmlParser.parse(fis);
}
} else {
File example = new File(TestUtil.getResourcePath(getClass(),
"/org/apache/geode/cache/doc-files/example-cache.xml"));
FileInputStream fis = new FileInputStream(example);
CacheXmlParser.parse(fis);
File example2 = new File(TestUtil.getResourcePath(getClass(),
"/org/apache/geode/cache/doc-files/example2-cache.xml"));
fis = new FileInputStream(example2);
CacheXmlParser.parse(fis);
File example3 = new File(TestUtil.getResourcePath(getClass(),
"/org/apache/geode/cache/doc-files/example3-cache.xml"));
fis = new FileInputStream(example3);
CacheXmlParser.parse(fis);
}
}
@Test
public void testEvictionLRUEntryAttributes() throws Exception {
final String rName = getUniqueName();
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setEvictionAttributes(
EvictionAttributes.createLRUEntryAttributes(80, EvictionAction.LOCAL_DESTROY));
cache.createRegion(rName, attrs);
testXml(cache);
}
public static class EvictionObjectSizer implements ObjectSizer, Declarable2 {
Properties props = new Properties();
public int sizeof(Object o) {
return 1;
}
public Properties getConfig() {
if (null == this.props) {
this.props = new Properties();
}
this.props.setProperty("EvictionObjectSizerColor", "blue");
return this.props;
}
public void init(Properties props) {
this.props = props;
}
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof EvictionObjectSizer)) {
return false;
}
EvictionObjectSizer other = (EvictionObjectSizer) obj;
if (!this.props.equals(other.props)) {
return false;
}
return true;
}
}
@Test
public void testEvictionLRUMemoryAttributes() throws Exception {
final String rName = getUniqueName();
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setEvictionAttributes(
EvictionAttributes.createLRUMemoryAttributes(10, new EvictionObjectSizer()));
cache.createRegion(rName, attrs);
testXml(cache);
}
@Test
public void testEvictionLRUHeapAttributes() throws Exception {
final String rName = getUniqueName();
CacheCreation cache = new CacheCreation();
RegionAttributesCreation attrs = new RegionAttributesCreation(cache);
attrs.setEvictionAttributes(EvictionAttributes
.createLRUHeapAttributes(new EvictionObjectSizer(), EvictionAction.LOCAL_DESTROY));
cache.createRegion(rName, attrs);
testXml(cache);
}
//////////////////////// Inner Classes ////////////////////////
/**
* A cache listener that is not {@link Declarable}
*
* @see #testCallbackNotDeclarable()
*/
public static class NotDeclarableCacheListener extends TestCacheListener {
}
public static class AssertionError extends RuntimeException {
public AssertionError() {
super("Test Exception");
}
}
/**
* A cache listener whose constructor throws an exception
*
* @see #testCallbackWithException()
*/
public static class ExceptionalCacheListener extends TestCacheListener {
public ExceptionalCacheListener() {
throw new AssertionError();
}
}
/**
* A <code>CacheListener</code> that is <code>Declarable</code>, but not <code>Declarable2</code>.
*/
public static class MyTestCacheListener extends TestCacheListener implements Declarable {
public void init(Properties props) {}
public boolean equals(Object o) {
return o instanceof MyTestCacheListener;
}
}
/**
* A <code>CacheWriter</code> that is <code>Declarable</code>, but not <code>Declarable2</code>.
*/
public static class MyTestCacheWriter extends TestCacheWriter implements Declarable {
public void init(Properties props) {}
public boolean equals(Object o) {
return o instanceof MyTestCacheWriter;
}
}
/**
* A <code>TransactionListener</code> that is <code>Declarable</code>, but not
* <code>Declarable2</code>.
*/
public static class MyTestTransactionListener extends TestTransactionListener
implements Declarable {
public void init(Properties props) {}
public boolean equals(Object o) {
return o instanceof MyTestTransactionListener;
}
}
/**
* A <code>CacheLoader</code> that is <code>Declarable</code> and has some interesting parameters.
*/
public static class CacheLoaderWithDeclarables implements CacheLoader, Declarable2 {
/** This loader's properties */
private Properties props;
/** Was this declarable initialized */
private boolean initialized = false;
/**
* Creates a new loader and initializes its properties
*/
public CacheLoaderWithDeclarables() {
this.props = new Properties();
props.put("KEY1", "VALUE1");
props.put("KEY2", new TestDeclarable());
}
/**
* Returns whether or not this <code>Declarable</code> was initialized.
*/
public boolean isInitialized() {
return this.initialized;
}
public void init(Properties props) {
this.initialized = true;
assertEquals(this.props, props);
}
public Properties getConfig() {
return this.props;
}
public Object load(LoaderHelper helper) throws CacheLoaderException {
fail("Loader shouldn't be invoked");
return null;
}
public boolean equals(Object o) {
if (o instanceof CacheLoaderWithDeclarables) {
CacheLoaderWithDeclarables other = (CacheLoaderWithDeclarables) o;
return this.props.equals(other.props);
} else {
return false;
}
}
public void close() {}
}
public static class TestDeclarable implements Declarable {
public void init(Properties props) {}
public boolean equals(Object o) {
return o instanceof TestDeclarable;
}
}
}