Example usage for javax.transaction UserTransaction commit

Introduction

In this page you can find the example usage for javax.transaction UserTransaction commit.

Prototype

void commit() throws RollbackException, HeuristicMixedException, HeuristicRollbackException, SecurityException,
        IllegalStateException, SystemException;

Source Link

Document

Complete the transaction associated with the current thread.

Usage

From source file:org.alfresco.module.vti.handler.alfresco.AlfrescoVersionsServiceHandler.java

/**
 * @see org.alfresco.module.vti.handler.VersionsServiceHandler#restoreVersion(java.lang.String, java.lang.String)
 *///from   ww w. j a v  a2  s. c o m
public List<DocumentVersionBean> restoreVersion(String fileName, String fileVersion) {
    if (logger.isDebugEnabled())
        logger.debug("Method with name 'restoreVersion' is started.");

    FileInfo documentFileInfo = pathHelper.resolvePathFileInfo(fileName);

    assertDocument(documentFileInfo);
    UserTransaction tx = transactionService.getUserTransaction(false);
    try {
        tx.begin();

        Map<String, Serializable> props = new HashMap<String, Serializable>(1, 1.0f);
        props.put(Version.PROP_DESCRIPTION, "");
        props.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);

        String alfrescoVersionLabel = VtiUtils.toAlfrescoVersionLabel(fileVersion);
        VersionHistory versionHistory = versionService.getVersionHistory(documentFileInfo.getNodeRef());
        Version version = versionHistory.getVersion(alfrescoVersionLabel);
        if (logger.isDebugEnabled())
            logger.debug("Reverting version '" + fileVersion + " for '" + fileName + "'.");
        versionService.revert(documentFileInfo.getNodeRef(), version);

        if (logger.isDebugEnabled())
            logger.debug("Creating a new version for '" + fileName + "'.");
        versionService.createVersion(documentFileInfo.getNodeRef(), props);

        tx.commit();
    } catch (Exception e) {
        try {
            tx.rollback();
        } catch (Exception tex) {
        }
        if (logger.isDebugEnabled())
            logger.debug("Error: version was not restored. ", e);
        throw new RuntimeException("Version was not restored. May be you don't have appropriate permissions.");
    }

    List<DocumentVersionBean> result = getVersions(documentFileInfo);

    if (logger.isDebugEnabled())
        logger.debug("Method with name 'restoreVersion' is finished.");

    return result;
}

---

From source file:org.alfresco.repo.cache.CacheTest.java

