Java Examples for org.springframework.transaction.support.TransactionSynchronizationManager

The following java examples will help you to understand the usage of org.springframework.transaction.support.TransactionSynchronizationManager. These source code samples are taken from different open source projects.

Example 1
Project: btpka3.github.com-master  File: DataSourceKeyAdvice.java View source code
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
    @SuppressWarnings("unchecked") Stack<String> keyStack = (Stack<String>) TransactionSynchronizationManager.getResource(RoutingDataSourceImpl.DATASOURCE_RSC_KEY);
    if (keyStack == null) {
        keyStack = new Stack<String>();
        TransactionSynchronizationManager.bindResource(RoutingDataSourceImpl.DATASOURCE_RSC_KEY, keyStack);
    }
    Method targetMethod = invocation.getMethod();
    String key = keyResolver.resolveKey(invocation.getThis(), targetMethod, invocation.getArguments());
    if (keyMapper != null) {
        key = keyMapper.mapping(key);
    }
    // 防止跨数�库进行事务
    if (key != null && throwExceptionWhenCrossDb) {
        for (int i = 0; i < keyStack.size(); i++) {
            String iKey = keyStack.get(i);
            if (iKey != null && !iKey.equals(key)) {
                throw new CrossDbTransNotSupportedException();
            }
        }
    }
    if (key == null && !allowNullKey) {
        throw new DataSouceKeyNotFoundException("Could not determin data source key for method : " + targetMethod);
    }
    if (logger.isDebugEnabled()) {
        logger.debug("using '{}' as data source key for method : {}", key, targetMethod);
    }
    keyStack.push(key);
    try {
        return invocation.proceed();
    } finally {
        keyStack.pop();
    }
}
Example 2
Project: geoserver-old-master  File: HibUtil.java View source code
public static void setUpSession(SessionFactory sessionFactory, boolean clearActiveTX) {
    if (clearActiveTX) {
        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            try {
                TransactionSynchronizationManager.unbindResource(sessionFactory);
            } catch (IllegalStateException e) {
            }
            TransactionSynchronizationManager.clearSynchronization();
        }
    }
    setUpSession(sessionFactory);
}
Example 3
Project: geoserver_trunk-master  File: HibUtil.java View source code
public static void setUpSession(SessionFactory sessionFactory, boolean clearActiveTX) {
    if (clearActiveTX) {
        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            try {
                TransactionSynchronizationManager.unbindResource(sessionFactory);
            } catch (IllegalStateException e) {
            }
            TransactionSynchronizationManager.clearSynchronization();
        }
    }
    setUpSession(sessionFactory);
}
Example 4
Project: apollo-master  File: EntityManagerUtil.java View source code
/**
   * close the entity manager.
   * Use it with caution! This is only intended for use with async request, which Spring won't
   * close the entity manager until the async request is finished.
   */
public void closeEntityManager() {
    EntityManagerHolder emHolder = (EntityManagerHolder) TransactionSynchronizationManager.getResource(getEntityManagerFactory());
    if (emHolder == null) {
        return;
    }
    logger.debug("Closing JPA EntityManager in EntityManagerUtil");
    EntityManagerFactoryUtils.closeEntityManager(emHolder.getEntityManager());
}
Example 5
Project: bbs.newgxu.cn-master  File: JPAEmlookupRegister.java View source code
public EntityManager lookupEntityManager() {
    EntityManagerFactory emf = lookupEntityManagerFactory(event.getServletContext());
    if (TransactionSynchronizationManager.hasResource(emf)) {
        EntityManagerHolder holder = (EntityManagerHolder) TransactionSynchronizationManager.getResource(emf);
        EntityManager s = holder.getEntityManager();
        return s;
    } else {
        //					return lookupEntityManagerFactory(event.getServletContext()).createEntityManager();
        return null;
    }
}
Example 6
Project: com.revolsys.open-master  File: Transaction.java View source code
public static void afterCommit(final Runnable runnable) {
    if (runnable != null) {
        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            final RunnableAfterCommit synchronization = new RunnableAfterCommit(runnable);
            TransactionSynchronizationManager.registerSynchronization(synchronization);
        } else {
            runnable.run();
        }
    }
}
Example 7
Project: geoserver-master  File: HibUtil.java View source code
public static void setUpSession(SessionFactory sessionFactory, boolean clearActiveTX) {
    if (clearActiveTX) {
        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            try {
                TransactionSynchronizationManager.unbindResource(sessionFactory);
            } catch (IllegalStateException e) {
            }
            TransactionSynchronizationManager.clearSynchronization();
        }
    }
    setUpSession(sessionFactory);
}
Example 8
Project: lemon-master  File: SpringSessionContext.java View source code
public Session currentSession() throws HibernateException {
    Object value = TransactionSynchronizationManager.getResource(this.sessionFactory);
    if (value instanceof Session) {
        return (Session) value;
    } else if (value instanceof SessionHolder) {
        SessionHolder sessionHolder = (SessionHolder) value;
        Session session = sessionHolder.getSession();
        if (TransactionSynchronizationManager.isSynchronizationActive() && !sessionHolder.isSynchronizedWithTransaction()) {
            TransactionSynchronizationManager.registerSynchronization(new SpringSessionSynchronization(sessionHolder, this.sessionFactory));
            sessionHolder.setSynchronizedWithTransaction(true);
            // Switch to FlushMode.AUTO, as we have to assume a thread-bound Session
            // with FlushMode.MANUAL, which needs to allow flushing within the transaction.
            FlushMode flushMode = session.getFlushMode();
            if (FlushMode.isManualFlushMode(flushMode) && !TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
                session.setFlushMode(FlushMode.AUTO);
                sessionHolder.setPreviousFlushMode(flushMode);
            }
        }
        return session;
    } else {
        throw new HibernateException("No Session found for current thread");
    }
}
Example 9
Project: pedal-tx-master  File: JPATransactionWrapper.java View source code
@Override
protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
    super.prepareSynchronization(status, definition);
    if (status.isNewTransaction()) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapterData());
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapterTask());
    }
}
Example 10
Project: spring-amqp-master  File: RabbitTransactionManager.java View source code
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) {
    if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
        throw new InvalidIsolationLevelException("AMQP does not support an isolation level concept");
    }
    RabbitTransactionObject txObject = (RabbitTransactionObject) transaction;
    RabbitResourceHolder resourceHolder = null;
    try {
        resourceHolder = ConnectionFactoryUtils.getTransactionalResourceHolder(getConnectionFactory(), true);
        if (logger.isDebugEnabled()) {
            logger.debug("Created AMQP transaction on channel [" + resourceHolder.getChannel() + "]");
        }
        // resourceHolder.declareTransactional();
        txObject.setResourceHolder(resourceHolder);
        txObject.getResourceHolder().setSynchronizedWithTransaction(true);
        int timeout = determineTimeout(definition);
        if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
            txObject.getResourceHolder().setTimeoutInSeconds(timeout);
        }
        TransactionSynchronizationManager.bindResource(getConnectionFactory(), txObject.getResourceHolder());
    } catch (AmqpException ex) {
        if (resourceHolder != null) {
            ConnectionFactoryUtils.releaseResources(resourceHolder);
        }
        throw new CannotCreateTransactionException("Could not create AMQP transaction", ex);
    }
}
Example 11
Project: zk-master  File: SpringTransactionSynchronizationListener.java View source code
//-- utilities --//
private void getThreadLocals() {
    try {
        Class cls = Classes.forNameByThread("org.springframework.transaction.support.TransactionSynchronizationManager");
        _threadLocals = new Object[7];
        _threadLocals[0] = getThreadLocal(cls, "resources").get();
        _threadLocals[1] = getThreadLocal(cls, "synchronizations").get();
        _threadLocals[2] = getThreadLocal(cls, "currentTransactionName").get();
        _threadLocals[3] = getThreadLocal(cls, "currentTransactionReadOnly").get();
        _threadLocals[4] = getThreadLocal(cls, "actualTransactionActive").get();
        //20070907, Henri Chen: bug 1785457, hibernate3 might not used
        try {
            cls = Classes.forNameByThread("org.springframework.orm.hibernate3.SessionFactoryUtils");
            _threadLocals[5] = getThreadLocal(cls, "deferredCloseHolder").get();
        } catch (ClassNotFoundException ex) {
        }
        cls = Classes.forNameByThread("org.springframework.transaction.interceptor.TransactionAspectSupport");
        //1.2.8 currentTransactionInfo
        try {
            _threadLocals[6] = getThreadLocal(cls, "transactionInfoHolder").get();
        } catch (SystemException ex) {
            if (ex.getCause() instanceof NoSuchFieldException) {
                _threadLocals[6] = getThreadLocal(cls, "currentTransactionInfo").get();
            } else {
                throw ex;
            }
        }
    } catch (ClassNotFoundException ex) {
        throw UiException.Aide.wrap(ex);
    }
}
Example 12
Project: effectivejava-master  File: DataSourceUtils.java View source code
/**
	 * Actually obtain a JDBC Connection from the given DataSource.
	 * Same as {@link #getConnection}, but throwing the original SQLException.
	 * <p>Is aware of a corresponding Connection bound to the current thread, for example
	 * when using {@link DataSourceTransactionManager}. Will bind a Connection to the thread
	 * if transaction synchronization is active (e.g. if in a JTA transaction).
	 * <p>Directly accessed by {@link TransactionAwareDataSourceProxy}.
	 * @param dataSource the DataSource to obtain Connections from
	 * @return a JDBC Connection from the given DataSource
	 * @throws SQLException if thrown by JDBC methods
	 * @see #doReleaseConnection
	 */
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
    Assert.notNull(dataSource, "No DataSource specified");
    ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
    if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
        conHolder.requested();
        if (!conHolder.hasConnection()) {
            logger.debug("Fetching resumed JDBC Connection from DataSource");
            conHolder.setConnection(dataSource.getConnection());
        }
        return conHolder.getConnection();
    }
    // Else we either got no holder or an empty thread-bound holder here.
    logger.debug("Fetching JDBC Connection from DataSource");
    Connection con = dataSource.getConnection();
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        logger.debug("Registering transaction synchronization for JDBC Connection");
        // Use same Connection for further JDBC actions within the transaction.
        // Thread-bound object will get removed by synchronization at transaction completion.
        ConnectionHolder holderToUse = conHolder;
        if (holderToUse == null) {
            holderToUse = new ConnectionHolder(con);
        } else {
            holderToUse.setConnection(con);
        }
        holderToUse.requested();
        TransactionSynchronizationManager.registerSynchronization(new ConnectionSynchronization(holderToUse, dataSource));
        holderToUse.setSynchronizedWithTransaction(true);
        if (holderToUse != conHolder) {
            TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
        }
    }
    return con;
}
Example 13
Project: spring-framework-2.5.x-master  File: DataSourceUtils.java View source code
/**
	 * Actually obtain a JDBC Connection from the given DataSource.
	 * Same as {@link #getConnection}, but throwing the original SQLException.
	 * <p>Is aware of a corresponding Connection bound to the current thread, for example
	 * when using {@link DataSourceTransactionManager}. Will bind a Connection to the thread
	 * if transaction synchronization is active (e.g. if in a JTA transaction).
	 * <p>Directly accessed by {@link TransactionAwareDataSourceProxy}.
	 * @param dataSource the DataSource to obtain Connections from
	 * @return a JDBC Connection from the given DataSource
	 * @throws SQLException if thrown by JDBC methods
	 * @see #doReleaseConnection
	 */
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
    Assert.notNull(dataSource, "No DataSource specified");
    ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
    if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
        conHolder.requested();
        if (!conHolder.hasConnection()) {
            logger.debug("Fetching resumed JDBC Connection from DataSource");
            conHolder.setConnection(dataSource.getConnection());
        }
        return conHolder.getConnection();
    }
    // Else we either got no holder or an empty thread-bound holder here.
    logger.debug("Fetching JDBC Connection from DataSource");
    Connection con = dataSource.getConnection();
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        logger.debug("Registering transaction synchronization for JDBC Connection");
        // Use same Connection for further JDBC actions within the transaction.
        // Thread-bound object will get removed by synchronization at transaction completion.
        ConnectionHolder holderToUse = conHolder;
        if (holderToUse == null) {
            holderToUse = new ConnectionHolder(con);
        } else {
            holderToUse.setConnection(con);
        }
        holderToUse.requested();
        TransactionSynchronizationManager.registerSynchronization(new ConnectionSynchronization(holderToUse, dataSource));
        holderToUse.setSynchronizedWithTransaction(true);
        if (holderToUse != conHolder) {
            TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
        }
    }
    return con;
}
Example 14
Project: 1ed-master  File: SpringUtil.java View source code
/**
	 * Deixa a Session viva nesta Thread. Mesma coisa que uma Thread de uma
	 * requisição web utilizando o filtro "OpenSessionInViewFilter"
	 */
