Examples with CacheTransactionManager org.apache.geode.cache.CacheTransactionManager used on opensource projects

Example 41 with CacheTransactionManager

use of org.apache.geode.cache.CacheTransactionManager in project geode by apache.

the class MultiVMRegionTestCase method testTXUpdateLoadNoConflict.

/**
   * Tests that the push of a loaded value does not cause a conflict on the side receiving the
   * update
   */
@Ignore("TODO: this test always hits early out")
@Test
public void testTXUpdateLoadNoConflict() throws Exception {
    /*
     * this no longer holds true - we have load conflicts now
     * 
     */
    if (true) {
        return;
    }
    assumeTrue(supportsTransactions());
    assumeFalse(getRegionAttributes().getScope().isGlobal());
    assumeFalse(getRegionAttributes().getDataPolicy().withPersistence());
    assertTrue(getRegionAttributes().getScope().isDistributed());
    CacheTransactionManager txMgr = this.getCache().getCacheTransactionManager();
    final String rgnName = getUniqueName();
    SerializableRunnable create = new SerializableRunnable("testTXUpdateLoadNoConflict: Create Region & Load value") {

        @Override
        public void run() {
            CacheTransactionManager txMgr2 = getCache().getCacheTransactionManager();
            MyTransactionListener tl = new MyTransactionListener();
            txMgr2.addListener(tl);
            try {
                Region rgn = createRegion(rgnName);
                AttributesMutator mutator = rgn.getAttributesMutator();
                mutator.setCacheLoader(new CacheLoader() {

                    int count = 0;

                    @Override
                    public Object load(LoaderHelper helper) throws CacheLoaderException {
                        count++;
                        return "LV " + count;
                    }

                    @Override
                    public void close() {
                    }
                });
                Object value = rgn.get("key");
                assertEquals("LV 1", value);
                getSystem().getLogWriter().info("testTXUpdateLoadNoConflict: loaded Key");
                flushIfNecessary(rgn);
            } catch (CacheException e) {
                fail("While creating region", e);
            }
        }
    };
    VM vm0 = Host.getHost(0).getVM(0);
    try {
        MyTransactionListener tl = new MyTransactionListener();
        txMgr.addListener(tl);
        AttributesFactory rgnAtts = new AttributesFactory(getRegionAttributes());
        rgnAtts.setDataPolicy(DataPolicy.REPLICATE);
        Region rgn = createRegion(rgnName, rgnAtts.create());
        txMgr.begin();
        TransactionId myTXId = txMgr.getTransactionId();
        rgn.create("key", "txValue");
        vm0.invoke(create);
        {
            TXStateProxy tx = ((TXManagerImpl) txMgr).internalSuspend();
            assertTrue(rgn.containsKey("key"));
            assertEquals("LV 1", rgn.getEntry("key").getValue());
            ((TXManagerImpl) txMgr).internalResume(tx);
        }
        // make sure transactional view is still correct
        assertEquals("txValue", rgn.getEntry("key").getValue());
        txMgr.commit();
        getSystem().getLogWriter().info("testTXUpdateLoadNoConflict: did commit");
        assertEquals("txValue", rgn.getEntry("key").getValue());
        {
            Collection events = tl.lastEvent.getCreateEvents();
            assertEquals(1, events.size());
            EntryEvent ev = (EntryEvent) events.iterator().next();
            assertEquals(myTXId, ev.getTransactionId());
            assertTrue(ev.getRegion() == rgn);
            assertEquals("key", ev.getKey());
            assertEquals("txValue", ev.getNewValue());
            assertEquals(null, ev.getOldValue());
            assertTrue(!ev.getOperation().isLocalLoad());
            assertTrue(!ev.getOperation().isNetLoad());
            assertTrue(!ev.getOperation().isLoad());
            assertTrue(!ev.getOperation().isNetSearch());
            assertTrue(!ev.getOperation().isExpiration());
            assertEquals(null, ev.getCallbackArgument());
            assertEquals(true, ev.isCallbackArgumentAvailable());
            assertTrue(!ev.isOriginRemote());
            assertTrue(ev.getOperation().isDistributed());
        }
        // Now setup recreate the region in the controller with NONE
        // so test can do local destroys.
        rgn.localDestroyRegion();
        rgnAtts.setDataPolicy(DataPolicy.NORMAL);
        rgn = createRegion(rgnName, rgnAtts.create());
        // now see if net loader is working
        Object v2 = rgn.get("key2");
        assertEquals("LV 2", v2);
        // now confirm that netload does not cause a conflict
        txMgr.begin();
        myTXId = txMgr.getTransactionId();
        rgn.create("key3", "txValue3");
        {
            TXStateProxy tx = ((TXManagerImpl) txMgr).internalSuspend();
            // do a get outside of the transaction to force a net load
            Object v3 = rgn.get("key3");
            assertEquals("LV 3", v3);
            ((TXManagerImpl) txMgr).internalResume(tx);
        }
        // make sure transactional view is still correct
        assertEquals("txValue3", rgn.getEntry("key3").getValue());
        txMgr.commit();
        getSystem().getLogWriter().info("testTXUpdateLoadNoConflict: did commit");
        assertEquals("txValue3", rgn.getEntry("key3").getValue());
        {
            Collection events = tl.lastEvent.getCreateEvents();
            assertEquals(1, events.size());
            EntryEvent ev = (EntryEvent) events.iterator().next();
            assertEquals(myTXId, ev.getTransactionId());
            assertTrue(ev.getRegion() == rgn);
            assertEquals("key3", ev.getKey());
            assertEquals("txValue3", ev.getNewValue());
            assertEquals(null, ev.getOldValue());
            assertTrue(!ev.getOperation().isLocalLoad());
            assertTrue(!ev.getOperation().isNetLoad());
            assertTrue(!ev.getOperation().isLoad());
            assertTrue(!ev.getOperation().isNetSearch());
            assertTrue(!ev.getOperation().isExpiration());
            assertEquals(null, ev.getCallbackArgument());
            assertEquals(true, ev.isCallbackArgumentAvailable());
            assertTrue(!ev.isOriginRemote());
            assertTrue(ev.getOperation().isDistributed());
        }
        // now see if tx net loader is working
        // now confirm that netload does not cause a conflict
        txMgr.begin();
        myTXId = txMgr.getTransactionId();
        Object v4 = rgn.get("key4");
        assertEquals("LV 4", v4);
        assertEquals("LV 4", rgn.get("key4"));
        assertEquals("LV 4", rgn.getEntry("key4").getValue());
        txMgr.rollback();
        // confirm that netLoad is transactional
        assertEquals("LV 5", rgn.get("key4"));
        assertEquals("LV 5", rgn.getEntry("key4").getValue());
        // make sure non-tx netsearch works
        assertEquals("txValue", rgn.get("key"));
        assertEquals("txValue", rgn.getEntry("key").getValue());
        // make sure net-search result does not conflict with commit
        rgn.localInvalidate("key");
        txMgr.begin();
        myTXId = txMgr.getTransactionId();
        rgn.put("key", "new txValue");
        {
            TXStateProxy tx = ((TXManagerImpl) txMgr).internalSuspend();
            // do a get outside of the transaction to force a netsearch
            // does a netsearch
            assertEquals("txValue", rgn.get("key"));
            assertEquals("txValue", rgn.getEntry("key").getValue());
            ((TXManagerImpl) txMgr).internalResume(tx);
        }
        // make sure transactional view is still correct
        assertEquals("new txValue", rgn.getEntry("key").getValue());
        txMgr.commit();
        // give other side change to process commit
        flushIfNecessary(rgn);
        getSystem().getLogWriter().info("testTXUpdateLoadNoConflict: did commit");
        assertEquals("new txValue", rgn.getEntry("key").getValue());
        {
            Collection events = tl.lastEvent.getPutEvents();
            assertEquals(1, events.size());
            EntryEvent ev = (EntryEvent) events.iterator().next();
            assertEquals(myTXId, ev.getTransactionId());
            assertTrue(ev.getRegion() == rgn);
            assertEquals("key", ev.getKey());
            assertEquals("new txValue", ev.getNewValue());
            assertEquals(null, ev.getOldValue());
            assertTrue(!ev.getOperation().isLocalLoad());
            assertTrue(!ev.getOperation().isNetLoad());
            assertTrue(!ev.getOperation().isLoad());
            assertTrue(!ev.getOperation().isNetSearch());
            assertTrue(!ev.getOperation().isExpiration());
            assertEquals(null, ev.getCallbackArgument());
            assertEquals(true, ev.isCallbackArgumentAvailable());
            assertTrue(!ev.isOriginRemote());
            assertTrue(ev.getOperation().isDistributed());
        }
        // make sure tx local invalidate allows netsearch
        Object localCmtValue = rgn.getEntry("key").getValue();
        txMgr.begin();
        assertSame(localCmtValue, rgn.getEntry("key").getValue());
        rgn.localInvalidate("key");
        assertNull(rgn.getEntry("key").getValue());
        // now make sure a get will do a netsearch and find the value
        // in the other vm instead of the one in local cmt state
        Object txValue = rgn.get("key");
        assertNotSame(localCmtValue, txValue);
        assertSame(txValue, rgn.get("key"));
        assertNotSame(localCmtValue, rgn.getEntry("key").getValue());
        // make sure we did a search and not a load
        assertEquals(localCmtValue, rgn.getEntry("key").getValue());
        // now make sure that if we do a tx distributed invalidate
        // that we will do a load and not a search
        rgn.invalidate("key");
        assertNull(rgn.getEntry("key").getValue());
        txValue = rgn.get("key");
        assertEquals("LV 6", txValue);
        assertSame(txValue, rgn.get("key"));
        assertEquals("LV 6", rgn.getEntry("key").getValue());
        // now make sure after rollback that local cmt state has not changed
        txMgr.rollback();
        assertSame(localCmtValue, rgn.getEntry("key").getValue());
    } catch (Exception e) {
        CacheFactory.getInstance(getSystem()).close();
        getSystem().getLogWriter().fine("testTXUpdateLoadNoConflict: Caused exception in createRegion");
        throw e;
    }
}