public void testTransactionalCacheWithSingleTxn() throws Throwable {
    // add item to global cache
    TransactionalCache.putSharedCacheValue(backingCache, NEW_GLOBAL_ONE, NEW_GLOBAL_ONE, null);
    TransactionalCache.putSharedCacheValue(backingCache, NEW_GLOBAL_TWO, NEW_GLOBAL_TWO, null);
    TransactionalCache.putSharedCacheValue(backingCache, NEW_GLOBAL_THREE, NEW_GLOBAL_THREE, null);

    TransactionService transactionService = serviceRegistry.getTransactionService();
    UserTransaction txn = transactionService.getUserTransaction();

    try {/*  w ww .  j a  v a2 s .  c om*/
        // begin a transaction
        txn.begin();

        // remove 1 from the cache
        transactionalCache.remove(NEW_GLOBAL_ONE);
        assertFalse("Item was not removed from txn cache", transactionalCache.contains(NEW_GLOBAL_ONE));
        assertNull("Get didn't return null", transactionalCache.get(NEW_GLOBAL_ONE));
        assertTrue("Item was removed from backing cache", backingCache.contains(NEW_GLOBAL_ONE));

        // read 2 from the cache
        assertEquals("Item not read from backing cache", NEW_GLOBAL_TWO,
                transactionalCache.get(NEW_GLOBAL_TWO));
        // Change the backing cache
        TransactionalCache.putSharedCacheValue(backingCache, NEW_GLOBAL_TWO, NEW_GLOBAL_TWO + "-updated", null);
        // Ensure read-committed
        assertEquals("Read-committed not preserved", NEW_GLOBAL_TWO, transactionalCache.get(NEW_GLOBAL_TWO));

        // update 3 in the cache
        transactionalCache.put(UPDATE_TXN_THREE, "XXX");
        assertEquals("Item not updated in txn cache", "XXX", transactionalCache.get(UPDATE_TXN_THREE));
        assertFalse("Item was put into backing cache", backingCache.contains(UPDATE_TXN_THREE));

        // check that the keys collection is correct
        Collection<String> transactionalKeys = transactionalCache.getKeys();
        assertFalse("Transactionally removed item found in keys", transactionalKeys.contains(NEW_GLOBAL_ONE));
        assertTrue("Transactionally added item not found in keys",
                transactionalKeys.contains(UPDATE_TXN_THREE));

        // Register a post-commit cache reader to make sure that nothing blows up if the cache is hit in post-commit
        PostCommitCacheReader listenerReader = new PostCommitCacheReader(transactionalCache, UPDATE_TXN_THREE);
        AlfrescoTransactionSupport.bindListener(listenerReader);

        // Register a post-commit cache reader to make sure that nothing blows up if the cache is hit in post-commit
        PostCommitCacheWriter listenerWriter = new PostCommitCacheWriter(transactionalCache, UPDATE_TXN_FOUR,
                "FOUR");
        AlfrescoTransactionSupport.bindListener(listenerWriter);

        // commit the transaction
        txn.commit();

        // Check the post-commit stressers
        if (listenerReader.e != null) {
            throw listenerReader.e;
        }
        if (listenerWriter.e != null) {
            throw listenerWriter.e;
        }

        // check that backing cache was updated with the in-transaction changes
        assertFalse("Item was not removed from backing cache", backingCache.contains(NEW_GLOBAL_ONE));
        assertNull("Item could still be fetched from backing cache",
                TransactionalCache.getSharedCacheValue(backingCache, NEW_GLOBAL_ONE, null));
        assertEquals("Item not updated in backing cache", "XXX",
                TransactionalCache.getSharedCacheValue(backingCache, UPDATE_TXN_THREE, null));

        // Check that the transactional cache serves get requests
        assertEquals("Transactional cache must serve post-commit get requests", "XXX",
                transactionalCache.get(UPDATE_TXN_THREE));
    } catch (Throwable e) {
        if (txn.getStatus() == Status.STATUS_ACTIVE) {
            txn.rollback();
        }
        throw e;
    }
}

---

From source file:org.alfresco.repo.cache.CacheTest.java

public void testTransactionalCacheDisableSharedCaches() throws Throwable {
    // add item to global cache
    TransactionalCache.putSharedCacheValue(backingCache, NEW_GLOBAL_ONE, NEW_GLOBAL_ONE, null);
    TransactionalCache.putSharedCacheValue(backingCache, NEW_GLOBAL_TWO, NEW_GLOBAL_TWO, null);
    TransactionalCache.putSharedCacheValue(backingCache, NEW_GLOBAL_THREE, NEW_GLOBAL_THREE, null);

    TransactionService transactionService = serviceRegistry.getTransactionService();
    UserTransaction txn = transactionService.getUserTransaction();
    try {/*  ww w  . j  a v  a  2s.  c  om*/
        // begin a transaction
        txn.begin();

        // Go directly past ALL shared caches
        transactionalCache.setDisableSharedCacheReadForTransaction(true);

        // Try to get results in shared caches
        assertNull("Read of mutable shared cache MUST NOT use backing cache",
                transactionalCache.get(NEW_GLOBAL_ONE));
        assertNull("Value should not be in any cache", transactionalCache.get(UPDATE_TXN_THREE));

        // Update the transactional caches
        transactionalCache.put(NEW_GLOBAL_TWO, "An update");
        transactionalCache.put(UPDATE_TXN_THREE, UPDATE_TXN_THREE);

        // Try to get results in shared caches
        assertNull("Read of mutable shared cache MUST NOT use backing cache",
                transactionalCache.get(NEW_GLOBAL_ONE));
        assertEquals("Value should be in transactional cache", "An update",
                transactionalCache.get(NEW_GLOBAL_TWO));
        assertEquals("Value should be in transactional cache", UPDATE_TXN_THREE,
                transactionalCache.get(UPDATE_TXN_THREE));

        txn.commit();

        // Now check that values were not written through for any caches
        assertEquals("Out-of-txn read must return shared value", NEW_GLOBAL_ONE,
                transactionalCache.get(NEW_GLOBAL_ONE));
        assertNull("Value should be removed from shared cache", transactionalCache.get(NEW_GLOBAL_TWO));
        assertEquals("New values must be written to shared cache", UPDATE_TXN_THREE,
                transactionalCache.get(UPDATE_TXN_THREE));
    } catch (Throwable e) {
        if (txn.getStatus() == Status.STATUS_ACTIVE) {
            txn.rollback();
        }
        throw e;
    }
}

