/** * Specify the transaction timeout to use for transactional wrapping, in <b>seconds</b>. * Default is none, using the transaction manager's default timeout. * @see org.springframework.transaction.TransactionDefinition#getTimeout() * @see #setReceiveTimeout */ public void setTransactionTimeout(int transactionTimeout) { this.transactionDefinition.setTimeout(transactionTimeout); }
/** * Gets DB transaction isolation level based on ongoing cache transaction isolation. * * @return DB transaction isolation. */ private TransactionDefinition definition(Transaction tx, String cacheName) { assert tx != null; DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.setName("Ignite Tx [cache=" + (cacheName != null ? cacheName : "<default>") + ", id=" + tx.xid() + ']'); def.setIsolationLevel(isolationLevel(tx.isolation())); long timeoutSec = (tx.timeout() + 500) / 1000; if (timeoutSec > 0 && timeoutSec < Integer.MAX_VALUE) def.setTimeout((int)timeoutSec); return def; }
@Test public void newTransactionWithCommitAndTimeout() { MockUOWManager manager = new MockUOWManager(); WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager); DefaultTransactionDefinition definition = new DefaultTransactionDefinition(); definition.setTimeout(10); definition.setReadOnly(true); assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); assertFalse(TransactionSynchronizationManager.isActualTransactionActive()); assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly()); assertEquals("result", ptm.execute(definition, new TransactionCallback<String>() { @Override public String doInTransaction(TransactionStatus status) { assertTrue(TransactionSynchronizationManager.isSynchronizationActive()); assertTrue(TransactionSynchronizationManager.isActualTransactionActive()); assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly()); return "result"; } })); assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); assertFalse(TransactionSynchronizationManager.isActualTransactionActive()); assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly()); assertEquals(10, manager.getUOWTimeout()); assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType()); assertFalse(manager.getJoined()); assertFalse(manager.getRollbackOnly()); }
/** * Specify the transaction timeout to use for transactional wrapping, in <b>seconds</b>. * Default is none, using the transaction manager's default timeout. * @see org.springframework.transaction.TransactionDefinition#getTimeout() * @see #setReceiveTimeout */ public void setTransactionTimeout(int transactionTimeout) { this.transactionDefinition.setTimeout(transactionTimeout); }
private void setTimeout(final DefaultTransactionDefinition definition, final int timeout) { if (timeout >= 0) { definition.setTimeout(timeout); } }
/** * Specify the transaction timeout to use for transactional wrapping, in <b>seconds</b>. * Default is none, using the transaction manager's default timeout. * @see org.springframework.transaction.TransactionDefinition#getTimeout() * @see #setReceiveTimeout */ public void setTransactionTimeout(int transactionTimeout) { this.transactionDefinition.setTimeout(transactionTimeout); }
/** * Specify the transaction timeout to use for transactional wrapping, in <b>seconds</b>. * Default is none, using the transaction manager's default timeout. * @see org.springframework.transaction.TransactionDefinition#getTimeout() * @see #setReceiveTimeout */ public void setTransactionTimeout(int transactionTimeout) { this.transactionDefinition.setTimeout(transactionTimeout); }
public void setTransactionTimeout(int timeout) throws SystemException { if (TransactionSynchronizationManager.isActualTransactionActive()) { // cannot set timeout on already running transaction return; } definition.setTimeout(timeout); }
@Bean public TransactionTemplate transactionTemplate( PlatformTransactionManager transactionManager) { DefaultTransactionDefinition td = new DefaultTransactionDefinition(); td.setTimeout(30); return new TransactionTemplate(transactionManager, td); }
transactionDefinition.setTimeout(200);
/** * Parse a "transactional" element and configure the "transactionManager" and "transactionDefinition" * properties for the target builder. */ private void configureTransactionAttributes(Element txElement, BeanDefinitionBuilder targetBuilder) { targetBuilder.addPropertyReference("transactionManager", txElement.getAttribute("transaction-manager")); DefaultTransactionDefinition txDefinition = new DefaultTransactionDefinition(); txDefinition.setPropagationBehaviorName( DefaultTransactionDefinition.PREFIX_PROPAGATION + txElement.getAttribute("propagation")); txDefinition.setIsolationLevelName( DefaultTransactionDefinition.PREFIX_ISOLATION + txElement.getAttribute("isolation")); txDefinition.setTimeout(Integer.valueOf(txElement.getAttribute("timeout"))); txDefinition.setReadOnly(txElement.getAttribute("read-only").equalsIgnoreCase("true")); targetBuilder.addPropertyValue("transactionDefinition", txDefinition); }
public static TransactionStatus getTransaction(JtaTransactionManager jtaTransactionManager){ DefaultTransactionDefinition definition = new DefaultTransactionDefinition(); definition.setTimeout(-1); TransactionStatus transactionStatus =jtaTransactionManager.getTransaction(definition); return transactionStatus; }
public void start() throws Exception { LOG.info("Starting a transaction from TransactionalLifecycle..."); DefaultTransactionDefinition defaultTransactionDefinition = new DefaultTransactionDefinition(); defaultTransactionDefinition.setTimeout(3600); TRANSACTION_STATUS = getTransactionManager().getTransaction(defaultTransactionDefinition); started = true; }
private void beginTxn(TransactionContext transactionContext) { try { if( transactionContext.getTransactionStatus() == null ){ if (logger.isDebugEnabled()) { logger.debug("beginTxn(ProcessContext) - beginTxn"); } DefaultTransactionDefinition txnDefinition = new DefaultTransactionDefinition(DefaultTransactionDefinition.PROPAGATION_REQUIRED); if(timeout>0){ txnDefinition.setTimeout(timeout); } TransactionStatus txnStatus = platformTransactionManager.getTransaction(txnDefinition); // logger.debug("TransactionStatus.isCompleted "+txnStatus.isCompleted()); transactionContext.setTransactionStatus(txnStatus); } } catch( Exception e ) { logger.error("beginTxn(ServiceContext)", e); //$NON-NLS-1$ } } private void commitTxn(TransactionContext transactionContext){
/** * The constructor. * * @param settings are the settings to use. */ public SpringTransactionAdapter(TransactionSettings settings) { super(); this.transactionDefinition = new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRED); if (settings.getIsolationLevel() != null) { this.transactionDefinition.setIsolationLevel(settings.getIsolationLevel().getJdbcCode()); } if (settings.getTimeout() != null) { this.transactionDefinition.setTimeout(settings.getTimeout().intValue()); } }
int timeout = session.getSettings().getSettingAsInt(CompassEnvironment.Transaction.TRANSACTION_TIMEOUT, -1); if (timeout != -1) { transactionDefinition.setTimeout(timeout);
@Override public <T> T execute(final Function<Session, T> callback) { try { DefaultTransactionDefinition definition = new DefaultTransactionDefinition(); definition.setIsolationLevel(getTransactionIsolation().getTransactionIsolation()); int timeout = getTimeout(); if (timeout >= 0) { definition.setTimeout(timeout); } definition.setReadOnly(isReadOnly()); return connectionProvider.connection(false, connection -> { Session session = newSession(connection); TransactionTemplate tt = new TransactionTemplate(platformTransactionManager, definition); return tt.execute(transactionStatus -> callback.apply(session)); }); } catch (final Exception e) { throw JdbcTemplateExceptionTranslator.doTranslate(e); } }
public TransactionImpl(PlatformTransactionManager transactionManager, PersistenceImpl persistence, boolean join, @Nullable TransactionParams params, String storeName) { this.tm = transactionManager; this.persistence = persistence; this.storeName = storeName; log.trace("Creating transaction: store='{}' join={} params={}", storeName, join, params); td = new DefaultTransactionDefinition(); if (join) td.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); else td.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); if (params != null) { if (params.getTimeout() != 0) td.setTimeout(params.getTimeout()); if (params.isReadOnly()) td.setReadOnly(true); } ts = tm.getTransaction(td); persistence.registerSynchronizations(storeName); }
/** * Gets DB transaction isolation level based on ongoing cache transaction isolation. * * @return DB transaction isolation. */ private TransactionDefinition definition(Transaction tx, String cacheName) { assert tx != null; DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.setName("Ignite Tx [cache=" + (cacheName != null ? cacheName : "<default>") + ", id=" + tx.xid() + ']'); def.setIsolationLevel(isolationLevel(tx.isolation())); long timeoutSec = (tx.timeout() + 500) / 1000; if (timeoutSec > 0 && timeoutSec < Integer.MAX_VALUE) def.setTimeout((int)timeoutSec); return def; }