public Session openSession() {
    if (ctx != null) {
        txManager = (HibernateTransactionManager) ctx.getBean("transactionManager");
        SessionFactory sessionFactory = txManager.getSessionFactory();
        session = sessionFactory.openSession();
        TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
    }
    return session;
}
Example 15
Project: Broadleaf-eCommerce-master  File: IdentityExecutionUtils.java View source code
private static void activateSession() {
    Map<Object, Object> resourceMap = TransactionSynchronizationManager.getResourceMap();
    for (Map.Entry<Object, Object> entry : resourceMap.entrySet()) {
        if (entry.getKey() instanceof EntityManagerFactory && entry.getValue() instanceof EntityManagerHolder) {
            ((HibernateEntityManager) ((EntityManagerHolder) entry.getValue()).getEntityManager()).getSession();
        }
    }
}
Example 16
Project: BroadleafCommerce-master  File: IdentityExecutionUtils.java View source code
private static void activateSession() {
    Map<Object, Object> resourceMap = TransactionSynchronizationManager.getResourceMap();
    for (Map.Entry<Object, Object> entry : resourceMap.entrySet()) {
        if (entry.getKey() instanceof EntityManagerFactory && entry.getValue() instanceof EntityManagerHolder) {
            ((HibernateEntityManager) ((EntityManagerHolder) entry.getValue()).getEntityManager()).getSession();
        }
    }
}
Example 17
Project: commerce-master  File: IdentityExecutionUtils.java View source code
private static void activateSession() {
    Map<Object, Object> resourceMap = TransactionSynchronizationManager.getResourceMap();
    for (Map.Entry<Object, Object> entry : resourceMap.entrySet()) {
        if (entry.getKey() instanceof EntityManagerFactory && entry.getValue() instanceof EntityManagerHolder) {
            ((HibernateEntityManager) ((EntityManagerHolder) entry.getValue()).getEntityManager()).getSession();
        }
    }
}
Example 18
Project: cosmo-master  File: AbstractHibernateDaoTestCase.java View source code
/**
     * Override onteadDownAfterTransaction.
     * @throws Exception - if something is wrong this exception is thrown.
     */
@AfterTransaction
public void onTearDownAfterTransaction() throws Exception {
    // Get a reference to the Session and bind it to the TransactionManager
    SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
    Session s = holder.getSession();
    TransactionSynchronizationManager.unbindResource(sessionFactory);
    //  s.clear();
    //   clearSession();
    SessionFactoryUtils.closeSession(s);
}
Example 19
Project: openmentor-master  File: BaseDAOTestCase.java View source code
protected void endTestTransaction() {
    if (log.isDebugEnabled()) {
        log.debug("Ending test transaction: session: " + session);
    }
    try {
        session.flush();
    } catch (Exception e) {
    }
    ;
    TransactionSynchronizationManager.unbindResource(sessionFactory);
    SessionFactoryUtils.releaseSession(session, sessionFactory);
    session = null;
}
Example 20
Project: Phynixx-master  File: JtaConnectionHolderSupportAspect.java View source code
@Before("@annotation(org.csc.phynixx.spring.jta.JtaConnectionHolderSupport)")
public void before() throws Throwable {
    System.out.println("Actual Transaction Active for JtaConnectionHolderSynchronization" + TransactionSynchronizationManager.isActualTransactionActive());
    if (!TransactionSynchronizationManager.isActualTransactionActive()) {
        return;
    }
    Object connectionFactory = this.getConnectionFactory();
    if (TransactionSynchronizationManager.hasResource(connectionFactory)) {
        return;
    }
    ResourceHolder connectionHolder = this.getConnectionHolder();
    TransactionSynchronizationManager.bindResource(connectionFactory, connectionHolder);
    /**
		 * support die LifeCycle of then binding
		 */
    JtaConnectionHolderSynchronization<H, K> synchronization = new JtaConnectionHolderSynchronization(connectionHolder, connectionFactory);
    TransactionSynchronizationManager.registerSynchronization(synchronization);
    // Hole aktuelle Connection
    System.out.println("*************************");
}
Example 21
Project: retry-master  File: RetryOperationsInterceptorTests.java View source code
public void doTansactional() throws Exception {
    if (TransactionSynchronizationManager.isActualTransactionActive() && !enteredTransaction) {
        transactionCount++;
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            public void beforeCompletion() {
                enteredTransaction = false;
            }
        });
        enteredTransaction = true;
    }
    count++;
    if (count == 1) {
        throw new RuntimeException("Rollback please");
    }
}
Example 22
Project: spring-boot-starter-batch-web-master  File: BatchMetricsImpl.java View source code
@Override
public void increment(String metricName, Long value) {
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        initializeMetricContainerAndRegisterTransactionSynchronizationIfNecessary();
        metricContainer.get().metrics.add(Pair.of(metricName, value));
    } else {
        incrementNonTransactional(metricName, value);
    }
}
Example 23
Project: spring-framework-issues-master  File: BookServiceImpl.java View source code
@Override
public void triggerCreatePostCommit(final Book book) {
    // Lookup book to make sure we are using the enitity manager/repository
    lookupBookById(book.getId());
    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

        @Override
        public void afterCompletion(int status) {
            if (status == TransactionSynchronization.STATUS_COMMITTED) {
                BookServiceHelper.getInstance().getBookService().createBookWithoutTx(book);
            }
        }
    });
}
Example 24
Project: spring-framework-master  File: DataSourceUtils.java View source code
/**
	 * Actually obtain a JDBC Connection from the given DataSource.
	 * Same as {@link #getConnection}, but throwing the original SQLException.
	 * <p>Is aware of a corresponding Connection bound to the current thread, for example
	 * when using {@link DataSourceTransactionManager}. Will bind a Connection to the thread
	 * if transaction synchronization is active (e.g. if in a JTA transaction).
	 * <p>Directly accessed by {@link TransactionAwareDataSourceProxy}.
	 * @param dataSource the DataSource to obtain Connections from
	 * @return a JDBC Connection from the given DataSource
	 * @throws SQLException if thrown by JDBC methods
	 * @see #doReleaseConnection
	 */
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
    Assert.notNull(dataSource, "No DataSource specified");
    ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
    if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
        conHolder.requested();
        if (!conHolder.hasConnection()) {
            logger.debug("Fetching resumed JDBC Connection from DataSource");
            conHolder.setConnection(dataSource.getConnection());
        }
        return conHolder.getConnection();
    }
    // Else we either got no holder or an empty thread-bound holder here.
    logger.debug("Fetching JDBC Connection from DataSource");
    Connection con = dataSource.getConnection();
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        logger.debug("Registering transaction synchronization for JDBC Connection");
        // Use same Connection for further JDBC actions within the transaction.
        // Thread-bound object will get removed by synchronization at transaction completion.
        ConnectionHolder holderToUse = conHolder;
        if (holderToUse == null) {
            holderToUse = new ConnectionHolder(con);
        } else {
            holderToUse.setConnection(con);
        }
        holderToUse.requested();
        TransactionSynchronizationManager.registerSynchronization(new ConnectionSynchronization(holderToUse, dataSource));
        holderToUse.setSynchronizedWithTransaction(true);
        if (holderToUse != conHolder) {
            TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
        }
    }
    return con;
}
Example 25
Project: spring-modules-master  File: Jsr94Template.java View source code
/**
	 * Executes a stateful rule session. If called in a transaction, the session will be closed upon
	 * transaction completion; otherwise it will be closed when the callback returns.
	 * @param uri The ruleset uri
	 * @param properties The properties for the stateful rule session
	 * @param callback The callback
	 * @return The result of the callback execution
	 */
public Object executeStateful(final String uri, final Map properties, final StatefulRuleSessionCallback callback) {
    // get the session
    boolean synchronize = TransactionSynchronizationManager.isSynchronizationActive();
    if (!synchronize) {
        logger.debug("Not running in transaction; the session will be closed when the callback returns.");
    }
    StatefulRuleSession session = (StatefulRuleSession) TransactionSynchronizationManager.getResource(getRuleSource());
    if (session == null) {
        logger.debug("Opening StatefulRuleSession");
        session = (StatefulRuleSession) createRuleSession(uri, properties, RuleRuntime.STATEFUL_SESSION_TYPE);
        if (synchronize)
            TransactionSynchronizationManager.bindResource(getRuleSource(), session);
    }
    try {
        return callback.execute(session);
    } catch (InvalidRuleSessionException ex) {
        throw new Jsr94InvalidRuleSessionException(ex);
    } catch (RemoteException ex) {
        throw new Jsr94RemoteException(ex);
    } catch (InvalidHandleException ex) {
        throw new Jsr94InvalidHandleException(ex);
    } finally {
        if (!synchronize) {
            releaseStatefulSession(session);
            logger.debug("Closed session");
        }
    }
}
Example 26
Project: spring-retry-master  File: RetryOperationsInterceptorTests.java View source code
public void doTansactional() throws Exception {
    if (TransactionSynchronizationManager.isActualTransactionActive() && !enteredTransaction) {
        transactionCount++;
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            public void beforeCompletion() {
                enteredTransaction = false;
            }
        });
        enteredTransaction = true;
    }
    count++;
    if (count == 1) {
        throw new RuntimeException("Rollback please");
    }
}
Example 27
Project: camel-master  File: EntityManagers.java View source code
/**
     * Fetches {@link javax.persistence.EntityManager} bound to the current Spring transaction or creates new manager.
     *
     * @param entityManagerFactory {@link javax.persistence.EntityManagerFactory} used either as a key for a Spring
     *                             transaction resource lookup or as a factory to create new
     *                             {@link javax.persistence.EntityManager}.
     * @return {@link javax.persistence.EntityManager} bound to the existing Spring transaction or new manager instance.
     */