---

From source file:org.alfresco.repo.cache.CacheTest.java

/**
 * Tests a straight Ehcache adapter against a transactional cache both in and out
 * of a transaction.  This is done repeatedly, pushing the count up.
 *///from ww  w .  ja  v a  2  s  . com
public void testPerformance() throws Exception {
    for (int i = 0; i < 6; i++) {
        int count = (int) Math.pow(10D, (double) i);

        // test standalone
        long timePlain = runPerformanceTestOnCache(objectCache, count);

        // do transactional cache in a transaction
        TransactionService transactionService = serviceRegistry.getTransactionService();
        UserTransaction txn = transactionService.getUserTransaction();
        txn.begin();
        long timeTxn = runPerformanceTestOnCache(transactionalCache, count);
        long commitStart = System.nanoTime();
        txn.commit();
        long commitEnd = System.nanoTime();
        long commitTime = (commitEnd - commitStart);
        // add this to the cache's performance overhead
        timeTxn += commitTime;

        // report
        System.out.println("Cache performance test: \n" + "   count: " + count + "\n" + "   direct: "
                + timePlain / ((long) count) + " ns\\count \n" + "   transaction: " + timeTxn / ((long) count)
                + " ns\\count");
    }
}

---

From source file:org.alfresco.repo.cache.CacheTest.java

/**
 * Starts off with a <tt>null</tt> in the backing cache and adds a value to the
 * transactional cache.  There should be no problem with this.
 *///ww w .ja v  a  2s.c  o m
public void testNullValue() throws Throwable {
    TransactionService transactionService = serviceRegistry.getTransactionService();
    UserTransaction txn = transactionService.getUserTransaction();

    txn.begin();

    TransactionalCache.putSharedCacheValue(backingCache, "A", null, null);
    transactionalCache.put("A", "AAA");

    try {
        txn.commit();
    } catch (Throwable e) {
        try {
            txn.rollback();
        } catch (Throwable ee) {
        }
        throw e;
    }
}

---

From source file:org.alfresco.repo.cache.CacheTest.java

/**
 * Add 50K objects into the transactional cache and checks that the first object added
 * has been discarded.//ww w  .ja  v  a  2 s  .c o  m
 */
public void testMaxSizeOverrun() throws Exception {
    TransactionService transactionService = serviceRegistry.getTransactionService();
    UserTransaction txn = transactionService.getUserTransaction();
    try {
        txn.begin();

        Object startValue = new Integer(-1);
        String startKey = startValue.toString();
        transactionalCache.put(startKey, startValue);

        assertEquals("The start value isn't correct", startValue, transactionalCache.get(startKey));

        for (int i = 0; i < 205000; i++) {
            Object value = Integer.valueOf(i);
            String key = value.toString();
            transactionalCache.put(key, value);
        }

        // Is the start value here?
        Object checkStartValue = transactionalCache.get(startKey);
        // Now, the cache should no longer contain the first value
        assertNull("The start value didn't drop out of the cache", checkStartValue);

        txn.commit();
    } finally {
        try {
            txn.rollback();
        } catch (Throwable ee) {
        }
    }
}

