Examples with OrderId org.apache.geode.internal.cache.execute.data.OrderId used on opensource projects

Example 56 with OrderId

use of org.apache.geode.internal.cache.execute.data.OrderId in project geode by apache.

the class RemoteTransactionDUnitTest method validateContains.

void validateContains(CustId custId, Set<OrderId> ordersSet, boolean containsKey, boolean containsValue) {
    Region<CustId, Customer> custRegion = getCache().getRegion(CUSTOMER);
    Region<OrderId, Order> orderRegion = getCache().getRegion(ORDER);
    Region<CustId, Order> refRegion = getCache().getRegion(D_REFERENCE);
    boolean rContainsKC = custRegion.containsKey(custId);
    boolean rContainsKO = containsKey;
    for (OrderId o : ordersSet) {
        getGemfireCache().getLoggerI18n().fine("SWAP:rContainsKO:" + rContainsKO + " containsKey:" + orderRegion.containsKey(o));
        rContainsKO = rContainsKO && orderRegion.containsKey(o);
    }
    boolean rContainsKR = refRegion.containsKey(custId);
    boolean rContainsVC = custRegion.containsValueForKey(custId);
    boolean rContainsVO = containsValue;
    for (OrderId o : ordersSet) {
        rContainsVO = rContainsVO && orderRegion.containsValueForKey(o);
    }
    boolean rContainsVR = refRegion.containsValueForKey(custId);
    assertEquals(containsKey, rContainsKC);
    assertEquals(containsKey, rContainsKO);
    assertEquals(containsKey, rContainsKR);
    assertEquals(containsValue, rContainsVR);
    assertEquals(containsValue, rContainsVC);
    assertEquals(containsValue, rContainsVO);
    if (containsKey) {
        Region.Entry eC = custRegion.getEntry(custId);
        for (OrderId o : ordersSet) {
            assertNotNull(orderRegion.getEntry(o));
        }
        Region.Entry eR = refRegion.getEntry(custId);
        assertNotNull(eC);
        assertNotNull(eR);
    // assertIndexDetailsEquals(1,custRegion.size());
    // assertIndexDetailsEquals(1,orderRegion.size());
    // assertIndexDetailsEquals(1,refRegion.size());
    } else {
        // assertIndexDetailsEquals(0,refRegion.size());
        try {
            Region.Entry eC = custRegion.getEntry(custId);
            assertNull("should have had an EntryNotFoundException:" + eC, eC);
        } catch (EntryNotFoundException enfe) {
        // this is what we expect
        }
        try {
            for (OrderId o : ordersSet) {
                assertNull("should have had an EntryNotFoundException:" + orderRegion.getEntry(o), orderRegion.getEntry(o));
            }
        } catch (EntryNotFoundException enfe) {
        // this is what we expect
        }
        try {
            Region.Entry eR = refRegion.getEntry(custId);
            assertNull("should have had an EntryNotFoundException:" + eR, eR);
        } catch (EntryNotFoundException enfe) {
        // this is what we expect
        }
    }
}

Example 57 with OrderId

use of org.apache.geode.internal.cache.execute.data.OrderId in project geode by apache.

the class RemoteTransactionDUnitTest method testTXWithRI.

@Test
public void testTXWithRI() throws Exception {
    Host host = Host.getHost(0);
    VM accessor = host.getVM(0);
    VM datastore = host.getVM(1);
    VM client = host.getVM(2);
    initAccessorAndDataStore(accessor, datastore, 0);
    int port = startServer(datastore);
    createClientRegion(client, port, false, true);
    accessor.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            Region<CustId, Customer> custRegion = getCache().getRegion(CUSTOMER);
            Region<OrderId, Order> orderRegion = getCache().getRegion(ORDER);
            Region<CustId, Customer> refRegion = getCache().getRegion(D_REFERENCE);
            CustId custId = new CustId(1);
            OrderId orderId = new OrderId(1, custId);
            getCache().getCacheTransactionManager().begin();
            custRegion.put(custId, new Customer("foo", "bar"));
            orderRegion.put(orderId, new Order("fooOrder"));
            refRegion.put(custId, new Customer("foo", "bar"));
            getCache().getCacheTransactionManager().commit();
            return null;
        }
    });
    client.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            Region<CustId, Customer> custRegion = getCache().getRegion(CUSTOMER);
            Region<OrderId, Order> orderRegion = getCache().getRegion(ORDER);
            Region<CustId, Customer> refRegion = getCache().getRegion(D_REFERENCE);
            final ClientListener cl = (ClientListener) custRegion.getAttributes().getCacheListeners()[0];
            WaitCriterion waitForListenerInvocation = new WaitCriterion() {

                public boolean done() {
                    return cl.invoked;
                }

                public String description() {
                    return "listener was never invoked";
                }
            };
            Wait.waitForCriterion(waitForListenerInvocation, 10 * 1000, 10, true);
            return null;
        }
    });
}

