use of org.apache.geode.internal.cache.execute.data.CustId in project geode by apache.
the class RemoteTransactionDUnitTest method testTxRemoveAllNotColocated.
@Test
public void testTxRemoveAllNotColocated() {
Host host = Host.getHost(0);
VM acc = host.getVM(0);
VM datastore1 = host.getVM(1);
VM datastore2 = host.getVM(3);
datastore2.invoke(new SerializableCallable() {
public Object call() throws Exception {
createRegion(false, /* accessor */
0, null);
return null;
}
});
initAccessorAndDataStore(acc, datastore1, 0);
VM accessor = getVMForTransactions(acc, datastore1);
final CustId custId0 = new CustId(0);
final CustId custId1 = new CustId(1);
final CustId custId2 = new CustId(2);
final CustId custId3 = new CustId(3);
final CustId custId4 = new CustId(4);
final CustId custId20 = new CustId(20);
final TXId txId = (TXId) accessor.invoke(new SerializableCallable() {
public Object call() throws Exception {
Region<CustId, Customer> cust = getGemfireCache().getRegion(CUSTOMER);
Region<CustId, Customer> ref = getGemfireCache().getRegion(D_REFERENCE);
TXManagerImpl mgr = getGemfireCache().getTxManager();
mgr.begin();
Customer customer = new Customer("customer1", "address1");
Customer customer2 = new Customer("customer2", "address2");
Customer fakeCust = new Customer("foo2", "bar2");
try {
cust.removeAll(Arrays.asList(custId0, custId4, custId1, custId2, custId3, custId20));
fail("expected exception not thrown");
} catch (TransactionDataNotColocatedException e) {
mgr.rollback();
}
assertNotNull(cust.get(custId0));
assertNotNull(cust.get(custId1));
assertNotNull(cust.get(custId2));
assertNotNull(cust.get(custId3));
assertNotNull(cust.get(custId4));
return mgr.getTransactionId();
}
});
}
use of org.apache.geode.internal.cache.execute.data.CustId in project geode by apache.
the class MyTransactionFunction method verifyExecutionOnPrimary.
private void verifyExecutionOnPrimary(RegionFunctionContext ctx) {
PartitionedRegion pr = (PartitionedRegion) ctx.getDataSet();
ArrayList args = (ArrayList) ctx.getArguments();
CustId custId = (CustId) args.get(1);
int bucketId = PartitionedRegionHelper.getHashKey(pr, null, custId, null, null);
DistributedMember primary = pr.getRegionAdvisor().getPrimaryMemberForBucket(bucketId);
DistributedMember me = pr.getCache().getDistributedSystem().getDistributedMember();
Assert.assertTrue(me.equals(primary), "Function should have been executed on primary:" + primary + " but was executed on member:" + me);
}
use of org.apache.geode.internal.cache.execute.data.CustId in project geode by apache.
the class MyTransactionFunction method verifyTransactionRollback.
private void verifyTransactionRollback(RegionFunctionContext ctx) {
Region custPR = ctx.getDataSet();
Region orderPR = custPR.getCache().getRegion(PRTransactionDUnitTest.OrderPartitionedRegionName);
CacheTransactionManager mgr = custPR.getCache().getCacheTransactionManager();
ArrayList args = (ArrayList) ctx.getArguments();
CustId custId = (CustId) args.get(1);
Customer newCus = (Customer) args.get(2);
OrderId orderId = (OrderId) args.get(3);
Order order = (Order) args.get(4);
Customer oldCustomer = (Customer) custPR.get(custId);
Order oldOrder = (Order) orderPR.get(orderId);
mgr.begin();
custPR.put(custId, newCus);
Customer txCust = (Customer) custPR.get(custId);
orderPR.put(orderId, order);
Order txOrder = (Order) orderPR.get(orderId);
Assert.assertTrue(newCus.equals(txCust), "Expected Customer to be:" + newCus + " but was:" + txCust);
Assert.assertTrue(txOrder.equals(order), "Expected Order to be:" + order + " but was:" + txOrder);
mgr.rollback();
Customer commitedCust = (Customer) custPR.get(custId);
Assert.assertTrue(oldCustomer.equals(commitedCust), "Expected Customer to be:" + oldCustomer + " but was:" + commitedCust);
Order commitedOrder = (Order) orderPR.get(orderId);
Assert.assertTrue(oldOrder.equals(commitedOrder), "Expected Order to be:" + oldOrder + " but was:" + commitedOrder);
mgr.begin();
Assert.assertTrue(custPR.remove(custId, oldCustomer));
orderPR.replace(orderId, order);
mgr.rollback();
Assert.assertTrue(oldCustomer.equals(custPR.get(custId)));
Assert.assertTrue(oldOrder.equals(orderPR.get(orderId)));
mgr.begin();
Assert.assertTrue(custPR.replace(custId, oldCustomer, newCus));
orderPR.remove(orderId, oldOrder);
Assert.assertTrue(null == orderPR.putIfAbsent(orderId, order));
mgr.rollback();
Assert.assertTrue(oldCustomer.equals(custPR.get(custId)));
Assert.assertTrue(oldOrder.equals(orderPR.get(orderId)));
}
use of org.apache.geode.internal.cache.execute.data.CustId in project geode by apache.
the class MyTransactionFunction method verifyInvalidateOperation.
private void verifyInvalidateOperation(RegionFunctionContext ctx) {
Region custPR = ctx.getDataSet();
Region orderPR = custPR.getCache().getRegion(PRTransactionDUnitTest.OrderPartitionedRegionName);
CacheTransactionManager mgr = custPR.getCache().getCacheTransactionManager();
ArrayList args = (ArrayList) ctx.getArguments();
CustId custId = (CustId) args.get(1);
Customer newCus = (Customer) args.get(2);
OrderId orderId = (OrderId) args.get(3);
Order order = (Order) args.get(4);
Customer oldCustomer = (Customer) custPR.get(custId);
Customer commitedCust = null;
// test destroy rollback
mgr.begin();
custPR.put(custId, newCus);
custPR.invalidate(custId);
orderPR.put(orderId, order);
mgr.rollback();
commitedCust = (Customer) custPR.get(custId);
Assert.assertTrue(oldCustomer.equals(commitedCust), "Expected customer to rollback to:" + oldCustomer + " but was:" + commitedCust);
// test destroy rollback on unmodified entry
mgr.begin();
custPR.invalidate(custId);
orderPR.put(orderId, order);
mgr.rollback();
commitedCust = (Customer) custPR.get(custId);
Assert.assertTrue(oldCustomer.equals(commitedCust), "Expected customer to rollback to:" + oldCustomer + " but was:" + commitedCust);
// test remote destroy
boolean caughtEx = false;
try {
mgr.begin();
custPR.put(custId, new Customer("foo", "bar"));
custPR.invalidate(custId);
custPR.invalidate(new CustId(1));
custPR.invalidate(new CustId(3));
custPR.invalidate(new CustId(7));
mgr.commit();
} catch (Exception e) {
mgr.rollback();
if ((e instanceof TransactionDataNotColocatedException) || (e instanceof TransactionDataRebalancedException)) {
caughtEx = true;
} else if (e instanceof EntryNotFoundException && e.getMessage().matches("Entry not found for key.*1")) {
caughtEx = true;
} else {
throw new TestException("Expected to catch PR remote destroy exception, but caught:" + e.getMessage(), e);
}
}
if (!caughtEx) {
throw new TestException("An Expected exception was not thrown");
}
// test destroy on unmodified entry
mgr.begin();
custPR.invalidate(custId);
orderPR.put(orderId, order);
mgr.commit();
commitedCust = (Customer) custPR.get(custId);
Assert.assertTrue(commitedCust == null, "Expected Customer to be null but was:" + commitedCust);
Order commitedOrder = (Order) orderPR.get(orderId);
Assert.assertTrue(order.equals(commitedOrder), "Expected Order to be:" + order + " but was:" + commitedOrder);
// test destroy on new entry
// TODO: This throws EntryNotFound
/*
* OrderId newOrderId = new OrderId(5000,custId); mgr.begin(); orderPR.put(newOrderId, new
* Order("New Order to be destroyed")); orderPR.invalidate(newOrderId); mgr.commit();
* Assert.assertTrue(orderPR.get(newOrderId)==null,"Did not expect orderId to be present");
*/
}
use of org.apache.geode.internal.cache.execute.data.CustId in project geode by apache.
the class PRTransactionDUnitTest method _resumeTx.
private void _resumeTx(Op op, TransactionId txId, PartitionedRegion pr, CacheTransactionManager mgr) {
CustId cust1 = new CustId(1);
OrderId order1 = new OrderId(11, cust1);
OrderId neworder = new OrderId(111, cust1);
mgr.resume(txId);
try {
switch(op) {
case GET:
pr.get(order1);
break;
case CONTAINSVALUEFORKEY:
pr.containsValueForKey(order1);
break;
case CONTAINSKEY:
pr.containsKey(order1);
break;
case CREATE:
pr.create(neworder, new Order("test"));
break;
case PUT:
pr.put(order1, new Order("test"));
break;
case INVALIDATE:
pr.invalidate(order1);
break;
case DESTROY:
pr.destroy(order1);
break;
case GETENTRY:
pr.getEntry(order1);
break;
default:
throw new AssertionError("Unknown operations " + op);
}
} finally {
mgr.rollback();
}
}
Aggregations