Example usage for org.springframework.transaction TransactionStatus isCompleted

List of usage examples for org.springframework.transaction TransactionStatus isCompleted

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.transaction.*
  5. TransactionStatus
  6. isCompleted

Introduction

In this page you can find the example usage for org.springframework.transaction TransactionStatus isCompleted.

Prototype

boolean isCompleted();

Source Link

Document

Return whether this transaction is completed, that is, whether it has already been committed or rolled back.

Usage

From source file:org.caratarse.auth.services.plugins.transactions.OpenTransactionPlugin.java

@Override
public void process(Request request, Response response) {
    TransactionStatus status = transaction.get();
    if (!status.isRollbackOnly()) {
        if (!status.isCompleted()) {
            transactionManager.commit(status);
        }// w w  w .j  av  a2 s .c o m
    } else {
        if (!status.isCompleted()) {
            transactionManager.rollback(status);
        }
    }
}

From source file:org.bitsofinfo.util.address.usps.ais.store.jpa.JPAStore.java

private Copyright processCopyright(Copyright copyright) throws StoreException {
    Copyright c = this.entityMgr.find(Copyright.class, copyright.getIdentifier());

    if (c == null) {
        DefaultTransactionDefinition td = new DefaultTransactionDefinition();
        td.setName("Process copyright");
        td.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

        TransactionStatus txs = this.transactionManager.getTransaction(td);

        try {//from w w  w  .jav a  2  s  .c  o m
            this.saveRecord(copyright);
            this.transactionManager.commit(txs);

        } catch (DataIntegrityViolationException e) {
            if (!txs.isCompleted()) {
                this.transactionManager.rollback(txs);
            }

            // ignore this, it is fine, some other load beat us to it
            c = this.entityMgr.find(Copyright.class, copyright.getIdentifier());
        }

        c = copyright;
    }

    return c;
}

From source file:org.drools.container.spring.beans.persistence.DroolsSpringTransactionManager.java

/**
 * Borrowed from Seam/*w w  w  .ja  v a  2s .c o m*/
 */
public int getStatus() {
    if (ptm == null) {
        return TransactionManager.STATUS_NO_TRANSACTION;
    }

    logger.debug("Current TX name (According to TransactionSynchronizationManager) : "
            + TransactionSynchronizationManager.getCurrentTransactionName());
    if (TransactionSynchronizationManager.isActualTransactionActive()) {
        TransactionStatus transaction = null;
        try {
            if (currentTransaction == null) {
                transaction = ptm.getTransaction(td);
                if (transaction.isNewTransaction()) {
                    return TransactionManager.STATUS_COMMITTED;
                }
            } else {
                transaction = currentTransaction;
            }
            logger.debug("Current TX: " + transaction);
            // If SynchronizationManager thinks it has an active transaction but
            // our transaction is a new one
            // then we must be in the middle of committing
            if (transaction.isCompleted()) {
                if (transaction.isRollbackOnly()) {
                    return TransactionManager.STATUS_ROLLEDBACK;
                }
                return TransactionManager.STATUS_COMMITTED;
            } else {
                // Using the commented-out code in means that if rollback with this manager,
                //  I always have to catch and check the exception 
                //  because ROLLEDBACK can mean both "rolled back" and "rollback only".
                // if ( transaction.isRollbackOnly() ) {
                //     return TransactionManager.STATUS_ROLLEDBACK;
                // }

                return TransactionManager.STATUS_ACTIVE;
            }
        } finally {
            if (currentTransaction == null) {
                ptm.commit(transaction);
            }
        }
    }
    return TransactionManager.STATUS_NO_TRANSACTION;
}

From source file:com.eclecticlogic.pedal.impl.TransactionImpl.java

public <R> R _exec(Function<Context, R> runner) {
    TransactionStatus status = null;
    try {/*from  w w w.  j a  v  a 2  s  .co m*/
        status = getPlatformTransactionManager().getTransaction(getTransactionDefinition());
        logger.trace("start: new = {}", status.isNewTransaction() ? "yes" : "no");

        Context context = new ContextImpl();

        R retval = runner.apply(context);

        if (status.isRollbackOnly()) {
            getPlatformTransactionManager().rollback(status);
            logger.trace("rollback");
        } else {
            getPlatformTransactionManager().commit(status);
            logger.trace("commit");
        }

        return retval;
    } catch (RuntimeException e) {
        if (status != null && status.isCompleted() == false) {
            getPlatformTransactionManager().rollback(status);
            logger.trace("rollback");
        }
        throw e;
    }
}