Example 58 with OrderId

use of org.apache.geode.internal.cache.execute.data.OrderId in project geode by apache.

the class RemoteTransactionDUnitTest method createRegion.

void createRegion(boolean accessor, int redundantCopies, InterestPolicy interestPolicy) {
    AttributesFactory af = new AttributesFactory();
    af.setScope(Scope.DISTRIBUTED_ACK);
    af.setDataPolicy(DataPolicy.REPLICATE);
    af.setConcurrencyChecksEnabled(getConcurrencyChecksEnabled());
    getCache().createRegion(D_REFERENCE, af.create());
    af = new AttributesFactory();
    af.setConcurrencyChecksEnabled(getConcurrencyChecksEnabled());
    if (interestPolicy != null) {
        af.setSubscriptionAttributes(new SubscriptionAttributes(interestPolicy));
    }
    af.setPartitionAttributes(new PartitionAttributesFactory<CustId, Customer>().setTotalNumBuckets(4).setLocalMaxMemory(accessor ? 0 : 1).setPartitionResolver(new CustomerIDPartitionResolver("resolver1")).setRedundantCopies(redundantCopies).create());
    getCache().createRegion(CUSTOMER, af.create());
    af.setPartitionAttributes(new PartitionAttributesFactory<OrderId, Order>().setTotalNumBuckets(4).setLocalMaxMemory(accessor ? 0 : 1).setPartitionResolver(new CustomerIDPartitionResolver("resolver2")).setRedundantCopies(redundantCopies).setColocatedWith(CUSTOMER).create());
    getCache().createRegion(ORDER, af.create());
}

Example 59 with OrderId

use of org.apache.geode.internal.cache.execute.data.OrderId in project geode by apache.

the class RemoteTransactionDUnitTest method doSizeTest.

private void doSizeTest(final boolean isAccessor) {
    Host host = Host.getHost(0);
    VM accessor = host.getVM(0);
    VM datastore1 = host.getVM(1);
    VM datastore2 = host.getVM(2);
    initAccessorAndDataStore(accessor, datastore1, datastore2, 0);
    VM taskVM = isAccessor ? accessor : datastore1;
    taskVM.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            Region custRegion = getCache().getRegion(CUSTOMER);
            TXManagerImpl mgr = getGemfireCache().getTxManager();
            mgr.begin();
            assertEquals(5, custRegion.size());
            assertNotNull(mgr.getTXState());
            return null;
        }
    });
    datastore1.invoke(verifyNoTxState);
    datastore2.invoke(verifyNoTxState);
    taskVM.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            Region custRegion = getCache().getRegion(CUSTOMER);
            Region orderRegion = getCache().getRegion(ORDER);
            TXManagerImpl mgr = getGemfireCache().getTxManager();
            TransactionId txId = mgr.suspend();
            PartitionedRegion custPR = (PartitionedRegion) custRegion;
            int remoteKey = -1;
            for (int i = 100; i < 200; i++) {
                DistributedMember myId = custPR.getMyId();
                if (!myId.equals(custPR.getOwnerForKey(custPR.getKeyInfo(new CustId(i))))) {
                    remoteKey = i;
                    break;
                }
            }
            if (remoteKey == -1) {
                throw new IllegalStateException("expected non-negative key");
            }
            mgr.resume(txId);
            assertNotNull(mgr.getTXState());
            CustId custId = new CustId(remoteKey);
            OrderId orderId = new OrderId(remoteKey, custId);
            custRegion.put(custId, new Customer("customer" + remoteKey, "address" + remoteKey));
            getCache().getLogger().info("Putting " + custId + ", keyInfo:" + custPR.getKeyInfo(new CustId(remoteKey)));
            orderRegion.put(orderId, new Order("order" + remoteKey));
            assertEquals(6, custRegion.size());
            return mgr.getTransactionId();
        }
    });
    final Integer txOnDatastore1 = (Integer) datastore1.invoke(getNumberOfTXInProgress);
    final Integer txOnDatastore2 = (Integer) datastore2.invoke(getNumberOfTXInProgress);
    assertEquals(1, txOnDatastore1 + txOnDatastore2);
    taskVM.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            CacheTransactionManager mgr = getGemfireCache().getTxManager();
            mgr.commit();
            return null;
        }
    });
    datastore1.invoke(verifyNoTxState);
    datastore2.invoke(verifyNoTxState);
    final Integer txOnDatastore1_1 = (Integer) datastore1.invoke(getNumberOfTXInProgress);
    final Integer txOnDatastore2_2 = (Integer) datastore2.invoke(getNumberOfTXInProgress);
    assertEquals(0, txOnDatastore1_1.intValue());
    assertEquals(0, txOnDatastore2_2.intValue());
}

