use of org.apache.geode.internal.cache.execute.data.Customer 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.Customer in project geode by apache.
the class PRTransactionDUnitTest method validatePRTXInCacheListener.
/**
* verify that 10 orders are created for each customer
*
* @throws ClassNotFoundException
*/
public static void validatePRTXInCacheListener() throws ClassNotFoundException {
PartitionedRegion customerPartitionedregion = null;
PartitionedRegion orderPartitionedregion = null;
try {
customerPartitionedregion = (PartitionedRegion) basicGetCache().getRegion(Region.SEPARATOR + CustomerPartitionedRegionName);
orderPartitionedregion = (PartitionedRegion) basicGetCache().getRegion(Region.SEPARATOR + OrderPartitionedRegionName);
} catch (Exception e) {
Assert.fail("validateAfterPutPartitionedRegion : failed while getting the region", e);
}
assertNotNull(customerPartitionedregion);
assertNotNull(orderPartitionedregion);
customerPartitionedregion.getDataStore().dumpEntries(false);
orderPartitionedregion.getDataStore().dumpEntries(false);
Iterator custIterator = customerPartitionedregion.getDataStore().getEntries().iterator();
LogWriterUtils.getLogWriter().info("Found " + customerPartitionedregion.getDataStore().getEntries().size() + " Customer entries in the partition");
Region.Entry custEntry = null;
while (custIterator.hasNext()) {
custEntry = (Entry) custIterator.next();
CustId custid = (CustId) custEntry.getKey();
Customer cust = (Customer) custEntry.getValue();
Iterator orderIterator = orderPartitionedregion.getDataStore().getEntries().iterator();
LogWriterUtils.getLogWriter().info("Found " + orderPartitionedregion.getDataStore().getEntries().size() + " Order entries in the partition");
int orderPerCustomer = 0;
Region.Entry orderEntry = null;
while (orderIterator.hasNext()) {
orderEntry = (Entry) orderIterator.next();
OrderId orderId = (OrderId) orderEntry.getKey();
Order order = (Order) orderEntry.getValue();
if (custid.equals(orderId.getCustId())) {
orderPerCustomer++;
}
}
assertEquals(10, orderPerCustomer);
}
}
use of org.apache.geode.internal.cache.execute.data.Customer in project geode by apache.
the class PRTransactionDUnitTest method basicPRTXInFunction.
/**
* Test all the basic functionality of colocated transactions. This method invokes
* {@link MyTransactionFunction} and tells it what to test, using different arguments.
*
* @param redundantBuckets redundant buckets for colocated PRs
* @param populateData if false tests are carried out on empty colocated PRs
*/
protected void basicPRTXInFunction(int redundantBuckets, boolean populateData) {
if (populateData) {
createPopulateAndVerifyCoLocatedPRs(redundantBuckets);
} else {
createColocatedPRs(redundantBuckets);
}
SerializableCallable registerFunction = new SerializableCallable("register Fn") {
public Object call() throws Exception {
Function txFunction = new MyTransactionFunction();
FunctionService.registerFunction(txFunction);
return Boolean.TRUE;
}
};
dataStore1.invoke(registerFunction);
dataStore2.invoke(registerFunction);
dataStore3.invoke(registerFunction);
accessor.invoke(new SerializableCallable("run function") {
public Object call() throws Exception {
PartitionedRegion pr = (PartitionedRegion) basicGetCache().getRegion(Region.SEPARATOR + CustomerPartitionedRegionName);
PartitionedRegion orderpr = (PartitionedRegion) basicGetCache().getRegion(Region.SEPARATOR + OrderPartitionedRegionName);
CustId custId = new CustId(2);
Customer newCus = new Customer("foo", "bar");
Order order = new Order("fooOrder");
OrderId orderId = new OrderId(22, custId);
ArrayList args = new ArrayList();
Function txFunction = new MyTransactionFunction();
FunctionService.registerFunction(txFunction);
Execution e = FunctionService.onRegion(pr);
Set filter = new HashSet();
// test transaction non-coLocated operations
filter.clear();
args.clear();
args.add(new Integer(VERIFY_NON_COLOCATION));
LogWriterUtils.getLogWriter().info("VERIFY_NON_COLOCATION");
args.add(custId);
args.add(newCus);
args.add(orderId);
args.add(order);
filter.add(custId);
try {
e.withFilter(filter).setArguments(args).execute(txFunction.getId()).getResult();
fail("Expected exception was not thrown");
} catch (FunctionException fe) {
LogWriterUtils.getLogWriter().info("Caught Expected exception");
if (fe.getCause() instanceof TransactionDataNotColocatedException) {
} else {
throw new TestException("Expected to catch FunctionException with cause TransactionDataNotColocatedException" + " but cause is " + fe.getCause(), fe.getCause());
}
}
// verify that the transaction modifications are applied
args.set(0, new Integer(VERIFY_TX));
LogWriterUtils.getLogWriter().info("VERIFY_TX");
orderpr.put(orderId, order);
assertNotNull(orderpr.get(orderId));
e.withFilter(filter).setArguments(args).execute(txFunction.getId()).getResult();
assertTrue("Unexpected customer value after commit", newCus.equals(pr.get(custId)));
Order commitedOrder = (Order) orderpr.get(orderId);
assertTrue("Unexpected order value after commit. Expected:" + order + " Found:" + commitedOrder, order.equals(commitedOrder));
// verify conflict detection
args.set(0, new Integer(VERIFY_TXSTATE_CONFLICT));
e.withFilter(filter).setArguments(args).execute(txFunction.getId()).getResult();
// verify that the transaction is rolled back
args.set(0, new Integer(VERIFY_ROLLBACK));
LogWriterUtils.getLogWriter().info("VERIFY_ROLLBACK");
e.withFilter(filter).setArguments(args).execute(txFunction.getId()).getResult();
// verify destroy
args.set(0, new Integer(VERIFY_DESTROY));
LogWriterUtils.getLogWriter().info("VERIFY_DESTROY");
e.withFilter(filter).setArguments(args).execute(txFunction.getId()).getResult();
// verify invalidate
args.set(0, new Integer(VERIFY_INVALIDATE));
LogWriterUtils.getLogWriter().info("VERIFY_INVALIDATE");
e.withFilter(filter).setArguments(args).execute(txFunction.getId()).getResult();
return Boolean.TRUE;
}
});
}
use of org.apache.geode.internal.cache.execute.data.Customer in project geode by apache.
the class PRTransactionDUnitTest method testRepeatableRead.
@Test
public void testRepeatableRead() throws Exception {
createColocatedPRs(1);
SerializableCallable registerFunction = new SerializableCallable("register Fn") {
public Object call() throws Exception {
Function txFunction = new MyTransactionFunction();
FunctionService.registerFunction(txFunction);
return Boolean.TRUE;
}
};
dataStore1.invoke(registerFunction);
dataStore2.invoke(registerFunction);
dataStore3.invoke(registerFunction);
accessor.invoke(new SerializableCallable("run function") {
public Object call() throws Exception {
PartitionedRegion pr = (PartitionedRegion) basicGetCache().getRegion(Region.SEPARATOR + CustomerPartitionedRegionName);
PartitionedRegion orderpr = (PartitionedRegion) basicGetCache().getRegion(Region.SEPARATOR + OrderPartitionedRegionName);
CustId custId = new CustId(2);
Customer newCus = new Customer("foo", "bar");
Order order = new Order("fooOrder");
OrderId orderId = new OrderId(22, custId);
ArrayList args = new ArrayList();
Function txFunction = new MyTransactionFunction();
FunctionService.registerFunction(txFunction);
Execution e = FunctionService.onRegion(pr);
Set filter = new HashSet();
filter.clear();
args.clear();
args.add(new Integer(VERIFY_REP_READ));
LogWriterUtils.getLogWriter().info("VERIFY_REP_READ");
args.add(custId);
args.add(newCus);
args.add(orderId);
args.add(order);
filter.add(custId);
e.withFilter(filter).setArguments(args).execute(txFunction.getId()).getResult();
return null;
}
});
}
use of org.apache.geode.internal.cache.execute.data.Customer in project geode by apache.
the class FixedPartitioningTestBase method getForColocation.
public static void getForColocation(String customerRegion, String order, String shipment) {
Region region_Cust = (PartitionedRegion) cache.getRegion(customerRegion);
assertNotNull(region_Cust);
for (int i = 1; i <= 20; i++) {
CustId custid = new CustId(i);
Customer customer = new Customer("name" + i, "Address" + i);
try {
assertEquals(customer, region_Cust.get(custid));
} catch (Exception e) {
org.apache.geode.test.dunit.Assert.fail("getForColocation : failed while doing get operation in CustomerPartitionedRegion ", e);
}
}
Region region_Ord = (PartitionedRegion) cache.getRegion(order);
assertNull(region_Ord);
Region region_Ship = (PartitionedRegion) cache.getRegion(shipment);
assertNull(region_Ship);
}
Aggregations