Example 42 with CacheTransactionManager

use of org.apache.geode.cache.CacheTransactionManager in project geode by apache.

the class LRUEvictionControllerDUnitTest method testReplicationAndTransactions.

/**
   * Create two regions, one a "feed" that performs transactions which are replicated to a region
   * with an Entry LRU set to one Asserts that the LRU rules are observed
   * 
   * @throws Exception
   */
@Test
public void testReplicationAndTransactions() throws Exception {
    final String r1 = this.getUniqueName() + "-1";
    final String r2 = this.getUniqueName() + "-2";
    final String r3 = this.getUniqueName() + "-3";
    VM feeder = Host.getHost(0).getVM(3);
    VM repl = Host.getHost(0).getVM(2);
    final int maxEntries = 1;
    final int numEntries = 10000;
    final int txBatchSize = 10;
    // need at least one batch
    assertTrue(numEntries > txBatchSize);
    CacheSerializableRunnable createRegion = new CacheSerializableRunnable("Create Replicate Region") {

        public void run2() throws CacheException {
            AttributesFactory factory = new AttributesFactory();
            factory.setOffHeap(isOffHeapEnabled());
            factory.setEvictionAttributes(EvictionAttributes.createLRUEntryAttributes(maxEntries, EvictionAction.OVERFLOW_TO_DISK));
            factory.setDataPolicy(DataPolicy.REPLICATE);
            File[] diskDirs = new File[1];
            diskDirs[0] = new File("overflowDir/" + OSProcess.getId());
            diskDirs[0].mkdirs();
            factory.setDiskStoreName(getCache().createDiskStoreFactory().setDiskDirs(diskDirs).create("LRUEvictionControllerDUnitTest").getName());
            factory.setDiskSynchronous(true);
            factory.setScope(Scope.DISTRIBUTED_ACK);
            RegionAttributes a = factory.create();
            createRegion(r1, a);
            createRegion(r2, a);
            createRegion(r3, a);
        }
    };
    feeder.invoke(createRegion);
    repl.invoke(createRegion);
    feeder.invoke(new CacheSerializableRunnable("put " + numEntries + " entries and assert " + maxEntries + " max entries") {

        public void run2() throws CacheException {
            Cache c = getCache();
            CacheTransactionManager txm = c.getCacheTransactionManager();
            Region reg1 = getRootRegion().getSubregion(r1);
            assertNotNull(reg1);
            Region reg2 = getRootRegion().getSubregion(r2);
            assertNotNull(reg2);
            Region reg3 = getRootRegion().getSubregion(r3);
            assertNotNull(reg3);
            boolean startTx = false;
            final Region[] r = { reg1, reg2, reg3 };
            for (int i = 0; i < numEntries; i++) {
                if (i % txBatchSize == 0) {
                    txm.begin();
                    startTx = true;
                }
                reg1.create("r1-key-" + i, "r1-value-" + i);
                reg2.create("r2-key-" + i, "r2-value-" + i);
                reg3.create("r3-key-" + i, "r3-value-" + i);
                if (i % txBatchSize == (txBatchSize - 1)) {
                    txm.commit();
                    try {
                        // allow stats to get a sample in
                        Thread.sleep(20);
                    } catch (InterruptedException ie) {
                        fail("interrupted");
                    }
                    startTx = false;
                }
            }
            if (startTx) {
                txm.commit();
            }
            for (int i = 0; i < r.length; i++) {
                assertEquals(numEntries, r[i].size());
                {
                    LocalRegion lr = (LocalRegion) r[i];
                    assertEquals(maxEntries, lr.getEvictionController().getLRUHelper().getStats().getLimit());
                    assertEquals(maxEntries, lr.getEvictionController().getLRUHelper().getStats().getCounter());
                }
            }
        }
    });
    repl.invoke(new CacheSerializableRunnable("Replicate asserts " + maxEntries + " max entries") {

        public void run2() throws CacheException {
            getCache();
            Region reg1 = getRootRegion().getSubregion(r1);
            Region reg2 = getRootRegion().getSubregion(r2);
            Region reg3 = getRootRegion().getSubregion(r3);
            final Region[] r = { reg1, reg2, reg3 };
            for (int i = 0; i < r.length; i++) {
                assertNotNull(r[i]);
                assertEquals(numEntries, r[i].size());
                {
                    LocalRegion lr = (LocalRegion) r[i];
                    assertEquals(maxEntries, lr.getEvictionController().getLRUHelper().getStats().getLimit());
                    assertEquals(maxEntries, lr.getEvictionController().getLRUHelper().getStats().getCounter());
                }
            }
        }
    });
}

