use of org.apache.geode.test.dunit.SerializableCallableIF in project geode by apache.
the class ClientServerInvalidAndDestroyedEntryDUnitTest method doTestClientGetsInvalidEntry.
/**
* Bug #43407 - when a client does a get(k) and the entry is invalid in the server we want the
* client to end up with an entry that is invalid.
*/
private void doTestClientGetsInvalidEntry(final String regionName, final boolean usePR, boolean useTX) throws Exception {
VM vm1 = Host.getHost(0).getVM(1);
VM vm2 = Host.getHost(0).getVM(2);
// here are the keys that will be used to validate behavior. Keys must be
// colocated if using both a partitioned region in the server and transactions
// in the client. All of these keys hash to bucket 0 in a two-bucket PR
// except Object11 and IDoNotExist1
final String notAffectedKey = "Object1";
final String nonexistantKey = (usePR && useTX) ? "IDoNotExist2" : "IDoNotExist1";
final String key1 = "Object10";
final String key2 = (usePR && useTX) ? "Object12" : "Object11";
SerializableCallableIF createServer = getCreateServerCallable(regionName, usePR);
int serverPort = (Integer) vm1.invoke(createServer);
vm2.invoke(createServer);
vm1.invoke(new SerializableRunnable("populate server and create invalid entry") {
public void run() {
Region myRegion = getCache().getRegion(regionName);
for (int i = 1; i <= 20; i++) {
myRegion.put("Object" + i, "Value" + i);
}
myRegion.invalidate(key1);
myRegion.invalidate(key2);
}
});
org.apache.geode.test.dunit.LogWriterUtils.getLogWriter().info("creating client cache");
ClientCache c = new ClientCacheFactory().addPoolServer("localhost", serverPort).set(LOG_LEVEL, LogWriterUtils.getDUnitLogLevel()).create();
Region myRegion = c.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create(regionName);
;
if (useTX) {
c.getCacheTransactionManager().begin();
}
// get of a valid entry should work
assertNotNull(myRegion.get(notAffectedKey));
// get of an invalid entry should return null and create the entry in an invalid state
org.apache.geode.test.dunit.LogWriterUtils.getLogWriter().info("getting " + key1 + " - should reach this cache and be INVALID");
assertNull(myRegion.get(key1));
assertTrue(myRegion.containsKey(key1));
// since this might be a PR we also check the next key to force PR Get messaging
assertNull(myRegion.get(key2));
assertTrue(myRegion.containsKey(key2));
// now try a key that doesn't exist anywhere
assertNull(myRegion.get(nonexistantKey));
assertFalse(myRegion.containsKey(nonexistantKey));
if (useTX) {
c.getCacheTransactionManager().commit();
// test that the commit correctly created the entries in the region
assertNotNull(myRegion.get(notAffectedKey));
assertNull(myRegion.get(key1));
assertTrue(myRegion.containsKey(key1));
assertNull(myRegion.get(key2));
assertTrue(myRegion.containsKey(key2));
}
myRegion.localDestroy(notAffectedKey);
myRegion.localDestroy(key1);
myRegion.localDestroy(key2);
if (useTX) {
c.getCacheTransactionManager().begin();
}
// check that getAll returns invalidated entries
List keys = new LinkedList();
keys.add(notAffectedKey);
keys.add(key1);
keys.add(key2);
Map result = myRegion.getAll(keys);
assertNotNull(result.get(notAffectedKey));
assertNull(result.get(key1));
assertNull(result.get(key2));
assertTrue(result.containsKey(key1));
assertTrue(result.containsKey(key2));
assertTrue(myRegion.containsKey(key1));
assertTrue(myRegion.containsKey(key2));
if (useTX) {
c.getCacheTransactionManager().commit();
// test that the commit correctly created the entries in the region
assertNotNull(myRegion.get(notAffectedKey));
assertNull(myRegion.get(key1));
assertTrue(myRegion.containsKey(key1));
assertNull(myRegion.get(key2));
assertTrue(myRegion.containsKey(key2));
}
// test that a listener is not invoked when there is already an invalidated
// entry in the client cache
UpdateListener listener = new UpdateListener();
listener.log = org.apache.geode.test.dunit.LogWriterUtils.getLogWriter();
myRegion.getAttributesMutator().addCacheListener(listener);
myRegion.get(key1);
assertEquals("expected no cache listener invocations", 0, listener.updateCount, listener.updateCount);
myRegion.localDestroy(notAffectedKey);
myRegion.getAll(keys);
assertTrue("expected to find " + notAffectedKey, myRegion.containsKey(notAffectedKey));
assertEquals("expected only one listener invocation for " + notAffectedKey, 1, listener.updateCount);
}
use of org.apache.geode.test.dunit.SerializableCallableIF in project geode by apache.
the class ClientServerInvalidAndDestroyedEntryDUnitTest method doTestClientGetsTombstone.
/**
* Similar to bug #43407 but not reported in a ticket, we want a client that does a get() on a
* destroyed entry to end up with a tombstone for that entry. This was already the case but there
* were no unit tests covering this for different server configurations and with/without
* transactions.
*/
private void doTestClientGetsTombstone(final String regionName, final boolean usePR, boolean useTX) throws Exception {
VM vm1 = Host.getHost(0).getVM(1);
VM vm2 = Host.getHost(0).getVM(2);
// here are the keys that will be used to validate behavior. Keys must be
// colocated if using both a partitioned region in the server and transactions
// in the client. All of these keys hash to bucket 0 in a two-bucket PR
// except Object11 and IDoNotExist1
final String notAffectedKey = "Object1";
final String nonexistantKey = (usePR && useTX) ? "IDoNotExist2" : "IDoNotExist1";
final String key1 = "Object10";
final String key2 = (usePR && useTX) ? "Object12" : "Object11";
SerializableCallableIF createServer = getCreateServerCallable(regionName, usePR);
int serverPort = (Integer) vm1.invoke(createServer);
vm2.invoke(createServer);
vm1.invoke(new SerializableRunnable("populate server and create invalid entry") {
public void run() {
Region myRegion = getCache().getRegion(regionName);
for (int i = 1; i <= 20; i++) {
myRegion.put("Object" + i, "Value" + i);
}
myRegion.destroy(key1);
myRegion.destroy(key2);
}
});
org.apache.geode.test.dunit.LogWriterUtils.getLogWriter().info("creating client cache");
ClientCache c = new ClientCacheFactory().addPoolServer("localhost", serverPort).set(LOG_LEVEL, LogWriterUtils.getDUnitLogLevel()).create();
Region myRegion = c.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create(regionName);
;
if (useTX) {
c.getCacheTransactionManager().begin();
}
// get of a valid entry should work
assertNotNull(myRegion.get(notAffectedKey));
// get of an invalid entry should return null and create the entry in an invalid state
org.apache.geode.test.dunit.LogWriterUtils.getLogWriter().info("getting " + key1 + " - should reach this cache and be a TOMBSTONE");
assertNull(myRegion.get(key1));
assertFalse(myRegion.containsKey(key1));
RegionEntry entry;
if (!useTX) {
entry = ((LocalRegion) myRegion).getRegionEntry(key1);
// it should be there
assertNotNull(entry);
// it should be a destroyed entry with Token.TOMBSTONE
assertTrue(entry.isTombstone());
}
// since this might be a PR we also check the next key to force PR Get messaging
assertNull(myRegion.get(key2));
assertFalse(myRegion.containsKey(key2));
if (!useTX) {
entry = ((LocalRegion) myRegion).getRegionEntry(key2);
// it should be there
assertNotNull(entry);
// it should be a destroyed entry with Token.TOMBSTONE
assertTrue(entry.isTombstone());
}
// now try a key that doesn't exist anywhere
assertNull(myRegion.get(nonexistantKey));
assertFalse(myRegion.containsKey(nonexistantKey));
if (useTX) {
c.getCacheTransactionManager().commit();
// test that the commit correctly created the entries in the region
assertNotNull(myRegion.get(notAffectedKey));
assertNull(myRegion.get(key1));
assertFalse(myRegion.containsKey(key1));
entry = ((LocalRegion) myRegion).getRegionEntry(key1);
// it should be there
assertNotNull(entry);
// it should be a destroyed entry with Token.TOMBSTONE
assertTrue(entry.isTombstone());
assertNull(myRegion.get(key2));
assertFalse(myRegion.containsKey(key2));
entry = ((LocalRegion) myRegion).getRegionEntry(key2);
// it should be there
assertNotNull(entry);
// it should be a destroyed entry with Token.TOMBSTONE
assertTrue(entry.isTombstone());
}
myRegion.localDestroy(notAffectedKey);
if (useTX) {
c.getCacheTransactionManager().begin();
}
// check that getAll returns invalidated entries
List keys = new LinkedList();
keys.add(notAffectedKey);
keys.add(key1);
keys.add(key2);
Map result = myRegion.getAll(keys);
org.apache.geode.test.dunit.LogWriterUtils.getLogWriter().info("result of getAll = " + result);
assertNotNull(result.get(notAffectedKey));
assertNull(result.get(key1));
assertNull(result.get(key2));
assertFalse(myRegion.containsKey(key1));
assertFalse(myRegion.containsKey(key2));
if (!useTX) {
entry = ((LocalRegion) myRegion).getRegionEntry(key1);
// it should be there
assertNotNull(entry);
// it should be a destroyed entry with Token.TOMBSTONE
assertTrue(entry.isTombstone());
entry = ((LocalRegion) myRegion).getRegionEntry(key2);
// it should be there
assertNotNull(entry);
// it should be a destroyed entry with Token.TOMBSTONE
assertTrue(entry.isTombstone());
} else {
// useTX
c.getCacheTransactionManager().commit();
// test that the commit correctly created the entries in the region
assertNotNull(myRegion.get(notAffectedKey));
assertNull(myRegion.get(key1));
assertFalse(myRegion.containsKey(key1));
entry = ((LocalRegion) myRegion).getRegionEntry(key1);
// it should be there
assertNotNull(entry);
// it should be a destroyed entry with Token.TOMBSTONE
assertTrue(entry.isTombstone());
assertNull(myRegion.get(key2));
assertFalse(myRegion.containsKey(key2));
entry = ((LocalRegion) myRegion).getRegionEntry(key2);
// it should be there
assertNotNull(entry);
// it should be a destroyed entry with Token.TOMBSTONE
assertTrue(entry.isTombstone());
}
}
use of org.apache.geode.test.dunit.SerializableCallableIF in project geode by apache.
the class ClientServerInvalidAndDestroyedEntryDUnitTest method doTestRegisterInterestRemovesOldEntry.
private void doTestRegisterInterestRemovesOldEntry(final String regionName, final boolean usePR) throws Exception {
VM vm1 = Host.getHost(0).getVM(1);
VM vm2 = Host.getHost(0).getVM(2);
// here are the keys that will be used to validate behavior. Keys must be
// colocated if using both a partitioned region in the server and transactions
// in the client. All of these keys hash to bucket 0 in a two-bucket PR
// except Object11 and IDoNotExist1
final String key10 = "Object10";
final String interestPattern = "Object.*";
SerializableCallableIF createServer = getCreateServerCallable(regionName, usePR);
int serverPort = (Integer) vm1.invoke(createServer);
vm2.invoke(createServer);
vm1.invoke(new SerializableRunnable("populate server") {
public void run() {
Region myRegion = getCache().getRegion(regionName);
for (int i = 1; i <= 20; i++) {
myRegion.put("Object" + i, "Value" + i);
}
}
});
org.apache.geode.test.dunit.LogWriterUtils.getLogWriter().info("creating client cache");
ClientCache c = new ClientCacheFactory().addPoolServer("localhost", serverPort).set(LOG_LEVEL, LogWriterUtils.getDUnitLogLevel()).setPoolSubscriptionEnabled(true).create();
Region myRegion = c.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create(regionName);
;
myRegion.registerInterestRegex(interestPattern);
// make sure key1 is in the client because we're going to mess with it
assertNotNull(myRegion.get(key10));
// remove the entry for key1 on the servers and then simulate interest recovery
// to show that the entry for key1 is no longer there in the client when recovery
// finishes
SerializableRunnable destroyKey10 = new SerializableRunnable("locally destroy " + key10 + " in the servers") {
public void run() {
Region myRegion = getCache().getRegion(regionName);
EntryEventImpl event = ((LocalRegion) myRegion).generateEvictDestroyEvent(key10);
event.setOperation(Operation.LOCAL_DESTROY);
if (usePR) {
BucketRegion bucket = ((PartitionedRegion) myRegion).getBucketRegion(key10);
if (bucket != null) {
event.setRegion(bucket);
org.apache.geode.test.dunit.LogWriterUtils.getLogWriter().info("performing local destroy in " + bucket + " ccEnabled=" + bucket.concurrencyChecksEnabled + " rvv=" + bucket.getVersionVector());
// turn off cc so entry is removed
bucket.concurrencyChecksEnabled = false;
bucket.mapDestroy(event, false, false, null);
bucket.concurrencyChecksEnabled = true;
}
} else {
// turn off cc so entry is
((LocalRegion) myRegion).concurrencyChecksEnabled = false;
// removed
((LocalRegion) myRegion).mapDestroy(event, false, false, null);
((LocalRegion) myRegion).concurrencyChecksEnabled = true;
}
}
};
vm1.invoke(destroyKey10);
vm2.invoke(destroyKey10);
myRegion.getCache().getLogger().info("clearing keys of interest");
((LocalRegion) myRegion).clearKeysOfInterest(interestPattern, InterestType.REGULAR_EXPRESSION, InterestResultPolicy.KEYS_VALUES);
myRegion.getCache().getLogger().info("done clearing keys of interest");
assertTrue("expected region to be empty but it has " + myRegion.size() + " entries", myRegion.size() == 0);
RegionEntry entry;
entry = ((LocalRegion) myRegion).getRegionEntry(key10);
// it should have been removed
assertNull(entry);
// now register interest. At the end, finishRegisterInterest should clear
// out the entry for key1 because it was stored in image-state as a
// destroyed RI entry in clearKeysOfInterest
myRegion.registerInterestRegex(interestPattern);
entry = ((LocalRegion) myRegion).getRegionEntry(key10);
// it should not be there
assertNull(entry);
}
Aggregations