public static EntityManager resolveEntityManager(EntityManagerFactory entityManagerFactory) {
    EntityManagerHolder entityManagerHolder = (EntityManagerHolder) TransactionSynchronizationManager.getResource(entityManagerFactory);
    if (entityManagerHolder != null) {
        return entityManagerHolder.getEntityManager();
    }
    return entityManagerFactory.createEntityManager();
}
Example 28
Project: cms-ce-master  File: IndexTransactionJournal.java View source code
public void registerUpdate(Collection<ContentKey> contentKeys, boolean updateMetadataOnly) {
    if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
        return;
    }
    for (ContentKey contentKey : contentKeys) {
        final IndexTransactionJournalEntry indexTransactionJournalEntry = new IndexTransactionJournalEntry(UPDATE, contentKey, updateMetadataOnly);
        changeHistory.add(indexTransactionJournalEntry);
    }
}
Example 29
Project: db-util-master  File: OptimisticConcurrencyControlAspect.java View source code
private Object proceed(ProceedingJoinPoint pjp, Retry retryAnnotation) throws Throwable {
    int times = retryAnnotation.times();
    Class<? extends Throwable>[] retryOn = retryAnnotation.on();
    Assert.isTrue(times > 0, "@Retry{times} should be greater than 0!");
    Assert.isTrue(retryOn.length > 0, "@Retry{on} should have at least one Throwable!");
    if (retryAnnotation.failInTransaction() && TransactionSynchronizationManager.isActualTransactionActive()) {
        throw new IllegalTransactionStateException("You shouldn't retry an operation from withing an existing Transaction." + "This is because we can't retry if the current Transaction was already rollbacked!");
    }
    LOGGER.info("Proceed with {} retries on {}", times, Arrays.toString(retryOn));
    return tryProceeding(pjp, times, retryOn);
}
Example 30
Project: droolsjbpm-integration-master  File: KieSpringTransactionManager.java View source code
public void commit(boolean transactionOwner) {
    if (transactionOwner) {
        try {
            // if we didn't begin this transaction, then do nothing
            this.ptm.commit(currentTransaction);
            currentTransaction = null;
            if (TransactionSynchronizationManager.hasResource(KieSpringTransactionManager.RESOURCE_CONTAINER)) {
                TransactionSynchronizationManager.unbindResource(KieSpringTransactionManager.RESOURCE_CONTAINER);
            }
        } catch (Exception e) {
            logger.warn("Unable to commit transaction", e);
            throw new RuntimeException("Unable to commit transaction", e);
        }
    }
}
Example 31
Project: ef-orm-master  File: CrudMethodMetadataPostProcessor.java View source code
/* 
		 * (non-Javadoc)
		 * @see org.aopalliance.intercept.MethodInterceptor#invoke(org.aopalliance.intercept.MethodInvocation)
		 */
public Object invoke(MethodInvocation invocation) throws Throwable {
    Method method = invocation.getMethod();
    CrudMethodMetadata metadata = (CrudMethodMetadata) TransactionSynchronizationManager.getResource(method);
    if (metadata != null) {
        return invocation.proceed();
    }
    CrudMethodMetadata methodMetadata = metadataCache.get(method);
    if (methodMetadata == null) {
        methodMetadata = new DefaultCrudMethodMetadata(method);
        CrudMethodMetadata tmp = metadataCache.putIfAbsent(method, methodMetadata);
        if (tmp != null) {
            methodMetadata = tmp;
        }
    }
    TransactionSynchronizationManager.bindResource(method, methodMetadata);
    try {
        return invocation.proceed();
    } finally {
        TransactionSynchronizationManager.unbindResource(method);
    }
}
Example 32
Project: FiWare-Template-Handler-master  File: SpringTransactionContext.java View source code
public void addTransactionListener(final TransactionState transactionState, final TransactionListener transactionListener) {
    if (transactionState.equals(TransactionState.COMMITTING)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void beforeCommit(boolean readOnly) {
                transactionListener.execute(commandContext);
            }
        });
    } else if (transactionState.equals(TransactionState.COMMITTED)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void afterCommit() {
                transactionListener.execute(commandContext);
            }
        });
    } else if (transactionState.equals(TransactionState.ROLLINGBACK)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void beforeCompletion() {
                transactionListener.execute(commandContext);
            }
        });
    } else if (transactionState.equals(TransactionState.ROLLED_BACK)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void afterCompletion(int status) {
                transactionListener.execute(commandContext);
            }
        });
    }
}
Example 33
Project: iwethey-master  File: HibernateTestHarness.java View source code
public void setUp() throws Exception {
    SessionFactory sf = (SessionFactory) this.context.getBean("sessionFactory");
    //Session s = SessionFactoryUtils.getSession(sessionFactory, true);
    // open and bind the session for this test thread.
    Session s = sf.openSession();
    TransactionSynchronizationManager.bindResource(sf, new SessionHolder(s));
}
Example 34
Project: javaconfig-ftw-master  File: SpringTransactionContext.java View source code
public void addTransactionListener(final TransactionState transactionState, final TransactionListener transactionListener) {
    if (transactionState.equals(TransactionState.COMMITTING)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void beforeCommit(boolean readOnly) {
                transactionListener.execute(commandContext);
            }
        });
    } else if (transactionState.equals(TransactionState.COMMITTED)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void afterCommit() {
                transactionListener.execute(commandContext);
            }
        });
    } else if (transactionState.equals(TransactionState.ROLLINGBACK)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void beforeCompletion() {
                transactionListener.execute(commandContext);
            }
        });
    } else if (transactionState.equals(TransactionState.ROLLED_BACK)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void afterCompletion(int status) {
                if (TransactionSynchronization.STATUS_ROLLED_BACK == status) {
                    transactionListener.execute(commandContext);
                }
            }
        });
    }
}
Example 35
Project: jboss-seam-2.3.0.Final-Hibernate.3-master  File: SpringTransaction.java View source code
public void begin() throws NotSupportedException, SystemException {
    log.debug("beginning Spring transaction");
    if (TransactionSynchronizationManager.isActualTransactionActive()) {
        throw new NotSupportedException("A Spring transaction is already active.");
    }
    currentTransaction = getPlatformTransactionManagerRequired().getTransaction(definition);
    getSynchronizations().afterTransactionBegin();
}
Example 36
Project: jdbi-master  File: JdbiUtil.java View source code
/**
     * Obtain a Handle instance, either the transactionally bound one if we are in a transaction,
     * or a new one otherwise.
     * @param db the Jdbi instance from which to obtain the handle
     *
     * @return the Handle instance
     */
public static Handle getHandle(Jdbi db) {
    Handle bound = (Handle) TransactionSynchronizationManager.getResource(db);
    if (bound == null) {
        bound = db.open();
        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            TransactionSynchronizationManager.bindResource(db, bound);
            TransactionSynchronizationManager.registerSynchronization(new Adapter(db, bound));
            TRANSACTIONAL_HANDLES.add(bound);
        }
    }
    return bound;
}
Example 37
Project: jenkow-plugin-master  File: SpringTransactionContext.java View source code
public void addTransactionListener(final TransactionState transactionState, final TransactionListener transactionListener) {
    if (transactionState.equals(TransactionState.COMMITTING)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void beforeCommit(boolean readOnly) {
                transactionListener.execute(commandContext);
            }
        });
    } else if (transactionState.equals(TransactionState.COMMITTED)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void afterCommit() {
                transactionListener.execute(commandContext);
            }
        });
    } else if (transactionState.equals(TransactionState.ROLLINGBACK)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void beforeCompletion() {
                transactionListener.execute(commandContext);
            }
        });
    } else if (transactionState.equals(TransactionState.ROLLED_BACK)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void afterCompletion(int status) {
                if (TransactionSynchronization.STATUS_ROLLED_BACK == status) {
                    transactionListener.execute(commandContext);
                }
            }
        });
    }
}
Example 38
Project: owsi-core-parent-master  File: TransactionSynchronizationTaskManagerServiceImpl.java View source code
protected void addSynchronizationIfNeeded() {
    if (!TransactionSynchronizationManager.isActualTransactionActive()) {
        throw new IllegalStateException(EXCEPTION_MESSAGE_NO_ACTUAL_TRANSACTION_ACTIVE);
    }
    if (!isTaskSynchronizationActive()) {
        // Initialize the list of tasks that will be executed later
        bindContext(new TransactionSynchronizationTasks());
        // Register the synchronization adapter (that will transmit events to this service)
        TransactionSynchronizationManager.registerSynchronization(new TaskTransactionSynchronizationAdapter());
    }
}
Example 39
Project: seam-2.2-master  File: SpringTransaction.java View source code
public void begin() throws NotSupportedException, SystemException {
    log.debug("beginning Spring transaction");
    if (TransactionSynchronizationManager.isActualTransactionActive()) {
        throw new NotSupportedException("A Spring transaction is already active.");
    }
    currentTransaction = getPlatformTransactionManagerRequired().getTransaction(definition);
    getSynchronizations().afterTransactionBegin();
}
Example 40
Project: seam-revisited-master  File: SpringTransaction.java View source code
public void begin() throws NotSupportedException, SystemException {
    log.debug("beginning Spring transaction");
    if (TransactionSynchronizationManager.isActualTransactionActive()) {
        throw new NotSupportedException("A Spring transaction is already active.");
    }
    currentTransaction = getPlatformTransactionManagerRequired().getTransaction(definition);
    getSynchronizations().afterTransactionBegin();
}
Example 41
Project: seam2jsf2-master  File: SpringTransaction.java View source code
public void begin() throws NotSupportedException, SystemException {
    log.debug("beginning Spring transaction");
    if (TransactionSynchronizationManager.isActualTransactionActive()) {
        throw new NotSupportedException("A Spring transaction is already active.");
    }
    currentTransaction = getPlatformTransactionManagerRequired().getTransaction(definition);
    getSynchronizations().afterTransactionBegin();
}
Example 42
Project: spring-batch-master  File: TransactionAwareProxyFactory.java View source code
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
    if (!TransactionSynchronizationManager.isActualTransactionActive()) {
        return invocation.proceed();
    }
    T cache;
    if (!TransactionSynchronizationManager.hasResource(this)) {
        cache = begin(target);
        TransactionSynchronizationManager.bindResource(this, cache);
        TransactionSynchronizationManager.registerSynchronization(new TargetSynchronization(this, cache));
    } else {
        @SuppressWarnings("unchecked") T retrievedCache = (T) TransactionSynchronizationManager.getResource(this);
        cache = retrievedCache;
    }
    Object result = invocation.getMethod().invoke(cache, invocation.getArguments());
    if (appendOnly) {
        String methodName = invocation.getMethod().getName();
        if ((result == null && methodName.equals("get")) || (Boolean.FALSE.equals(result) && (methodName.startsWith("contains")) || (Boolean.TRUE.equals(result) && methodName.startsWith("isEmpty")))) {
            // in the cache...
            return invocation.proceed();
        }
        if (result instanceof Collection<?>) {
            HashSet<Object> set = new HashSet<Object>((Collection<?>) result);
            set.addAll((Collection<?>) invocation.proceed());
            result = set;
        }
    }
    return result;
}
Example 43
Project: spring-cloud-aws-master  File: RdbmsRetryOperationsInterceptorTest.java View source code
@Test
public void testRetryContextWithoutTransaction() throws Throwable {
    this.expectedException.expect(RetryException.class);
    this.expectedException.expectMessage("An active transaction was found");
    TransactionSynchronizationManager.setActualTransactionActive(true);
    try {
        RdbmsRetryOperationsInterceptor operationsInterceptor = new RdbmsRetryOperationsInterceptor();
        MethodInvocation methodInvocation = mock(MethodInvocation.class);
        operationsInterceptor.invoke(methodInvocation);
    } finally {
        TransactionSynchronizationManager.setActualTransactionActive(false);
    }
}
Example 44
Project: spring-data-jpa-master  File: CrudMethodMetadataPostProcessor.java View source code
/* 
		 * (non-Javadoc)
		 * @see org.aopalliance.intercept.MethodInterceptor#invoke(org.aopalliance.intercept.MethodInvocation)
		 */