Example 43 with CacheTransactionManager

use of org.apache.geode.cache.CacheTransactionManager in project geode by apache.

the class DiskRegCacheXmlJUnitTest method closeCache.

/** Close the cache */
private synchronized void closeCache() {
    if (cache != null) {
        try {
            if (!cache.isClosed()) {
                CacheTransactionManager txMgr = cache.getCacheTransactionManager();
                if (txMgr != null) {
                    if (txMgr.exists()) {
                        // make sure we cleanup this threads txid stored in a thread local
                        txMgr.rollback();
                    }
                }
                cache.close();
            }
        } finally {
            cache = null;
        }
    }
}

Example 44 with CacheTransactionManager

use of org.apache.geode.cache.CacheTransactionManager in project geode by apache.

the class NestedTransactionFunction method execute.

public void execute(FunctionContext context) {
    Cache cache = CacheFactory.getAnyInstance();
    ArrayList args = (ArrayList) context.getArguments();
    TXId txId = null;
    int action = 0;
    try {
        txId = (TXId) args.get(0);
        action = (Integer) args.get(1);
    } catch (ClassCastException e) {
        logger.info("CommitFunction should be invoked with a TransactionId as an argument i.e. setArguments(txId).execute(function)");
        throw e;
    }
    CacheTransactionManager txMgr = cache.getCacheTransactionManager();
    Boolean result = false;
    final boolean isDebugEnabled = logger.isDebugEnabled();
    if (txMgr.tryResume(txId)) {
        if (isDebugEnabled) {
            logger.debug("CommitFunction: resumed transaction: {}", txId);
        }
        if (action == COMMIT) {
            if (isDebugEnabled) {
                logger.debug("CommitFunction: committing transaction: {}", txId);
            }
            txMgr.commit();
        } else if (action == ROLLBACK) {
            if (isDebugEnabled) {
                logger.debug("CommitFunction: rolling back transaction: {}", txId);
            }
            txMgr.rollback();
        } else {
            throw new IllegalStateException("unknown transaction termination action");
        }
        result = true;
    }
    if (isDebugEnabled) {
        logger.debug("CommitFunction: for transaction: {} sending result: {}", txId, result);
    }
    context.getResultSender().lastResult(result);
}

Example 45 with CacheTransactionManager

use of org.apache.geode.cache.CacheTransactionManager in project geode by apache.

the class TXJUnitTest method testPublicSuspendResume.

@Test
public void testPublicSuspendResume() {
    CacheTransactionManager txMgr = this.txMgr;
    assertTrue(!this.txMgr.exists());
    assertEquals(null, txMgr.suspend());
    TransactionId txId = null;
    try {
        txMgr.resume(txId);
        fail("expected IllegalStateException");
    } catch (IllegalStateException e) {
    }
    assertTrue(!this.txMgr.exists());
    this.txMgr.begin();
    TransactionId origId = this.txMgr.getTransactionId();
    assertTrue(this.txMgr.exists());
    {
        TransactionId tx = txMgr.suspend();
        assertTrue(!this.txMgr.exists());
        this.txMgr.begin();
        try {
            txMgr.resume(tx);
            fail("expected IllegalStateException");
        } catch (IllegalStateException expected) {
        }
        this.txMgr.rollback();
        assertTrue(!this.txMgr.exists());
        txMgr.resume(tx);
    }
    assertTrue(this.txMgr.exists());
    assertEquals(origId, this.txMgr.getTransactionId());
    this.txMgr.rollback();
}