---

From source file:org.alfresco.repo.cache.CacheTest.java

/** Execute the callback and ensure that the backing cache is left with the expected value */
private void executeAndCheck(RetryingTransactionCallback<Object> callback, boolean readOnly, String key,
        Object expectedValue, boolean mustContainKey) throws Throwable {
    if (expectedValue != null && !mustContainKey) {
        throw new IllegalArgumentException("Why have a value when the key should not be there?");
    }//from w  w w  .j av  a2s . c om

    TransactionService transactionService = serviceRegistry.getTransactionService();
    UserTransaction txn = transactionService.getUserTransaction(readOnly);
    try {
        txn.begin();
        callback.execute();
        txn.commit();
    } finally {
        try {
            txn.rollback();
        } catch (Throwable ee) {
        }
    }
    Object actualValue = TransactionalCache.getSharedCacheValue(backingCache, key, null);
    assertEquals("Backing cache value was not correct", expectedValue, actualValue);
    assertEquals("Backing cache contains(key): ", mustContainKey, backingCache.contains(key));

    // Clear the backing cache to ensure that subsequent tests don't run into existing data
    backingCache.clear();
}

---

From source file:org.alfresco.repo.cache.CacheTest.java

/** Lock values and ensure they don't get modified */
public void testValueLockingInTxn() throws Exception {
    // add item to global cache
    TransactionalCache.putSharedCacheValue(backingCache, DEFINITIVE_TWO, "initial_two", null);
    TransactionalCache.putSharedCacheValue(backingCache, DEFINITIVE_THREE, "initial_three", null);

    TransactionService transactionService = serviceRegistry.getTransactionService();
    UserTransaction txn = transactionService.getUserTransaction();
    try {//from w  w  w . j  a va  2  s . c o m
        // begin a transaction
        txn.begin();

        // Add
        {
            assertEquals(null, transactionalCache.get(DEFINITIVE_ONE));
            // Add it
            transactionalCache.put(DEFINITIVE_ONE, DEFINITIVE_ONE);
            assertFalse("Key should not be locked, yet.", transactionalCache.isValueLocked(DEFINITIVE_ONE));
            // Mark it as definitive
            transactionalCache.lockValue(DEFINITIVE_ONE);
            assertTrue("Key should be locked.", transactionalCache.isValueLocked(DEFINITIVE_ONE));
            // Attempt update
            transactionalCache.put(DEFINITIVE_ONE, "update_one");
            assertEquals("Update values should be locked.", DEFINITIVE_ONE,
                    transactionalCache.get(DEFINITIVE_ONE));
        }

        // Update
        {
            assertEquals("initial_two", transactionalCache.get(DEFINITIVE_TWO));
            // Update it
            transactionalCache.put(DEFINITIVE_TWO, DEFINITIVE_TWO);
            assertFalse("Key should not be locked, yet.", transactionalCache.isValueLocked(DEFINITIVE_TWO));
            // Mark it as definitive
            transactionalCache.lockValue(DEFINITIVE_TWO);
            assertTrue("Key should be locked.", transactionalCache.isValueLocked(DEFINITIVE_TWO));
            // Attempt update
            transactionalCache.put(DEFINITIVE_TWO, "update_two");
            assertEquals("Update values should be locked.", DEFINITIVE_TWO,
                    transactionalCache.get(DEFINITIVE_TWO));
            // Attempt removal
            transactionalCache.remove(DEFINITIVE_TWO);
            assertEquals("Update values should be locked.", DEFINITIVE_TWO,
                    transactionalCache.get(DEFINITIVE_TWO));
        }

        // Remove
        {
            assertEquals("initial_three", transactionalCache.get(DEFINITIVE_THREE));
            // Remove it
            transactionalCache.remove(DEFINITIVE_THREE);
            assertFalse("Key should not be locked, yet.", transactionalCache.isValueLocked(DEFINITIVE_THREE));
            // Mark it as definitive
            transactionalCache.lockValue(DEFINITIVE_THREE);
            assertTrue("Key should be locked.", transactionalCache.isValueLocked(DEFINITIVE_THREE));
            // Attempt update
            transactionalCache.put(DEFINITIVE_THREE, "add_three");
            assertEquals("Removal should be locked.", null, transactionalCache.get(DEFINITIVE_THREE));
        }

        txn.commit();

        // Check post-commit values
        assertEquals("Definitive change not written through.", DEFINITIVE_ONE,
                TransactionalCache.getSharedCacheValue(backingCache, DEFINITIVE_ONE, null));
        assertEquals("Definitive change not written through.", DEFINITIVE_TWO,
                TransactionalCache.getSharedCacheValue(backingCache, DEFINITIVE_TWO, null));
        assertEquals("Definitive change not written through.", null,
                TransactionalCache.getSharedCacheValue(backingCache, DEFINITIVE_THREE, null));
    } finally {
        try {
            txn.rollback();
        } catch (Throwable ee) {
        }
    }
}