public Object invoke(MethodInvocation invocation) throws Throwable {
    Method method = invocation.getMethod();
    CrudMethodMetadata metadata = (CrudMethodMetadata) TransactionSynchronizationManager.getResource(method);
    if (metadata != null) {
        return invocation.proceed();
    }
    CrudMethodMetadata methodMetadata = metadataCache.get(method);
    if (methodMetadata == null) {
        methodMetadata = new DefaultCrudMethodMetadata(method);
        CrudMethodMetadata tmp = metadataCache.putIfAbsent(method, methodMetadata);
        if (tmp != null) {
            methodMetadata = tmp;
        }
    }
    TransactionSynchronizationManager.bindResource(method, methodMetadata);
    try {
        return invocation.proceed();
    } finally {
        TransactionSynchronizationManager.unbindResource(method);
    }
}
Example 45
Project: spring-ldap-master  File: ContextSourceTransactionManagerTest.java View source code
@Before
public void setUp() throws Exception {
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.clearSynchronization();
    }
    contextSourceMock = mock(ContextSource.class);
    contextMock = mock(DirContext.class);
    transactionDefinitionMock = mock(TransactionDefinition.class);
    transactionDataManagerMock = mock(CompensatingTransactionOperationManager.class);
    renamingStrategyMock = mock(TempEntryRenamingStrategy.class);
    tested = new ContextSourceTransactionManager();
    tested.setContextSource(contextSourceMock);
    tested.setRenamingStrategy(renamingStrategyMock);
}
Example 46
Project: spring-modules-jcr-master  File: OpenSessionInViewTests.java View source code
public void testOpenSessionInViewInterceptor() throws Exception {
    MockControl sfControl = MockControl.createControl(SessionFactory.class);
    SessionFactory sf = (SessionFactory) sfControl.getMock();
    MockControl sessionControl = MockControl.createControl(Session.class);
    Session session = (Session) sessionControl.getMock();
    OpenSessionInViewInterceptor interceptor = new OpenSessionInViewInterceptor();
    MockServletContext sc = new MockServletContext();
    MockHttpServletRequest request = new MockHttpServletRequest(sc);
    MockHttpServletResponse response = new MockHttpServletResponse();
    sfControl.expectAndReturn(sf.getSession(), session);
    SessionHolder holder = new SessionHolder(session);
    sfControl.expectAndReturn(sf.getSessionHolder(session), holder);
    sfControl.replay();
    sessionControl.replay();
    interceptor.setSessionFactory(sf);
    interceptor.afterPropertiesSet();
    interceptor.preHandle(request, response, "handler");
    assertTrue(TransactionSynchronizationManager.hasResource(sf));
    assertSame(holder, TransactionSynchronizationManager.getResource(sf));
    // check that further invocations simply participate
    interceptor.preHandle(request, response, "handler");
    interceptor.preHandle(request, response, "handler");
    interceptor.postHandle(request, response, "handler", null);
    interceptor.afterCompletion(request, response, "handler", null);
    interceptor.postHandle(request, response, "handler", null);
    interceptor.afterCompletion(request, response, "handler", null);
    interceptor.preHandle(request, response, "handler");
    interceptor.postHandle(request, response, "handler", null);
    interceptor.afterCompletion(request, response, "handler", null);
    sfControl.verify();
    sessionControl.verify();
    sfControl.reset();
    sessionControl.reset();
    sfControl.replay();
    sessionControl.replay();
    interceptor.postHandle(request, response, "handler", null);
    assertTrue(TransactionSynchronizationManager.hasResource(sf));
    assertSame(holder, TransactionSynchronizationManager.getResource(sf));
    sfControl.verify();
    sessionControl.verify();
    sfControl.reset();
    sessionControl.reset();
    session.logout();
    sessionControl.setVoidCallable(1);
    sfControl.replay();
    sessionControl.replay();
    interceptor.afterCompletion(request, response, "handler", null);
    assertFalse(TransactionSynchronizationManager.hasResource(sf));
    sfControl.verify();
    sessionControl.verify();
}
Example 47
Project: summerb-master  File: TransactionBoundCache.java View source code
/**
	 * Get for write purpose
	 */
private LoadingCache<K, V> get() {
    String curTranName = TransactionSynchronizationManager.getCurrentTransactionName();
    if (transactionBoundCacheEntries.get() != null) {
        if (log.isTraceEnabled()) {
            log.trace(cacheName + ": Using transaction-local (assumming active transaction) cache tran=" + curTranName);
        }
        return transactionBoundCacheEntries.get().transactionBound;
    }
    boolean synchronizationActive = TransactionSynchronizationManager.isSynchronizationActive();
    if (!synchronizationActive) {
        if (log.isTraceEnabled()) {
            log.trace(cacheName + ": Using global cache");
        }
        return actual;
    }
    if (log.isTraceEnabled()) {
        log.trace(cacheName + ": Constructing transaction-local cache, tran=" + curTranName);
    }
    TransactionSynchronizationManager.registerSynchronization(synchronization);
    TransactionBoundCacheEntry newCache = new TransactionBoundCacheEntry<K, V>();
    newCache.transactionBound = CacheBuilder.newBuilder().removalListener(localRemovalListener).build(loader);
    newCache.transactionBound.putAll(actual.asMap());
    newCache.transactionBoundRemovals = new HashSet<K>();
    transactionBoundCacheEntries.set(newCache);
    return newCache.transactionBound;
}
Example 48
Project: abiquo-master  File: AbstractGeneratorTest.java View source code
protected void tearDown(final String... entities) {
    EntityManager em = getEntityManager();
    rollbackActiveTransaction(em);
    em.getTransaction().begin();
    for (String entity : entities) {
        em.createNativeQuery("delete from " + entity).executeUpdate();
    }
    em.getTransaction().commit();
    em.close();
    // Avoid having closed EntityManagers bound to the thread
    TransactionSynchronizationManager.unbindResource(getEntityManagerFactory());
}
Example 49
Project: compass-fork-master  File: SpringSyncTransaction.java View source code
public void begin(PlatformTransactionManager transactionManager, InternalCompassSession session, boolean commitBeforeCompletion) {
    this.session = session;
    this.transactionManager = transactionManager;
    // the factory called begin, so we are in charge, if we were not, than
    // it would not call begin (we are in charge of the COMPASS transaction,
    // the spring one is handled later)
    controllingNewTransaction = true;
    if (transactionManager != null) {
        DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
        transactionDefinition.setPropagationBehavior(DefaultTransactionDefinition.PROPAGATION_REQUIRED);
        int timeout = session.getSettings().getSettingAsInt(CompassEnvironment.Transaction.TRANSACTION_TIMEOUT, -1);
        if (timeout != -1) {
            transactionDefinition.setTimeout(timeout);
        }
        transactionDefinition.setReadOnly(session.isReadOnly());
        status = transactionManager.getTransaction(transactionDefinition);
    }
    session.getSearchEngine().begin();
    SpringTransactionSynchronization sync;
    if (transactionManager != null) {
        if (log.isDebugEnabled()) {
            if (status.isNewTransaction()) {
                log.debug("Beginning new Spring transaction, and a new compass transaction on thread [" + Thread.currentThread().getName() + "]");
            } else {
                log.debug("Joining Spring transaction, and starting a new compass transaction on thread [" + Thread.currentThread().getName() + "]");
            }
        }
        sync = new SpringTransactionSynchronization(session, status.isNewTransaction(), commitBeforeCompletion, transactionFactory);
    } else {
        if (log.isDebugEnabled()) {
            log.debug("Joining Spring transaction, and starting a new compass transaction on thread [" + Thread.currentThread().getName() + "]");
        }
        sync = new SpringTransactionSynchronization(session, false, commitBeforeCompletion, transactionFactory);
    }
    TransactionSynchronizationManager.registerSynchronization(sync);
    setBegun(true);
}
Example 50
Project: droolsjbpm-master  File: DroolsSpringTransactionManager.java View source code
/**
     * Borrowed from Seam
     * @author Michael Youngstrom
     */
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);
            // 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 TransactionManager.STATUS_ROLLEDBACK;
                }
                return TransactionManager.STATUS_ACTIVE;
            }
        } finally {
            if (currentTransaction == null) {
                ptm.commit(transaction);
            }
        }
    }
    return TransactionManager.STATUS_NO_TRANSACTION;
}
Example 51
Project: easyooo-framework-master  File: RoutingSynchronizationManager.java View source code
public static void initSynchronization(TransactionDefinition definition) throws IllegalStateException {
    if (isSynchronizationActive()) {
        throw new IllegalStateException("Cannot activate transaction synchronization - already active");
    }
    if (logger.isDebugEnabled()) {
        logger.debug("Initializing transaction synchronization");
    }
    synchronizations.set(new LinkedHashMap<DataSource, ConnectionHolder>());
    definitions.set(definition);
    // �始化Spring�步事务管�器,这使得Mybatis让Spring接管事务时,有一个判断标准,
    // �会��打开Session,也�会直接关闭Session
    // 具体请�看 org.mybatis.spring.SqlSessionUtils#getSqlSession
    // org.mybatis.spring.SqlSessionTemplate.SqlSessionInterceptor#invoke
    TransactionSynchronizationManager.initSynchronization();
}
Example 52
Project: ganshane-master  File: SpringSessionManagerImpl.java View source code
@Override
public void threadDidCleanup() {
    if (!participate) {
        // single session mode
        SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.unbindResource(sessionFactory);
        logger.debug("Closing single Hibernate Session in OpenSessionInViewFilter");
        closeSession(sessionHolder.getSession(), sessionFactory);
    }
}
Example 53
Project: hq-master  File: GalertProcessorImpl.java View source code
/**
     * Called when primitive information has been updated which doens't
     * require a reload of the entire definition.
     */
public void alertDefUpdated(GalertDef def, final String newName) {
    final Integer defId = def.getId();
    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {

        public void suspend() {
        }

        public void resume() {
        }

        public void flush() {
        }

        public void beforeCompletion() {
        }

        public void beforeCommit(boolean readOnly) {
        }

        public void afterCompletion(int status) {
        }

        public void afterCommit() {
            synchronized (cfgLock) {
                MemGalertDef memDef = (MemGalertDef) _alertDefs.get(defId);
                if (memDef != null)
                    memDef.setName(newName);
            }
        }
    });
}
Example 54
Project: jcr-springextension-master  File: LocalTransactionManagerTest.java View source code
@Test
public void testTransactionCommit() throws Exception {
    final SessionFactory sessionFactory = createMock(SessionFactory.class);
    final XASession xaSession = createMock(XASession.class);
    // create nice mock
    XAResource xaResource = createMock(XAResource.class);
    expect(sessionFactory.getSession()).andReturn(xaSession);
    expect(xaSession.getXAResource()).andReturn(xaResource);
    xaSession.save();
    xaSession.logout();
    Xid xidMock = new XidMock();
    xaResource.start(xidMock, XAResource.TMNOFLAGS);
    expect(xaResource.prepare(xidMock)).andReturn(0);
    xaResource.commit(xidMock, false);
    xaResource.end(xidMock, XAResource.TMSUCCESS);
    replay(sessionFactory, xaSession, xaResource);
    PlatformTransactionManager tm = new LocalTransactionManager(sessionFactory);
    TransactionTemplate tt = new TransactionTemplate(tm);
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sessionFactory));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
    tt.execute(new TransactionCallbackWithoutResult() {

        protected void doInTransactionWithoutResult(TransactionStatus status) {
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sessionFactory));
            JcrTemplate template = new JcrTemplate(sessionFactory);
            template.save();
        }
    });
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sessionFactory));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
    verify(sessionFactory, xaResource, xaSession);
}
Example 55
Project: m3s-master  File: AbstractServiceTest.java View source code
/**
	 * One time setup which keeps a session open for the duration of the tests.
	 */