From source file:org.drools.container.spring.beans.persistence.HumanTaskSpringTransactionManager.java

/**
 * Borrowed from Seam//from   w  w  w . j  a v a2  s .c o m
 */
public int getStatus() {
    if (ptm == null) {
        return TransactionManager.STATUS_NO_TRANSACTION;
    }

    // logger.debug( "Current TX name (According to TransactionSynchronizationManager) : " + TransactionSynchronizationManager.getCurrentTransactionName() );
    if (TransactionSynchronizationManager.isActualTransactionActive()) {
        TransactionStatus transaction = null;
        boolean commitNewTransaction = false;
        try {
            if (currentTransaction.size() == 0) {
                transaction = ptm.getTransaction(td);
                currentTransaction.push(transaction);
                commitNewTransaction = true;
                if (transaction.isNewTransaction()) {
                    return TransactionManager.STATUS_COMMITTED;
                }
            } else {
                transaction = currentTransaction.peek();
            }
            logger.debug("Current TX: " + transaction);
            // If SynchronizationManager thinks it has an active transaction but
            // our transaction is a new one
            // then we must be in the middle of committing
            if (transaction.isCompleted()) {
                if (transaction.isRollbackOnly()) {
                    return TransactionManager.STATUS_ROLLEDBACK;
                }
                return TransactionManager.STATUS_COMMITTED;
            } else {
                if (transaction.isRollbackOnly()) {
                    return 5;
                }
                return TransactionManager.STATUS_ACTIVE;
            }
        } finally {
            if (commitNewTransaction) {
                ptm.commit(transaction);
            }
        }
    }
    return TransactionManager.STATUS_NO_TRANSACTION;
}

From source file:de.tudarmstadt.ukp.clarin.webanno.webapp.migration.FixCoreferenceFeatures.java

private void doMigration() {
    DefaultTransactionDefinition def = new DefaultTransactionDefinition();
    def.setName("migrationRoot");
    def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

    TransactionStatus status = null;/*from  www  .  ja  va 2 s .c  o m*/
    try {
        status = txManager.getTransaction(def);
        Query q = entityManager.createQuery("UPDATE AnnotationFeature \n" + "SET type = :fixedType \n"
                + "WHERE type = :oldType \n" + "AND name in (:featureNames)");

        // This condition cannot be applied: 
        //   "AND layer.type = :layerType"
        //   q.setParameter("layerType", CHAIN_TYPE);
        // http://stackoverflow.com/questions/16506759/hql-is-generating-incomplete-cross-join-on-executeupdate
        // However, the risk that the migration upgrades the wrong featuers is still very low
        // even without this additional condition

        q.setParameter("featureNames", Arrays.asList(COREFERENCE_RELATION_FEATURE, COREFERENCE_TYPE_FEATURE));
        q.setParameter("oldType", "de.tudarmstadt.ukp.dkpro.core.api.coref.type.Coreference");
        q.setParameter("fixedType", CAS.TYPE_NAME_STRING);
        int changed = q.executeUpdate();
        if (changed > 0) {
            log.info("DATABASE UPGRADE PERFORMED: [" + changed + "] coref chain features had their type fixed");
        }
        txManager.commit(status);
    } finally {
        if (status != null && !status.isCompleted()) {
            txManager.rollback(status);
        }
    }
}

From source file:com.jaspersoft.jasperserver.api.metadata.common.service.impl.hibernate.HibernateRepositoryCache.java

protected CachedItem getCachedItem(ExecutionContext context, FileResource resource,
        RepositoryCacheableItem cacheableItem) {
    if (log.isDebugEnabled()) {
        log.debug("Looking in repository cache \"" + cacheableItem.getCacheName() + "\" for resource \""
                + resource.getURIString() + "\", version " + resource.getVersion() + "\", version date "
                + resource.getCreationDate());
    }/*from  w  ww .j a v  a  2s .c om*/

    LockHandle lock = lock(resource, cacheableItem);

    //Because of bug #25373 we need to manually manipulate with transaction:
    //open it AFTER thread acquires lock
    //and commit BEFORE thread releases the lock.
    TransactionStatus transaction = null;

    try {
        transaction = transactionManager.getTransaction(
                new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRES_NEW));

        CachedItem cachedItem = getCachedItem(resource.getURIString(), cacheableItem, true);
        if (cachedItem == null || cachedItem.getVersion() < resource.getVersion()
                || cachedItem.getVersionDate() == null
                || cachedItem.getVersionDate().before(resource.getCreationDate())) {
            if (resource.isReference()) {
                cachedItem = saveRefence(context, resource, cachedItem, cacheableItem);
            } else {
                cachedItem = saveData(context, resource, cachedItem, cacheableItem);
            }
        } else if (resource.isReference()) {
            //load the reference to force updates
            FileResource ref = (FileResource) repository.getResource(context, resource.getReferenceURI());
            CachedItem refItem = getCachedItem(context, ref, cacheableItem);
            if (!refItem.equals(cachedItem.getReference())) {
                updateReference(cachedItem, refItem);
            }
        }

        transactionManager.commit(transaction);
        return cachedItem;
    } finally {
        if (transaction != null && !transaction.isCompleted()) {
            try {
                transactionManager.rollback(transaction);
            } catch (Exception e) {
                // suppress exception throwing
                log.error(e.getMessage(), e);
            }
        }

        unlock(lock);
    }
}