---

From source file:org.alfresco.repo.cache.CacheTest.java

public void testTransactionalCacheStatsOnCommit() throws Throwable {
    // add item to global cache
    TransactionalCache.putSharedCacheValue(backingCache, "stats-test1", "v", null);
    TransactionalCache.putSharedCacheValue(backingCache, "stats-test2", "v", null);
    TransactionalCache.putSharedCacheValue(backingCache, "stats-test3", "v", null);

    TransactionService transactionService = serviceRegistry.getTransactionService();
    UserTransaction txn = transactionService.getUserTransaction();

    final long hitsAtStart = cacheStats.count("transactionalCache", OpType.GET_HIT);
    final long missesAtStart = cacheStats.count("transactionalCache", OpType.GET_MISS);
    final long putsAtStart = cacheStats.count("transactionalCache", OpType.PUT);
    final long removesAtStart = cacheStats.count("transactionalCache", OpType.REMOVE);
    final long clearsAtStart = cacheStats.count("transactionalCache", OpType.CLEAR);

    try {// w  ww . ja  va 2  s  .  c om
        // begin a transaction
        txn.begin();

        // Perform some puts
        transactionalCache.put("stats-test4", "v");
        transactionalCache.put("stats-test5", "v");
        transactionalCache.put("stats-test6", "v");
        transactionalCache.put("stats-test7", "v");
        transactionalCache.put("stats-test8", "v");

        // Perform some gets...
        // hits
        transactionalCache.get("stats-test3");
        transactionalCache.get("stats-test2");
        transactionalCache.get("stats-test1");
        // repeated hits won't touch the shared cache
        transactionalCache.get("stats-test2");
        transactionalCache.get("stats-test1");
        // misses - not yet committed
        transactionalCache.get("stats-miss1");
        transactionalCache.get("stats-miss2");
        transactionalCache.get("stats-miss3");
        transactionalCache.get("stats-miss4");
        // repeated misses won't touch the shared cache
        transactionalCache.get("stats-miss2");
        transactionalCache.get("stats-miss3");

        // Perform some removals
        transactionalCache.remove("stats-test1");
        transactionalCache.remove("stats-test2");
        transactionalCache.remove("stats-test3");
        transactionalCache.remove("stats-test9");
        transactionalCache.remove("stats-test10");
        transactionalCache.remove("stats-test11");
        transactionalCache.remove("stats-test12");
        transactionalCache.remove("stats-test13");

        // Check nothing has changed yet - changes not written through until commit or rollback
        assertEquals(hitsAtStart, cacheStats.count("transactionalCache", OpType.GET_HIT));
        assertEquals(missesAtStart, cacheStats.count("transactionalCache", OpType.GET_MISS));
        assertEquals(putsAtStart, cacheStats.count("transactionalCache", OpType.PUT));
        assertEquals(removesAtStart, cacheStats.count("transactionalCache", OpType.REMOVE));
        assertEquals(clearsAtStart, cacheStats.count("transactionalCache", OpType.CLEAR));

        // commit the transaction
        txn.commit();

        // TODO: remove is called twice for each remove (in beforeCommit and afterCommit) - check this is correct.
        assertEquals(removesAtStart + 16, cacheStats.count("transactionalCache", OpType.REMOVE));
        assertEquals(hitsAtStart + 3, cacheStats.count("transactionalCache", OpType.GET_HIT));
        assertEquals(missesAtStart + 4, cacheStats.count("transactionalCache", OpType.GET_MISS));
        assertEquals(putsAtStart + 5, cacheStats.count("transactionalCache", OpType.PUT));
        // Performing a clear would affect the other stats, so a separate test is required.
        assertEquals(clearsAtStart + 0, cacheStats.count("transactionalCache", OpType.CLEAR));
    } catch (Throwable e) {
        if (txn.getStatus() == Status.STATUS_ACTIVE) {
            txn.rollback();
        }
        throw e;
    }
}