protected void onSetUp() throws Exception {
    //logger.trace("onSetup(): entered method.");
    SessionFactory sessionFactory = (SessionFactory) getBean("sessionFactory");
    Session session = sessionFactory.openSession();
    SessionHolder holder = new SessionHolder(session);
    TransactionSynchronizationManager.bindResource(sessionFactory, holder);
}
Example 56
Project: narayana-master  File: PlatformTransactionManagerImple.java View source code
public void resumed(Transaction transaction) {
    SuspendedResourcesHolder holder = suspendedResources.remove(transaction);
    if (holder != null) {
        TransactionSynchronizationManager.setActualTransactionActive(true);
        TransactionSynchronizationManager.setCurrentTransactionReadOnly(holder.isReadOnly());
        TransactionSynchronizationManager.setCurrentTransactionName(holder.getName());
        TransactionSynchronizationManager.initSynchronization();
        for (TransactionSynchronization synchronization : holder.getSuspendedSynchronizations()) {
            synchronization.resume();
            TransactionSynchronizationManager.registerSynchronization(synchronization);
        }
    }
}
Example 57
Project: riot-master  File: ThreadBoundHibernateTemplate.java View source code
@Override
protected Object doExecute(HibernateCallback action, boolean enforceNewSession, boolean enforceNativeSession) throws DataAccessException {
    Assert.notNull(action, "Callback object must not be null");
    Session oldSession = null;
    Session session = (enforceNewSession ? SessionFactoryUtils.getNewSession(getSessionFactory(), getEntityInterceptor()) : getSession());
    SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(getSessionFactory());
    boolean existingTransaction = !enforceNewSession && (!isAllowCreate() || (sessionHolder != null && sessionHolder.containsSession(session)));
    if (existingTransaction) {
        log.debug("Found thread-bound Session for LongConversationTemplate");
    } else {
        if (sessionHolder != null) {
            oldSession = sessionHolder.getSession();
            sessionHolder.addSession(session);
        } else {
            TransactionSynchronizationManager.bindResource(getSessionFactory(), new SessionHolder(session));
        }
    }
    FlushMode previousFlushMode = null;
    try {
        previousFlushMode = applyFlushMode(session, existingTransaction);
        enableFilters(session);
        Session sessionToExpose = (enforceNativeSession || isExposeNativeSession() ? session : createSessionProxy(session));
        Object result = action.doInHibernate(sessionToExpose);
        flushIfNecessary(session, existingTransaction);
        return result;
    } catch (HibernateException ex) {
        throw convertHibernateAccessException(ex);
    } catch (SQLException ex) {
        throw convertJdbcAccessException(ex);
    } catch (RuntimeException ex) {
        throw ex;
    } finally {
        if (existingTransaction) {
            log.debug("Not closing pre-bound Hibernate Session after HibernateTemplate");
            disableFilters(session);
            if (previousFlushMode != null) {
                session.setFlushMode(previousFlushMode);
            }
        } else {
            SessionFactoryUtils.closeSession(session);
            if (oldSession != null) {
                sessionHolder.addSession(oldSession);
            } else {
                TransactionSynchronizationManager.unbindResource(getSessionFactory());
            }
        }
    }
}
Example 58
Project: spring-data-jdbc-ext-master  File: AqJmsFactoryBeanFactory.java View source code
@Override
public java.sql.Connection getConnection() throws SQLException {
    java.sql.Connection con = DataSourceUtils.getConnection(getTargetDataSource());
    java.sql.Connection conToUse = con;
    if (!(con instanceof OracleConnection)) {
        if (logger.isDebugEnabled()) {
            logger.debug("Unwrapping JDBC Connection of type:" + con.getClass().getName());
        }
        try {
            conToUse = nativeJdbcExtractor.getNativeConnection(con);
        } catch (SQLException e) {
            throw new NonTransientDataAccessResourceException("Error unwrapping the Oracle Connection: " + e.getMessage(), e);
        }
    }
    if (TransactionSynchronizationManager.isActualTransactionActive()) {
        if (logger.isDebugEnabled()) {
            logger.debug("Using Proxied JDBC Connection [" + conToUse + "]");
        }
        return getCloseSuppressingConnectionProxy(conToUse);
    } else {
        if (con instanceof OracleConnection) {
            if (logger.isDebugEnabled()) {
                logger.debug("Using Native JDBC Connection [" + conToUse + "]");
            }
            return conToUse;
        } else {
            if (logger.isDebugEnabled()) {
                logger.debug("Using Closeable Proxy fo JDBC Connection [" + conToUse + "]");
            }
            return getCloseDelegatingConnectionProxy(conToUse, con);
        }
    }
}
Example 59
Project: springboot-dubbox-master  File: DynamicPlugin.java View source code
@Override
public Object intercept(Invocation invocation) throws Throwable {
    boolean synchronizationActive = TransactionSynchronizationManager.isSynchronizationActive();
    //如果没有事务
    if (!synchronizationActive) {
        Object[] objects = invocation.getArgs();
        MappedStatement ms = (MappedStatement) objects[0];
        DynamicDataSourceGlobal dynamicDataSourceGlobal;
        if ((dynamicDataSourceGlobal = CACHE_MAP.get(ms.getId())) == null) {
            dynamicDataSourceGlobal = getDynamicDataSource(ms, objects[1]);
            LOGGER.warn("设置方法[{}] use [{}] Strategy, SqlCommandType [{}]..", ms.getId(), dynamicDataSourceGlobal.name(), ms.getSqlCommandType().name());
            CACHE_MAP.put(ms.getId(), dynamicDataSourceGlobal);
        }
        DynamicDataSourceHolder.putDataSource(dynamicDataSourceGlobal);
    }
    return invocation.proceed();
}
Example 60
Project: starflow-master  File: DefaultUniqueTableApp.java View source code
public CacheValue getCacheValue(int cacheNum, String name) {
    Assert.isTrue(TransactionSynchronizationManager.isSynchronizationActive(), "Transaction must be running");
    CacheValue cache = null;
    try {
        cache = getCurrCode(name);
        if (cache == null) {
            insert(name);
            cache = getCurrCode(name);
        }
        update(cacheNum, name);
        cache.setMaxVal(cache.getMinVal() + cacheNum);
    } catch (Exception e) {
        logger.error("获�主键失败", e);
    }
    return cache;
}
Example 61
Project: tapestry5-spring-tx-master  File: SpringHibernateSessionManagerImpl.java View source code
private void startNewTransaction() {
    sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(getSessionFactory());
    existingTransaction = (sessionHolder != null && sessionHolder.containsSession(session));
    if (existingTransaction) {
        logger.debug("Found thread-bound Session for HibernateInterceptor");
    } else {
        if (sessionHolder != null) {
            sessionHolder.addSession(session);
        } else {
            TransactionSynchronizationManager.bindResource(getSessionFactory(), new SessionHolder(session));
        }
    }
    this.previousFlushMode = applyFlushMode(session, existingTransaction);
    enableFilters(session);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    this.status = txManager.getTransaction(definition);
}
Example 62
Project: uPortal-master  File: OpenEntityManagerAspect.java View source code
@Around("anyPublicMethod() && @annotation(openEntityManager)")
public Object openEntityManager(ProceedingJoinPoint pjp, OpenEntityManager openEntityManager) throws Throwable {
    final EntityManagerFactory emf = getEntityManagerFactory(openEntityManager);
    EntityManager em = getTransactionalEntityManager(emf);
    boolean isNewEm = false;
    if (em == null) {
        logger.debug("Opening JPA EntityManager in OpenEntityManagerAspect");
        em = createEntityManager(emf);
        isNewEm = true;
        TransactionSynchronizationManager.bindResource(emf, new EntityManagerHolder(em));
    } else {
        logger.debug("Using Existing JPA EntityManager in OpenEntityManagerAspect");
    }
    try {
        return pjp.proceed();
    } finally {
        if (isNewEm) {
            logger.debug("Closing JPA EntityManager in OpenEntityManagerAspect");
            TransactionSynchronizationManager.unbindResource(emf);
            EntityManagerFactoryUtils.closeEntityManager(em);
        }
    }
}
Example 63
Project: Activiti-master  File: SpringTransactionContext.java View source code
public void addTransactionListener(final TransactionState transactionState, final TransactionListener transactionListener) {
    if (transactionState.equals(TransactionState.COMMITTING)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void beforeCommit(boolean readOnly) {
                transactionListener.execute(commandContext);
            }
        });
    } else if (transactionState.equals(TransactionState.COMMITTED)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void afterCommit() {
                CommandExecutor commandExecutor = commandContext.getProcessEngineConfiguration().getCommandExecutor();
                CommandConfig commandConfig = new CommandConfig(false, TransactionPropagation.REQUIRES_NEW);
                commandExecutor.execute(commandConfig, new Command<Void>() {

                    public Void execute(CommandContext commandContext) {
                        transactionListener.execute(commandContext);
                        return null;
                    }
                });
            }
        });
    } else if (transactionState.equals(TransactionState.ROLLINGBACK)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void beforeCompletion() {
                transactionListener.execute(commandContext);
            }
        });
    } else if (transactionState.equals(TransactionState.ROLLED_BACK)) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void afterCompletion(int status) {
                if (TransactionSynchronization.STATUS_ROLLED_BACK == status) {
                    CommandExecutor commandExecutor = commandContext.getProcessEngineConfiguration().getCommandExecutor();
                    CommandConfig commandConfig = new CommandConfig(false, TransactionPropagation.REQUIRES_NEW);
                    commandExecutor.execute(commandConfig, new Command<Void>() {

                        public Void execute(CommandContext commandContext) {
                            transactionListener.execute(commandContext);
                            return null;
                        }
                    });
                }
            }
        });
    }
}
Example 64
Project: aries-master  File: AriesPlatformTransactionManager.java View source code
public void threadAssociated(Transaction transaction) {
    try {
        if (transaction.getStatus() == Status.STATUS_ACTIVE) {
            SuspendedResourcesHolder holder = suspendedResources.remove(transaction);
            if (holder != null && holder.getSuspendedSynchronizations() != null) {
                TransactionSynchronizationManager.setActualTransactionActive(true);
                TransactionSynchronizationManager.setCurrentTransactionReadOnly(holder.isReadOnly());
                TransactionSynchronizationManager.setCurrentTransactionName(holder.getName());
                TransactionSynchronizationManager.initSynchronization();
                for (Iterator<?> it = holder.getSuspendedSynchronizations().iterator(); it.hasNext(); ) {
                    TransactionSynchronization synchronization = (TransactionSynchronization) it.next();
                    synchronization.resume();
                    TransactionSynchronizationManager.registerSynchronization(synchronization);
                }
            }
        }
    } catch (SystemException e) {
        return;
    }
}
Example 65
Project: BlackboardVCPortlet-master  File: OpenEntityManagerAspect.java View source code
@Around("anyPublicMethod() && @annotation(openEntityManager)")
public Object openEntityManager(ProceedingJoinPoint pjp, OpenEntityManager openEntityManager) throws Throwable {
    final EntityManagerFactory emf = getEntityManagerFactory(openEntityManager);
    EntityManager em = getTransactionalEntityManager(emf);
    boolean isNewEm = false;
    if (em == null) {
        logger.debug("Opening JPA EntityManager in OpenEntityManagerAspect");
        em = createEntityManager(emf);
        isNewEm = true;
        TransactionSynchronizationManager.bindResource(emf, new EntityManagerHolder(em));
    } else {
        logger.debug("Using Existing JPA EntityManager in OpenEntityManagerAspect");
    }
    try {
        return pjp.proceed();
    } finally {
        if (isNewEm) {
            logger.debug("Closing JPA EntityManager in OpenEntityManagerAspect");
            TransactionSynchronizationManager.unbindResource(emf);
            EntityManagerFactoryUtils.closeEntityManager(em);
        }
    }
}
Example 66
Project: EasyTransaction-master  File: EasyTransSynchronizer.java View source code
/**
	 * create LogContext.<br>
	 * pass in busCode and trxId will help about the execute efficient and the debug and statistics<br>
	 * so I demand to pass in busCode and trxId to generate a global unique bus key 
	 * @param busCode the unique busCode in AppId
	 * @param trxId the unique trxId in appId+busCode
	 */