From source file:com.jaspersoft.jasperserver.api.metadata.user.service.impl.RoleManagerServiceImpl.java

public PaginatedOperationResult getUsersWithoutRole(final ExecutionContext context, final String roleName,
        final String userName, Set assignedUserNameSet, Set unassignedUserNameSet, int firstResult,
        int maxResults) {

    PaginatedOperationResult result;/*from   w  w  w  .j a  va  2s .c o  m*/

    TransactionStatus transaction = null;

    try {

        // start transaction
        transaction = transactionManager.getTransaction(
                new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRES_NEW));

        userService.assignUsers(context, roleName, assignedUserNameSet);
        userService.unassignUsers(context, roleName, unassignedUserNameSet);

        getHibernateTemplate().flush();

        result = PaginationHelper.paginatedGetOperationResult(firstResult, maxResults,
                new PaginationHelper.JasperService() {
                    public List getResultList(int firstResult, int maxResults) {
                        return userService.getUsersWithoutRole(context, roleName, userName, firstResult,
                                maxResults);
                    }

                    public int getResultCount() {
                        return userService.getUsersCountWithoutRole(context, roleName, userName);
                    }
                });

    } finally {
        if (transaction != null && !transaction.isCompleted()) {
            try {
                // rollback
                transactionManager.rollback(transaction);
            } catch (Exception e) {
                // suppress exception
            }
        }
    }

    return result;
}

From source file:com.jaspersoft.jasperserver.api.metadata.user.service.impl.RoleManagerServiceImpl.java

public PaginatedOperationResult getUsersWithRole(final ExecutionContext context, final String roleName,
        final String userName, Set assignedUserNameSet, Set unassignedUserNameSet, int firstResult,
        int maxResults) {

    PaginatedOperationResult result;// ww  w .ja va  2 s.c  o m

    TransactionStatus transaction = null;
    try {

        // start transaction
        transaction = transactionManager.getTransaction(
                new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRES_NEW));

        userService.assignUsers(context, roleName, assignedUserNameSet);
        userService.unassignUsers(context, roleName, unassignedUserNameSet);

        getHibernateTemplate().flush();

        result = PaginationHelper.paginatedGetOperationResult(firstResult, maxResults,
                new PaginationHelper.JasperService() {
                    public List getResultList(int firstResult, int maxResults) {
                        return userService.getUsersWithRole(context, roleName, userName, firstResult,
                                maxResults);
                    }

                    public int getResultCount() {
                        return userService.getUsersCountWithRole(context, roleName, userName);
                    }
                });

    } finally {
        if (transaction != null && !transaction.isCompleted()) {
            try {
                // rollback
                transactionManager.rollback(transaction);
            } catch (Exception e) {
                // suppress exception
            }
        }
    }

    return result;
}

From source file:hoot.services.controllers.job.ProcessJobRunnable.java

@Override
public void run() {
    ApplicationContext appContext = ApplicationContextUtils.getApplicationContext();
    PlatformTransactionManager txManager = appContext.getBean("transactionManager",
            PlatformTransactionManager.class);

    TransactionStatus transactionStatus = null;
    try {/*  ww w .ja  v  a  2s  .c  o  m*/
        transactionStatus = txManager.getTransaction(null);
        processCommand();
        txManager.commit(transactionStatus);
    } catch (Exception e) {
        if ((transactionStatus != null) && !transactionStatus.isCompleted()) {
            txManager.rollback(transactionStatus);
        }
        logger.error("Error executing job with ID = {}", jobId, e);
    }
}