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

Example 66 with Customer

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

the class RemoteTransactionDUnitTest method testBug49398.

@Test
public void testBug49398() {
    disconnectAllFromDS();
    Host host = Host.getHost(0);
    VM vm1 = host.getVM(0);
    VM vm2 = host.getVM(1);
    final String lrName = getName() + "_lr";
    SerializableCallable createRegion = new SerializableCallable() {

        @Override
        public Object call() throws Exception {
            createRegion(false, 1, null);
            getCache().createRegionFactory(RegionShortcut.LOCAL).create(lrName);
            return null;
        }
    };
    vm1.invoke(createRegion);
    vm2.invoke(createRegion);
    vm1.invoke(new SerializableCallable() {

        @Override
        public Object call() throws Exception {
            CacheTransactionManager txMgr = getCache().getCacheTransactionManager();
            Region ref = getCache().getRegion(D_REFERENCE);
            Region lr = getCache().getRegion(lrName);
            txMgr.begin();
            ref.put(new CustId(1), new Customer("name1", "address1"));
            lr.put("key", "value");
            txMgr.commit();
            return null;
        }
    });
    // make sure local region changes are not reflected in the other vm
    vm2.invoke(new SerializableCallable() {

        @Override
        public Object call() throws Exception {
            Region lr = getCache().getRegion(lrName);
            assertNull(lr.get("key"));
            return null;
        }
    });
}

Example 67 with Customer

use of org.apache.geode.internal.cache.execute.data.Customer 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 68 with Customer

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

the class RemoteTransactionDUnitTest method testListenersNotInvokedOnSecondary.

@Test
public void testListenersNotInvokedOnSecondary() {
    Host host = Host.getHost(0);
    VM accessor = host.getVM(0);
    VM datastore1 = host.getVM(1);
    VM datastore2 = host.getVM(2);
    initAccessorAndDataStoreWithInterestPolicy(accessor, datastore1, datastore2, 1);
    SerializableCallable registerListener = new SerializableCallable() {

        public Object call() throws Exception {
            Region<CustId, Customer> custRegion = getCache().getRegion(CUSTOMER);
            custRegion.getAttributesMutator().addCacheListener(new ListenerInvocationCounter());
            return null;
        }
    };
    datastore1.invoke(registerListener);
    datastore2.invoke(registerListener);
    datastore1.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            Region<CustId, Customer> custRegion = getCache().getRegion(CUSTOMER);
            getCache().getCacheTransactionManager().begin();
            CustId custId = new CustId(1);
            Customer customer = new Customer("customerNew", "addressNew");
            custRegion.put(custId, customer);
            getCache().getCacheTransactionManager().commit();
            return null;
        }
    });
    SerializableCallable getListenerCount = new SerializableCallable() {

        public Object call() throws Exception {
            Region<CustId, Customer> custRegion = getCache().getRegion(CUSTOMER);
            ListenerInvocationCounter l = (ListenerInvocationCounter) custRegion.getAttributes().getCacheListeners()[0];
            getCache().getLogger().info("SWAP:listenerCount:" + l.invocationCount);
            return l.invocationCount;
        }
    };
    int totalInvocation = (Integer) datastore1.invoke(getListenerCount) + (Integer) datastore2.invoke(getListenerCount);
    assertEquals(1, totalInvocation);
}

Example 69 with Customer

use of org.apache.geode.internal.cache.execute.data.Customer 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 70 with Customer

use of org.apache.geode.internal.cache.execute.data.Customer 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;
        }
    });
}