---

From source file:org.alfresco.repo.cache.CacheTest.java

public void testTransactionalCacheStatsDisabled() throws Throwable {
    // add item to global cache
    TransactionalCache.putSharedCacheValue(backingCacheNoStats, "stats-test1", "v", null);
    TransactionalCache.putSharedCacheValue(backingCacheNoStats, "stats-test2", "v", null);
    TransactionalCache.putSharedCacheValue(backingCacheNoStats, "stats-test3", "v", null);

    TransactionService transactionService = serviceRegistry.getTransactionService();
    UserTransaction txn = transactionService.getUserTransaction();

    for (OpType opType : OpType.values()) {
        try {//from w w w  . j  a va 2  s  . c  om
            cacheStats.count("transactionalCacheNoStats", opType);
            fail("Expected NoStatsForCache error.");
        } catch (NoStatsForCache e) {
            // Good
        }
    }

    try {
        // begin a transaction
        txn.begin();

        // Perform some puts
        transactionalCacheNoStats.put("stats-test4", "v");
        transactionalCache.put("stats-test5", "v");
        transactionalCache.put("stats-test6", "v");
        transactionalCache.put("stats-test7", "v");
        transactionalCache.put("stats-test8", "v");

        // Perform some gets...
        // hits
        transactionalCache.get("stats-test3");
        transactionalCache.get("stats-test2");
        transactionalCache.get("stats-test1");
        // repeated hits won't touch the shared cache
        transactionalCache.get("stats-test2");
        transactionalCache.get("stats-test1");
        // misses - not yet committed
        transactionalCache.get("stats-miss1");
        transactionalCache.get("stats-miss2");
        transactionalCache.get("stats-miss3");
        transactionalCache.get("stats-miss4");
        // repeated misses won't touch the shared cache
        transactionalCache.get("stats-miss2");
        transactionalCache.get("stats-miss3");

        // Perform some removals
        transactionalCache.remove("stats-test1");
        transactionalCache.remove("stats-test2");
        transactionalCache.remove("stats-test3");
        transactionalCache.remove("stats-test9");
        transactionalCache.remove("stats-test10");
        transactionalCache.remove("stats-test11");
        transactionalCache.remove("stats-test12");
        transactionalCache.remove("stats-test13");

        // Check nothing has changed - changes not written through until commit or rollback
        for (OpType opType : OpType.values()) {
            try {
                cacheStats.count("transactionalCacheNoStats", opType);
                fail("Expected NoStatsForCache error.");
            } catch (NoStatsForCache e) {
                // Good
            }
        }

        // commit the transaction
        txn.commit();

        // Post-commit, nothing should have changed.
        for (OpType opType : OpType.values()) {
            try {
                cacheStats.count("transactionalCacheNoStats", opType);
                fail("Expected NoStatsForCache error.");
            } catch (NoStatsForCache e) {
                // Good
            }
        }
    } catch (Throwable e) {
        if (txn.getStatus() == Status.STATUS_ACTIVE) {
            txn.rollback();
        }
        throw e;
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• »