public void startSoftTrans(String busCode, String trxId) {
    Assert.notNull(busCode);
    Assert.notNull(trxId);
    //hook to TransactionSynchronizer
    TransactionSynchronizationManager.registerSynchronization(new TransactionHook());
    LogProcessContext logProcessContext = new LogProcessContext(config.getAppId(), busCode, trxId, writer, transStatusLogger);
    TransactionSynchronizationManager.bindResource(LOG_PROCESS_CONTEXT, logProcessContext);
    transStatusLogger.writeExecuteFlag(config.getAppId(), busCode, trxId);
}
Example 67
Project: felix-master  File: GeronimoPlatformTransactionManager.java View source code
public void threadAssociated(Transaction transaction) {
    try {
        if (transaction.getStatus() == Status.STATUS_ACTIVE) {
            SuspendedResourcesHolder holder = suspendedResources.remove(transaction);
            if (holder != null && holder.getSuspendedSynchronizations() != null) {
                TransactionSynchronizationManager.setActualTransactionActive(true);
                TransactionSynchronizationManager.setCurrentTransactionReadOnly(holder.isReadOnly());
                TransactionSynchronizationManager.setCurrentTransactionName(holder.getName());
                TransactionSynchronizationManager.initSynchronization();
                for (Iterator<?> it = holder.getSuspendedSynchronizations().iterator(); it.hasNext(); ) {
                    TransactionSynchronization synchronization = (TransactionSynchronization) it.next();
                    synchronization.resume();
                    TransactionSynchronizationManager.registerSynchronization(synchronization);
                }
            }
        }
    } catch (SystemException e) {
        return;
    }
}
Example 68
Project: graniteds-master  File: TideDataPublishingWrapper.java View source code
public <T> T execute(DataEnabled dataEnabled, ThrowableCallable<T> action) throws Throwable {
    boolean shouldRemoveContextAtEnd = DataContext.get() == null;
    boolean shouldInitContext = shouldRemoveContextAtEnd || DataContext.isNull();
    boolean onCommit = false;
    if (shouldInitContext) {
        DataContext.init(gravity, dataEnabled.topic(), dataEnabled.params(), dataEnabled.publish());
        if (dataUpdatePostprocessor != null)
            DataContext.get().setDataUpdatePostprocessor(dataUpdatePostprocessor);
    }
    DataContext.observe();
    try {
        if (dataEnabled.publish().equals(PublishMode.ON_COMMIT) && !TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
            if (TransactionSynchronizationManager.isSynchronizationActive()) {
                boolean registered = false;
                for (Object resource : TransactionSynchronizationManager.getResourceMap().values()) {
                    if (syncsMap.containsKey(resource.getClass().getName())) {
                        registered = syncsMap.get(resource.getClass().getName()).registerSynchronization(resource, shouldRemoveContextAtEnd);
                        break;
                    }
                }
                if (!registered)
                    TransactionSynchronizationManager.registerSynchronization(new DataPublishingTransactionSynchronization(shouldRemoveContextAtEnd));
                else if (shouldRemoveContextAtEnd)
                    TransactionSynchronizationManager.registerSynchronization(new DataContextCleanupTransactionSynchronization());
                onCommit = true;
            } else if (TransactionSynchronizationManager.isActualTransactionActive()) {
                log.error("Could not register synchronization for ON_COMMIT publish mode, check that the Spring PlatformTransactionManager supports it " + "and that the order of the TransactionInterceptor is lower than the order of TideDataPublishingInterceptor");
                if (shouldRemoveContextAtEnd)
                    DataContext.remove();
            } else {
                // No transaction, clear data context and wait for a possible manual transactions
                if (shouldRemoveContextAtEnd)
                    DataContext.remove();
            }
        }
        T ret = action.call();
        DataContext.publish(PublishMode.ON_SUCCESS);
        return ret;
    } finally {
        if (shouldRemoveContextAtEnd && !onCommit)
            DataContext.remove();
    }
}
Example 69
Project: graphity-core-master  File: OpenSessionInViewTests.java View source code
@After
public void tearDown() throws Exception {
    assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
}
Example 70
Project: haze-master  File: HazelcastTransactionManager.java View source code
/**
     * Returns the transaction context for the given Hazelcast instance bounded to the current thread.
     *
     * @throws NoTransactionException if the transaction context cannot be found
     */
public static TransactionContext getTransactionContext(HazelcastInstance hazelcastInstance) {
    TransactionContextHolder transactionContextHolder = (TransactionContextHolder) TransactionSynchronizationManager.getResource(hazelcastInstance);
    if (transactionContextHolder == null) {
        throw new NoTransactionException("No TransactionContext with actual transaction available for current thread");
    }
    return transactionContextHolder.getContext();
}
Example 71
Project: hazelcast-master  File: HazelcastTransactionManager.java View source code
/**
     * Returns the transaction context for the given Hazelcast instance bounded to the current thread.
     *
     * @throws NoTransactionException if the transaction context cannot be found
     */
public static TransactionContext getTransactionContext(HazelcastInstance hazelcastInstance) {
    TransactionContextHolder transactionContextHolder = (TransactionContextHolder) TransactionSynchronizationManager.getResource(hazelcastInstance);
    if (transactionContextHolder == null) {
        throw new NoTransactionException("No TransactionContext with actual transaction available for current thread");
    }
    return transactionContextHolder.getContext();
}
Example 72
Project: jeffaschenk-commons-master  File: SpringAccessor.java View source code
/**
     * Obtain the Current Session.
     *
     * @return Session which is Current Active Session or newly created Session.
     */
public static Session getCurrentSession() {
    try {
        SessionFactory sessionFactory = (SessionFactory) getBean(sessionFactoryBeanName);
        SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
        if (holder == null) {
            return getSession();
        }
        // **********************************
        // Obtain Session within Holder.
        Session session = holder.getSession();
        if (session != null) {
            return session;
        } else {
            return getSession();
        }
    } catch (Exception e) {
        log.error("Exception encountered while Obtaining Current Session:" + e.getMessage(), e);
        throw new java.lang.RuntimeException("Exception encountered while Obtaining Current Session Encountered", e);
    }
}
Example 73
Project: lutece-core-master  File: ChainedTransactionManager.java View source code
/**
     * Begin a transaction for all transaction managers {@inheritDoc}
     */
public TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
    if (_transactionManagers.isEmpty()) {
        return null;
    }
    MultiTransactionStatus mts = new MultiTransactionStatus(_transactionManagers.get(0));
    if (!TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.initSynchronization();
        mts.setNewSynchonization();
        if (_log.isDebugEnabled()) {
            _log.debug("Begin transaction : " + mts.toString());
        }
    }
    for (PlatformTransactionManager transactionManager : _transactionManagers) {
        mts.getTransactionStatuses().put(transactionManager, transactionManager.getTransaction(definition));
    }
    return mts;
}
Example 74
Project: molgenis-master  File: IndexActionRegisterServiceImpl.java View source code
@Transactional
@Override
public synchronized void register(String entityFullName, String entityId) {
    String transactionId = (String) TransactionSynchronizationManager.getResource(TRANSACTION_ID_RESOURCE_NAME);
    if (transactionId != null) {
        LOG.debug("register(entityFullName: [{}], entityId: [{}])", entityFullName, entityId);
        final int actionOrder = indexActionsPerTransaction.get(transactionId).size();
        if (actionOrder >= LOG_EVERY && actionOrder % LOG_EVERY == 0) {
            LOG.warn("Transaction {} has caused {} IndexActions to be created. Consider streaming your data manipulations.", transactionId, actionOrder);
        }
        IndexAction indexAction = indexActionFactory.create().setIndexActionGroup(indexActionGroupFactory.create(transactionId)).setEntityFullName(entityFullName).setEntityId(entityId).setIndexStatus(PENDING);
        indexActionsPerTransaction.put(transactionId, indexAction);
    } else {
        LOG.error("Transaction id is unknown, register of entityFullName [{}] dataType [{}], entityId [{}]", entityFullName, entityId);
    }
}
Example 75
Project: mybatis-shards-master  File: MultiDataSourcesTransactionManager.java View source code
@Override
public TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
    MultiDataSourcesTransactionStatus transactionStatus = new MultiDataSourcesTransactionStatus();
    log.debug("Operation '" + definition.getName() + "' starting transaction.");
    for (DataSource dataSource : dataSources) {
        DefaultTransactionDefinition defaultTransactionDefinition = new DefaultTransactionDefinition(definition);
        defaultTransactionDefinition.setName(definition.getName());
        PlatformTransactionManager txManager = this.transactionManagers.get(dataSource);
        TransactionStatus status = txManager.getTransaction(defaultTransactionDefinition);
        TransactionSynchronizationManager.setCurrentTransactionName(defaultTransactionDefinition.getName());
        transactionStatus.put(dataSource, status);
    }
    return transactionStatus;
}
Example 76
Project: perecoder-master  File: TransactionalIndexWriterAccessor.java View source code
@Override
public IndexWriter retrieveWriter(Directory directory) throws IOException {
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        // Получаем адаптер Ñ?инхронизации из менеджера
        IndexWriterTransactionSynchronization synchronization = (IndexWriterTransactionSynchronization) TransactionSynchronizationManager.getResource(directory);
        if (synchronization == null) {
            synchronization = new IndexWriterTransactionSynchronization(new IndexWriter(directory, indexWriterConfig.clone()));
            TransactionSynchronizationManager.bindResource(directory, synchronization);
        }
        // ВыполнÑ?ем перерегиÑ?трацию адаптера
        TransactionSynchronizationManager.registerSynchronization(synchronization);
        // Возвращаем актуальный Ñ?ервиÑ? запиÑ?и
        return synchronization.getWriter();
    } else {
        return createIndexWriter(directory);
    }
}
Example 77
Project: ranger-master  File: RangerTransactionSynchronizationAdapter.java View source code
public void executeOnTransactionCompletion(Runnable runnable) {
    if (LOG.isDebugEnabled()) {
        LOG.debug("Submitting new runnable {" + runnable + "} to run after completion");
    }
    if (!TransactionSynchronizationManager.isSynchronizationActive()) {
        LOG.info("Transaction synchronization is NOT ACTIVE. Executing right now runnable {" + runnable + "}");
        runnable.run();
        return;
    }
    List<Runnable> threadRunnables = RUNNABLES.get();
    if (threadRunnables == null) {
        threadRunnables = new ArrayList<Runnable>();
        RUNNABLES.set(threadRunnables);
        // Register a new transaction synchronization for the current thread.
        // TransactionSynchronizationManage will call afterCompletion() when current transaction completes.
        TransactionSynchronizationManager.registerSynchronization(this);
    }
    threadRunnables.add(runnable);
}
Example 78
Project: spring-data-neo4j-master  File: OpenSessionInViewInterceptor.java View source code
@Override
public void preHandle(WebRequest request) throws DataAccessException {
    String participateAttributeName = getParticipateAttributeName();
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    if (asyncManager.hasConcurrentResult()) {
        if (applyCallableInterceptor(asyncManager, participateAttributeName)) {
            return;
        }
    }
    if (TransactionSynchronizationManager.hasResource(getSessionFactory())) {
        // Do not modify the Session: just mark the request accordingly.
        Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
        int newCount = (count != null ? count + 1 : 1);
        request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
    } else {
        logger.debug("Opening Neo4j OGM Session in OpenSessionInViewInterceptor");
        Session session = sessionFactory.openSession();
        SessionHolder sessionHolder = new SessionHolder(session);
        TransactionSynchronizationManager.bindResource(getSessionFactory(), sessionHolder);
        AsyncRequestInterceptor interceptor = new AsyncRequestInterceptor(getSessionFactory(), sessionHolder);
        asyncManager.registerCallableInterceptor(participateAttributeName, interceptor);
        asyncManager.registerDeferredResultInterceptor(participateAttributeName, interceptor);
    }
}
Example 79
Project: spring-data-orientdb-master  File: OrientTransactionManager.java View source code
/* (non-Javadoc)
     * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#doBegin(java.lang.Object, org.springframework.transaction.TransactionDefinition)
     */
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) throws TransactionException {
    OrientTransaction tx = (OrientTransaction) transaction;
    ODatabase<?> db = tx.getDatabase();
    if (db == null || db.isClosed()) {
        db = dbf.openDatabase();
        tx.setDatabase(db);
        TransactionSynchronizationManager.bindResource(dbf, db);
    }
    log.debug("beginning transaction, db.hashCode() = {}", db.hashCode());
    db.begin();
}
Example 80
Project: spring-db4o-master  File: Db4oTransactionManager.java View source code
protected void doBegin(Object transaction, TransactionDefinition transactionDefinition) throws TransactionException {
    if (transactionDefinition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
        throw new InvalidIsolationLevelException("Db4o does not support an isolation level concept");
    }
    ObjectContainer container = null;
    try {
        Db4oTransactionObject txObject = (Db4oTransactionObject) transaction;
        if (txObject.getObjectContainerHolder() == null) {
            // use the given container
            container = getObjectContainer();
            logger.debug("Using given objectContainer [{}] for the current thread transaction", container);
            txObject.setObjectContainerHolder(new ObjectContainerHolder(container));
        }
        ObjectContainerHolder containerHolder = txObject.getObjectContainerHolder();
        containerHolder.setSynchronizedWithTransaction(true);
        // Register transaction timeout.
        if (transactionDefinition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT) {
            txObject.getObjectContainerHolder().setTimeoutInSeconds(transactionDefinition.getTimeout());
        }
        // Bind the session holder to the thread.
        TransactionSynchronizationManager.bindResource(getObjectContainer(), containerHolder);
    } catch (Exception ex) {
        throw new CannotCreateTransactionException("Could not start db4o object container transaction", ex);
    }
}
Example 81
Project: spring-hadoop-master  File: HdfsItemWriter.java View source code
@SuppressWarnings({ "unchecked", "rawtypes" })
private List<? extends T> getCurrentBuffer() {
    if (!TransactionSynchronizationManager.hasResource(bufferKey)) {
        TransactionSynchronizationManager.bindResource(bufferKey, new ArrayList());
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void beforeCommit(boolean readOnly) {
                List items = (List) TransactionSynchronizationManager.getResource(bufferKey);
                if (!CollectionUtils.isEmpty(items)) {
                    if (!readOnly) {
                        doWrite(items);
                    }
                }
            }

            @Override
            public void afterCompletion(int status) {
                if (TransactionSynchronizationManager.hasResource(bufferKey)) {
                    TransactionSynchronizationManager.unbindResource(bufferKey);
                }
            }
        });
    }
    return (List) TransactionSynchronizationManager.getResource(bufferKey);
}
Example 82
Project: spring-integration-master  File: RedisStoreMessageSource.java View source code
/**
	 * Returns a Message with the view into a {@link RedisStore} identified
	 * by {@link #keyExpression}
	 */