Example 60 with OrderId

use of org.apache.geode.internal.cache.execute.data.OrderId in project geode by apache.

the class RemoteTransactionDUnitTest method testTxPutIfAbsent.

@Test
public void testTxPutIfAbsent() {
    Host host = Host.getHost(0);
    VM acc = host.getVM(0);
    VM datastore = host.getVM(1);
    initAccessorAndDataStore(acc, datastore, 0);
    VM accessor = getVMForTransactions(acc, datastore);
    final CustId newCustId = new CustId(10);
    final Customer updateCust = new Customer("customer10", "address10");
    final TXId txId = (TXId) accessor.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            TXManagerImpl mgr = getGemfireCache().getTxManager();
            mgr.begin();
            Region<CustId, Customer> cust = getGemfireCache().getRegion(CUSTOMER);
            Region<CustId, Customer> rr = getGemfireCache().getRegion(D_REFERENCE);
            Customer expectedCust = new Customer("customer" + 1, "address" + 1);
            getGemfireCache().getLoggerI18n().fine("SWAP:doingPutIfAbsent");
            CustId oldCustId = new CustId(1);
            Customer old = cust.putIfAbsent(oldCustId, updateCust);
            assertTrue("expected:" + expectedCust + " but was " + old, expectedCust.equals(old));
            // transaction should be bootstrapped
            old = rr.putIfAbsent(oldCustId, updateCust);
            assertTrue("expected:" + expectedCust + " but was " + old, expectedCust.equals(old));
            // now a key that does not exist
            old = cust.putIfAbsent(newCustId, updateCust);
            assertNull(old);
            old = rr.putIfAbsent(newCustId, updateCust);
            assertNull(old);
            Region<OrderId, Order> order = getGemfireCache().getRegion(ORDER);
            Order oldOrder = order.putIfAbsent(new OrderId(10, newCustId), new Order("order10"));
            assertNull(old);
            assertNull(oldOrder);
            assertNotNull(cust.get(newCustId));
            assertNotNull(rr.get(newCustId));
            TXStateProxy tx = mgr.internalSuspend();
            assertNull(cust.get(newCustId));
            assertNull(rr.get(newCustId));
            mgr.internalResume(tx);
            cust.put(oldCustId, new Customer("foo", "bar"));
            rr.put(oldCustId, new Customer("foo", "bar"));
            return mgr.getTransactionId();
        }
    });
    datastore.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            Region cust = getGemfireCache().getRegion(CUSTOMER);
            int hash1 = PartitionedRegionHelper.getHashKey((PartitionedRegion) cust, new CustId(1));
            int hash10 = PartitionedRegionHelper.getHashKey((PartitionedRegion) cust, new CustId(10));
            TXManagerImpl mgr = getGemfireCache().getTxManager();
            assertTrue(mgr.isHostedTxInProgress(txId));
            TXStateProxy tx = mgr.getHostedTXState(txId);
            // 2 buckets for the two
            assertEquals(3 + (hash1 == hash10 ? 0 : 1), tx.getRegions().size());
            // different buckets
            for (LocalRegion r : tx.getRegions()) {
                assertTrue(r instanceof BucketRegion || r instanceof DistributedRegion);
                TXRegionState rs = tx.readRegion(r);
                for (Object key : rs.getEntryKeys()) {
                    TXEntryState es = rs.readEntry(key);
                    assertNotNull(es.getValue(key, r, false));
                    assertTrue("key:" + key + " r:" + r.getFullPath(), es.isDirty());
                }
            }
            return null;
        }
    });
    accessor.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            TXManagerImpl mgr = getGemfireCache().getTxManager();
            mgr.commit();
            Region<CustId, Customer> cust = getGemfireCache().getRegion(CUSTOMER);
            Region<CustId, Customer> rr = getGemfireCache().getRegion(D_REFERENCE);
            assertEquals(updateCust, cust.get(newCustId));
            assertEquals(updateCust, rr.get(newCustId));
            // test conflict
            mgr.begin();
            CustId conflictCust = new CustId(11);
            cust.putIfAbsent(conflictCust, new Customer("name11", "address11"));
            TXStateProxy tx = mgr.internalSuspend();
            cust.put(conflictCust, new Customer("foo", "bar"));
            mgr.internalResume(tx);
            try {
                mgr.commit();
                fail("expected exception not thrown");
            } catch (CommitConflictException cce) {
            }
            return null;
        }
    });
}