@Override
@SuppressWarnings("unchecked")
public Message<RedisStore> receive() {
    String key = this.keyExpression.getValue(this.evaluationContext, String.class);
    Assert.hasText(key, "Failed to determine the key for the collection");
    RedisStore store = this.createStoreView(key);
    Object holder = TransactionSynchronizationManager.getResource(this);
    if (holder != null) {
        Assert.isInstanceOf(IntegrationResourceHolder.class, holder);
        ((IntegrationResourceHolder) holder).addAttribute("store", store);
    }
    if (store instanceof Collection<?> && ((Collection<Object>) store).size() < 1) {
        return null;
    } else {
        return this.getMessageBuilderFactory().withPayload(store).build();
    }
}
Example 83
Project: spring-master  File: SqlSessionTemplateTest.java View source code
@Test
public void testExecutorType() {
    SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory, ExecutorType.BATCH);
    assertThat(template.getExecutorType()).isEqualTo(ExecutorType.BATCH);
    DataSourceTransactionManager manager = new DataSourceTransactionManager(dataSource);
    TransactionStatus status = null;
    try {
        status = manager.getTransaction(new DefaultTransactionDefinition());
        // will synchronize the template with the current tx
        template.getConnection();
        SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sqlSessionFactory);
        assertThat(holder.getExecutorType()).isEqualTo(ExecutorType.BATCH);
    } finally {
        // rollback required to close connection
        txManager.rollback(status);
    }
}
Example 84
Project: spring-xd-master  File: JobLaunchingJobRepositoryFactoryBean.java View source code
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
    if (TransactionSynchronizationManager.isActualTransactionActive()) {
        throw new IllegalStateException("Existing transaction detected in JobRepository. " + "Please fix this and try again (e.g. " + "remove @Transactional annotations from " + "client).");
    }
    return invocation.proceed();
}
Example 85
Project: tcc-master  File: EasyTransSynchronizer.java View source code
/**
	 * create LogContext.<br>
	 * pass in busCode and trxId will help about the execute efficient and the debug and statistics<br>
	 * so I demand to pass in busCode and trxId to generate a global unique bus key 
	 * @param busCode the unique busCode in AppId
	 * @param trxId the unique trxId in appId+busCode
	 */
public void startSoftTrans(String busCode, String trxId) {
    Assert.notNull(busCode);
    Assert.notNull(trxId);
    //hook to TransactionSynchronizer
    TransactionSynchronizationManager.registerSynchronization(new TransactionHook());
    LogProcessContext logProcessContext = new LogProcessContext(config.getAppId(), busCode, trxId, writer, transStatusLogger);
    TransactionSynchronizationManager.bindResource(LOG_PROCESS_CONTEXT, logProcessContext);
    transStatusLogger.writeExecuteFlag(config.getAppId(), busCode, trxId);
}
Example 86
Project: spring-data-gemfire-master  File: GemfireTransactionManager.java View source code
/**
	 * @inheritDoc
	 */
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) throws TransactionException {
    try {
        CacheTransactionObject cacheTransaction = (CacheTransactionObject) transaction;
        GemFireCache cache = getCache();
        if (logger.isDebugEnabled()) {
            logger.debug(String.format("Acquired GemFire Cache [%s] for local cache transaction", cache));
        }
        CacheTransactionManager cacheTransactionManager = getCacheTransactionManager();
        // begin GemFire local cache transaction
        cacheTransactionManager.begin();
        TransactionId transactionId = cacheTransactionManager.getTransactionId();
        if (transactionId != null) {
            TransactionSynchronizationManager.bindResource(cache, cacheTransaction.setAndGetHolder(newCacheHolder(transactionId)));
        }
    } catch (IllegalStateException e) {
        throw new CannotCreateTransactionException(String.format("%1$s; %2$s", "An existing, ongoing transaction is already associated with the current thread", "are multiple transaction managers present?"), e);
    }
}
Example 87
Project: claudia-master  File: InitDbCloudProviders.java View source code
@Transactional
public void loadTestBedBCN() {
    LOGGER.info("  ");
    assert TransactionSynchronizationManager.isActualTransactionActive();
    List<CloudProvider> list = cloudProviderDao.findAll();
    LOGGER.info(" size of current cloudProviders:  " + list.size());
    if (list.size() != 0) {
        LOGGER.info(" ALREADY LOADED!! ");
        return;
    }
    /** 
		VEE vee1cp1 = new VEE();
		vee1cp1.setName("VEE1 EMOTIVE1");
		vee1cp1.setCost(10);
		MemoryConf mc=new MemoryConf();
		mc.setMemoryUnit(MemoryUnit.GB);
		mc.setQuantity(128);
		vee1cp1.setMemoryConf(mc);
		
        
        CloudProvider cp1 = new CloudProvider();
		cp1.setUri("http://84.21.173.26:8080/DRP");
		cp1.setName("EMOTIVE1");
		cp1.setVees(new HashSet<VEE>(Arrays.asList(new VEE[] {vee1cp1})));
		vee1cp1.setCloudProvider(cp1);				
		
		VEE vee1cp2 = new VEE();
		vee1cp2.setName("VEE1 EMOTIVE2");
		vee1cp2.setCost(20);		
		
        CloudProvider cp2 = new CloudProvider();
		cp2.setUri("http://84.21.173.27:8080/DRP");
		cp2.setName("EMOTIVE2");
		cp2.setVees(new HashSet<VEE>(Arrays.asList(new VEE[] {vee1cp2})));
		vee1cp2.setCloudProvider(cp2);			

		
		VEE vee1cp3 = new VEE();
		vee1cp3.setName("VEE1 ONE");
		vee1cp3.setCost(30);	

        CloudProvider cp3 = new CloudProvider();
		cp3.setUri("http://84.21.173.28:4567");
		cp3.setName("ONE");
		cp3.setVees(new HashSet<VEE>(Arrays.asList(new VEE[] {vee1cp3})));
		vee1cp3.setCloudProvider(cp3);
		// * ----------- temporal ------------------- *
		try {
			XMLEncoder encoder=new XMLEncoder(
					new BufferedOutputStream(new FileOutputStream("/tmp/mf.xml")));			
			encoder.writeObject(cp1);
			encoder.writeObject(vee1cp1);
			encoder.writeObject(cp2);
			encoder.writeObject(vee1cp2);
			encoder.writeObject(cp3);
			encoder.writeObject(vee1cp3);
			encoder.close();
		
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		// * ----------- fin temporal ------------------- *
        
		cloudProviderDao.save(cp1);
		cloudProviderDao.save(cp2);
		cloudProviderDao.save(cp3);

		
		LOGGER.info("loadTestBedBCN load end");
        

		**/
    /**/
    XmlCloudProviderHelper x = XmlCloudProviderHelper.getInstance();
    try {
        Set<CloudProvider> newcps = x.decode();
        for (CloudProvider cp : newcps) {
            System.out.println("cn.nombre: " + cp.getName());
            for (VEE vee : cp.getVees()) {
                System.out.println("....vee.nombre: " + vee.getName() + " --> " + vee.getCost());
            }
            System.out.flush();
            cloudProviderDao.save(cp);
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (UnsupportedDataTypeException e) {
        e.printStackTrace();
    }
/**/
}
Example 88
Project: droolsbook-master  File: JPAKnowledgeSessionTemplate.java View source code
private void execute(KnowledgeSessionCallback action, StatefulKnowledgeSession session) {
    LocalHTWorkItemHandler hTHandler = new LocalHTWorkItemHandler(localTaskService, session, true);
    try {
        registerWorkItemHandlers(session, hTHandler);
        action.execute(session);
    } finally {
        TransactionSynchronizationManager.registerSynchronization(new SessionCleanupTransactionSynchronisation(session, hTHandler));
    }
}
Example 89
Project: egovframe.rte.3.5-master  File: AbstractLobTypeHandler.java View source code
/**
	 * This implementation delegates to setParameterInternal,
	 * passing in a transaction-synchronized LobCreator for the
	 * LobHandler of this type.
	 * @see #setParameterInternal
	 */
public final void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType) throws SQLException {
    if (!TransactionSynchronizationManager.isSynchronizationActive()) {
        throw new IllegalStateException("Spring transaction synchronization needs to be active for " + "setting values in iBATIS TypeHandlers that delegate to a Spring LobHandler");
    }
    final LobCreator lobCreator = this.lobHandler.getLobCreator();
    try {
        setParameterInternal(ps, i, parameter, jdbcType, lobCreator);
    } catch (IOException ex) {
        throw new SQLException("I/O errors during LOB access: " + ex.getMessage());
    }
    TransactionSynchronizationManager.registerSynchronization(new LobCreatorSynchronization(lobCreator));
}
Example 90
Project: Gorm-master  File: HibernateCriteriaBuilder.java View source code
@Override
protected void createCriteriaInstance() {
    {
        if (TransactionSynchronizationManager.hasResource(sessionFactory)) {
            participate = true;
            hibernateSession = ((SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory)).getSession();
        } else {
            hibernateSession = sessionFactory.openSession();
        }
        criteria = hibernateSession.createCriteria(targetClass);
        cacheCriteriaMapping();
        criteriaMetaClass = GroovySystem.getMetaClassRegistry().getMetaClass(criteria.getClass());
    }
}
Example 91
Project: iaf-master  File: DestinationFactoryUtils.java View source code
/**
	 * Obtain a JMS String that is synchronized with the current transaction, if any.
	 * @param sapSystem the JMS SapSystem to bind for
	 * (used as TransactionSynchronizationManager key)
	 * @param resourceFactory the ResourceFactory to use for extracting or creating
	 * JMS resources
	 * @param startDestination whether the underlying JMS JCoDestination approach should be
	 * started in order to allow for receiving messages. Note that a reused JCoDestination
	 * may already have been started before, even if this flag is <code>false</code>.
	 * @return the transactional String, or <code>null</code> if none found
	 * @throws JCoException in case of failure
	 */
public static String doGetTransactionalTid(SapSystem sapSystem, ResourceFactory resourceFactory) throws JCoException {
    Assert.notNull(sapSystem, "SapSystem must not be null");
    Assert.notNull(resourceFactory, "ResourceFactory must not be null");
    JcoResourceHolder resourceHolder = (JcoResourceHolder) TransactionSynchronizationManager.getResource(sapSystem);
    if (resourceHolder != null) {
        String tid = resourceFactory.getTid(resourceHolder);
        if (tid != null) {
            return tid;
        }
        if (resourceHolder.isFrozen()) {
            return null;
        }
    }
    if (!TransactionSynchronizationManager.isSynchronizationActive()) {
        return null;
    }
    JcoResourceHolder resourceHolderToUse = resourceHolder;
    if (resourceHolderToUse == null) {
        resourceHolderToUse = new JcoResourceHolder(sapSystem);
    }
    JCoDestination destination = resourceFactory.getDestination(resourceHolderToUse);
    String tid = null;
    boolean isExistingDestination = (destination != null);
    if (!isExistingDestination) {
        destination = resourceFactory.createDestination();
        resourceHolderToUse.addDestination(destination);
    }
    tid = resourceFactory.createTid(destination);
    resourceHolderToUse.addTid(tid, destination);
    if (resourceHolderToUse != resourceHolder) {
        TransactionSynchronizationManager.registerSynchronization(new JcoResourceSynchronization(sapSystem, resourceHolderToUse, resourceFactory.isSynchedLocalTransactionAllowed()));
        resourceHolderToUse.setSynchronizedWithTransaction(true);
        TransactionSynchronizationManager.bindResource(sapSystem, resourceHolderToUse);
    }
    return tid;
}
Example 92
Project: jrails-master  File: OpenSessionInViewFilter.java View source code
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    SessionFactory sessionFactory = lookupSessionFactory(request);
    boolean participate = false;
    if (isSingleSession()) {
        // single session mode
        if (TransactionSynchronizationManager.hasResource(sessionFactory)) {
            // Do not modify the Session: just set the participate flag.
            participate = true;
        } else {
            logger.debug("Opening single Hibernate Session in OpenSessionInViewFilter");
            Session session = getSession(sessionFactory);
            TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
        }
    } else {
        // deferred close mode
        if (SessionFactoryUtils.isDeferredCloseActive(sessionFactory)) {
            // Do not modify deferred close: just set the participate flag.
            participate = true;
        } else {
            SessionFactoryUtils.initDeferredClose(sessionFactory);
        }
    }
    try {
        filterChain.doFilter(request, response);
    } finally {
        if (!participate) {
            if (isSingleSession()) {
                // single session mode
                SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.unbindResource(sessionFactory);
                logger.debug("Closing single Hibernate Session in OpenSessionInViewFilter");
                closeSession(sessionHolder.getSession(), sessionFactory);
            } else {
                // deferred close mode
                SessionFactoryUtils.processDeferredClose(sessionFactory);
            }
        }
    }
}
Example 93
Project: opennms_dashboard-master  File: TransactionAwareEventForwarder.java View source code
/**
     * <p>requestPendingEventsList</p>
     *
     * @return a {@link java.util.List} object.
     */
public List<Log> requestPendingEventsList() {
    PendingEventsHolder eventsHolder = (PendingEventsHolder) TransactionSynchronizationManager.getResource(m_eventForwarder);
    if (eventsHolder != null && (eventsHolder.hasPendingEvents() || eventsHolder.isSynchronizedWithTransaction())) {
        eventsHolder.requested();
        if (!eventsHolder.hasPendingEvents()) {
            eventsHolder.setPendingEventsList(new LinkedList<Log>());
        }
        return eventsHolder.getPendingEvents();
    }
    List<Log> pendingEvents = new LinkedList<Log>();
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        PendingEventsHolder holderToUse = eventsHolder;
        if (holderToUse == null) {
            holderToUse = new PendingEventsHolder(pendingEvents);
        } else {
            holderToUse.setPendingEventsList(pendingEvents);
        }
        holderToUse.requested();
        TransactionSynchronizationManager.registerSynchronization(new PendingEventsSynchronization(holderToUse, m_eventForwarder));
        holderToUse.setSynchronizedWithTransaction(true);
        if (holderToUse != eventsHolder) {
            TransactionSynchronizationManager.bindResource(m_eventForwarder, holderToUse);
        }
    }
    return pendingEvents;
}
Example 94
Project: rapid-framework-master  File: MockOpenSessionInViewFilter.java View source code
public void endFilter() {
    if (!participate) {
        if (isSingleSession()) {
            // single session mode
            SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.unbindResource(sessionFactory);
            logger.debug("Closing single Hibernate Session in OpenSessionInViewFilter");
            closeSession(sessionHolder.getSession(), sessionFactory);
        } else {
            // deferred close mode
            SessionFactoryUtils.processDeferredClose(sessionFactory);
        }
    }
}
Example 95
Project: unitils-master  File: HibernateModule.java View source code
@Override
protected Session doGetActivePersistenceContext(Object testObject) {
    SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(getPersistenceUnit(testObject));
    if (sessionHolder != null && sessionHolder.getSession() != null && sessionHolder.getSession().isOpen()) {
        return sessionHolder.getSession();
    }
    return null;
}
Example 96
Project: zenoss-zep-master  File: DaoCacheImpl.java View source code
private <T> int getIdFromName(final DaoTableCache<T> cache, final T name) {
    Integer cached = cache.getCache().getIdFromName(name);
    if (cached == null) {
        final int id = cache.insertOrSelect(name);
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void afterCommit() {
                cache.getCache().cache(name, id);
            }
        });
        cached = id;
    }
    return cached;
}
Example 97
Project: Fudan-Sakai-master  File: DbGlossary.java View source code
protected void updateCache(GlossaryEntry entry, boolean remove) {
    if (useCache) {
        GlossaryTxSync txSync = new GlossaryTxSync(entry, remove);
        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            TransactionSynchronizationManager.registerSynchronization(txSync);
        } else {
            txSync.afterCompletion(GlossaryTxSync.STATUS_COMMITTED);
        }
    }
}
Example 98
Project: Katari-master  File: TrailsModuleApplicationServlet.java View source code
/** Processes the request.
   *
   * This method implements the open session in view, opening a new hibernate
   * session when the request starts and closing the session on end.
   *
   * {@inheritDoc}
   */
public void service(final ServletRequest request, final ServletResponse response) throws ServletException, IOException {
    SessionFactory sessionFactory;
    sessionFactory = (SessionFactory) beanFactory.getBean("sessionFactory");
    Session session = null;
    // True if there was a previous hibernate session active. In that case, we
    // just leave it alone, efectively 'participating' in the existing session.
    boolean participate = false;
    // True if this is the first time we call this servlet in the current
    // request.
    boolean firstCall = false;
    // The name of the attribute to check if the request has already been
    // handled by this servlet. We open the hibernate session the first time
    // only.
    String alreadyHandled = getServletName() + ".SESSION_OPENED";
    // Check if we have already entered this servlet in the current request.
    if (null == request.getAttribute(alreadyHandled)) {
        request.setAttribute(alreadyHandled, "filtered");
        if (TransactionSynchronizationManager.hasResource(sessionFactory)) {
            // Do not modify the Session: just set the participate flag.
            participate = true;
        } else {
            log.debug("Opening single Hibernate Session in open session in view");
            session = getSession(sessionFactory);
            TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
        }
        firstCall = true;
    }
    /* This is due to a bug in tapestry 4.1.5: when rendenig the exception
     * page, tapestry iterates recursively over all request attributes. Katari
     * puts for convenience, an atribute named 'request' that contains the
     * servlet request. This makes tapestry iterate infinitely through the
     * attributes, causing a stack trace exception.
     *
     * The bug is in tapestry HttpServletRequestStrategy.describeObject.
     */
    Object savedRequest = request.getAttribute("request");
    request.removeAttribute("request");
    try {
        super.service(request, response);
    } finally {
        request.setAttribute("request", savedRequest);
        if (firstCall) {
            if (!participate) {
                TransactionSynchronizationManager.unbindResource(sessionFactory);
                log.debug("Closing single Hibernate session in open session in view");
                closeSession(session, sessionFactory);
            }
            request.removeAttribute(alreadyHandled);
        }
    }
}
Example 99
Project: openmicroscopy-master  File: SessionHandlerMockHibernateTest.java View source code
@Override
@BeforeMethod
protected void setUp() throws Exception {
    super.setUp();
    newDataSource();
    newConnection();
    newSession();
    newSessionFactory();
    handler = new SessionHandler(factory);
    // As of r2677 (ticket:1013) session close is delayed
    // to servicehandler cleanup. We are simulating this.
    handler.setApplicationContext(context);
    context.addApplicationListener(new ApplicationListener() {

        public void onApplicationEvent(ApplicationEvent arg0) {
            if (arg0 instanceof RegisterServiceCleanupMessage) {
                cleanups.add((RegisterServiceCleanupMessage) arg0);
            }
        }
    });
    // must call newXInvocation in test
    // these are reused unless otherwise noted
    newStateful();
    newStateless();
    // Things should always be cleaned up by handler/interceptor
    assertFalse(TransactionSynchronizationManager.hasResource(factory));
    if (!TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.initSynchronization();
    }
}
Example 100
Project: openmrs-maven-master  File: HibernateContextDAO.java View source code
public void openSession() {
    log.debug("HibernateContext: Opening Hibernate Session");
    if (TransactionSynchronizationManager.hasResource(sessionFactory)) {
        if (log.isDebugEnabled())
            log.debug("Participating in existing session (" + sessionFactory.hashCode() + ")");
        participate = true;
    } else {
        if (log.isDebugEnabled())
            log.debug("Registering session with synchronization manager (" + sessionFactory.hashCode() + ")");
        Session session = SessionFactoryUtils.getSession(sessionFactory, true);
        session.setFlushMode(FlushMode.MANUAL);
        TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
    }
}
Example 101
Project: sakai-cle-master  File: DbGlossary.java View source code
protected void updateCache(GlossaryEntry entry, boolean remove) {
    if (useCache) {
        GlossaryTxSync txSync = new GlossaryTxSync(entry, remove);
        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            TransactionSynchronizationManager.registerSynchronization(txSync);
        } else {
            txSync.afterCompletion(GlossaryTxSync.STATUS_COMMITTED);
        }
    }
}