Refine search
protected TransactionManager startTxIfNeeded(Environment environment) { try { if (hasEnvironmentEntry(environment, "IS_TIMER_CMT", true)) { return null; } if (environment.get(EnvironmentName.TRANSACTION_MANAGER) instanceof ContainerManagedTransactionManager) { TransactionManager tm = TransactionManagerFactory.get().newTransactionManager(); if (tm.begin()) { return tm; } } } catch (Exception e) { logger.debug("Unable to optionally start transaction due to {}", e.getMessage(), e); } return null; }
public <T> T execute(Command<T> command) { boolean transactionOwner = false; boolean emOwner = false; T result = null; try { transactionOwner = txm.begin(); EntityManager em = getEntityManager(command); if (em == null) { em = emf.createEntityManager(); emOwner = true; } JpaPersistenceContext context = new JpaPersistenceContext(em); context.joinTransaction(); result = ((ExecutableCommand<T>)command).execute( context ); txm.commit( transactionOwner ); context.close(transactionOwner, emOwner); return result; } catch ( RuntimeException re ) { rollbackTransaction( re, transactionOwner ); throw re; } catch ( Exception t1 ) { rollbackTransaction( t1, transactionOwner ); throw new RuntimeException( "Wrapped exception see cause", t1 ); } }
protected EntityManager getEntityManagerFromTransaction(Environment env) { if (env.get(EnvironmentName.TRANSACTION_MANAGER) instanceof TransactionManager) { TransactionManager txm = (TransactionManager) env.get(EnvironmentName.TRANSACTION_MANAGER); EntityManager em = (EntityManager) txm.getResource(EnvironmentName.CMD_SCOPED_ENTITY_MANAGER); return em; } return null; }
protected <R> R call(Function<EntityManager, R> function) { boolean transactionOwner = false; try { transactionOwner = txm.begin(); EntityManager em = emf.createEntityManager(); R result = function.apply(em); txm.commit( transactionOwner ); em.close(); return result; } catch (Exception e) { txm.rollback(transactionOwner); throw new RuntimeException( "Exception when persisting error information", e); } }
protected EventCollection getCollection() { EventCollection collection = (EventCollection) this.tm.getResource(EVENT_COLLECTION); if (collection == null) { collection = emitter.newCollection(); this.tm.putResource(EVENT_COLLECTION, collection); registerSync(); } return collection; }
@Override public Void execute(org.kie.api.runtime.Context context) { if (manager.hasEnvironmentEntry("IS_JTA_TRANSACTION", false)) { initialKsession.dispose(); return null; } TransactionManager tm = (TransactionManager) initialKsession.getEnvironment().get(EnvironmentName.TRANSACTION_MANAGER); if (tm != null && tm.getStatus() != TransactionManager.STATUS_NO_TRANSACTION && tm.getStatus() != TransactionManager.STATUS_ROLLEDBACK && tm.getStatus() != TransactionManager.STATUS_COMMITTED) { TransactionManagerHelper.registerTransactionSyncInContainer(tm, new OrderedTransactionSynchronization(5, "PPIRM-" + initialKsession.getIdentifier()) { @Override public void beforeCompletion() { } @Override public void afterCompletion(int arg0) { initialKsession.dispose(); } }); } else { initialKsession.dispose(); } return null; } }
@Override public Void execute(org.kie.api.runtime.Context context) { TransactionManager tm = (TransactionManager) initialKsession.getEnvironment().get(EnvironmentName.TRANSACTION_MANAGER); if (manager.hasEnvironmentEntry("IS_JTA_TRANSACTION", false)) { if (initialKsession instanceof CommandBasedStatefulKnowledgeSession) { ((SingleSessionCommandService) commandService).destroy(); } else { ((RegistryContext) context).lookup( KieSession.class ).destroy(); if (tm != null && tm.getStatus() != TransactionManager.STATUS_NO_TRANSACTION && tm.getStatus() != TransactionManager.STATUS_ROLLEDBACK && tm.getStatus() != TransactionManager.STATUS_COMMITTED) { TransactionManagerHelper.registerTransactionSyncInContainer(tm, new OrderedTransactionSynchronization(5, "PPIRM-"+initialKsession.getIdentifier()) {
if (environment.usePersistence()){ tm = getTransactionManagerInternal(environment.getEnvironment()); owner = tm.begin(); initialKsession.execute(new ExecutableCommand<Void>() { private static final long serialVersionUID = 1L; factory.onDispose(initialKsession.getIdentifier()); initialKsession.execute(new DestroyKSessionCommand(initialKsession, this)); tm.commit(owner); tm.rollback(owner);
TransactionManager tm = (TransactionManager) ksession.getEnvironment().get(EnvironmentName.TRANSACTION_MANAGER); txStatus = tm.getStatus(); ksession.dispose(); logger.debug("KieSession disposed {}", ksession); } else { tm.registerTransactionSynchronization(new TransactionSynchronization() {
InternalRuntimeManager toBeManager = (InternalRuntimeManager) RuntimeManagerRegistry.get().getManager(migrationSpec.getToDeploymentId()); boolean migrateExecutorJobs = ((SimpleRuntimeEnvironment)currentManager.getEnvironment()).getEnvironmentTemplate().get("ExecutorService") != null; validate(migrateExecutorJobs); Map<Long, List<TimerInstance>> timerMigrated = null; transactionOwner = txm.begin(); txm.commit(transactionOwner); report.addEntry(Type.INFO, "Migration of process instance (" + migrationSpec.getProcessInstanceId() + ") completed successfully to process " + migrationSpec.getToProcessId()); report.setSuccessful(true); report.setEndDate(new Date()); } catch (Throwable e) { txm.rollback(transactionOwner); logger.error("Unexpected error during migration", e); if (current != null) { try { current.destroy(); } catch (SessionNotFoundException e) { tobe.destroy(); } catch (SessionNotFoundException e) {
public EntityManager getApplicationScopedEntityManager() { if ( this.appScopedEntityManager == null ) { // Use the App scoped EntityManager if the user has provided it, and it is open. this.appScopedEntityManager = (EntityManager) this.env.get( EnvironmentName.APP_SCOPED_ENTITY_MANAGER ); if ( this.appScopedEntityManager != null && !this.appScopedEntityManager.isOpen() ) { throw new RuntimeException("Provided APP_SCOPED_ENTITY_MANAGER is not open"); } if ( this.appScopedEntityManager == null ) { internalAppScopedEntityManagerFlag = true; this.appScopedEntityManager = this.emf.createEntityManager(); this.env.set( EnvironmentName.APP_SCOPED_ENTITY_MANAGER, this.appScopedEntityManager ); if (txm.getStatus() == TransactionManager.STATUS_ACTIVE) { this.txm.putResource(EnvironmentName.APP_SCOPED_ENTITY_MANAGER, this.appScopedEntityManager ); } } else { internalAppScopedEntityManagerFlag = false; } } return appScopedEntityManager; }
transactionOwner = txm.begin(); tpm.beginCommandScopedEntityManager(); TransactionManagerHelper.registerTransactionSyncInContainer(this.txm, new TaskSynchronizationImpl( this )); ObjectMarshallingStrategy[] strategies = (ObjectMarshallingStrategy[]) environment.get(EnvironmentName.OBJECT_MARSHALLING_STRATEGIES); if (strategies != null) { for (ObjectMarshallingStrategy strategy : strategies) { txm.commit( transactionOwner );
public EntityManager getCommandScopedEntityManager() { // first check if there is already cmd scoped entity manager as transactional resource EntityManager cmdScopedEntityManager = getInternalCommandScopedEntityManager(); if ( cmdScopedEntityManager == null) { cmdScopedEntityManager = (EntityManager) env.get( EnvironmentName.CMD_SCOPED_ENTITY_MANAGER ); if (cmdScopedEntityManager != null) { this.txm.putResource(EnvironmentName.CMD_SCOPED_ENTITY_MANAGER, cmdScopedEntityManager ); } if ( cmdScopedEntityManager == null) { internalCmdScopedEntityManagerFlag = true; cmdScopedEntityManager = this.emf.createEntityManager(); // no need to call joinTransaction as it will do so if one already exists this.env.set( EnvironmentName.CMD_SCOPED_ENTITY_MANAGER, cmdScopedEntityManager ); this.txm.putResource(EnvironmentName.CMD_SCOPED_ENTITY_MANAGER, cmdScopedEntityManager ); } else { internalCmdScopedEntityManagerFlag = false; } } cmdScopedEntityManager.joinTransaction(); if (this.appScopedEntityManager != null) { this.appScopedEntityManager.joinTransaction(); } return cmdScopedEntityManager; }
protected boolean canDestroy(RuntimeEngine runtime) { if (((RuntimeEngineImpl) runtime).isAfterCompletion()) { return false; } TransactionManager tm = getTransactionManager(runtime.getKieSession().getEnvironment()); if (tm.getStatus() == TransactionManager.STATUS_NO_TRANSACTION || tm.getStatus() == TransactionManager.STATUS_ACTIVE) { return true; } return false; }
javax.transaction.TransactionManager tm = (javax.transaction.TransactionManager) env.get( EnvironmentName.TRANSACTION_MANAGER ); TransactionManager txm = new JtaTransactionManager( env.get( EnvironmentName.TRANSACTION ), env.get( EnvironmentName.TRANSACTION_SYNCHRONIZATION_REGISTRY ), tm ); try { boolean txOwner = txm.begin(); boolean notTxOwner = txm.begin(); Serializable s = generateId(mainObject); mainObject.setId(Long.valueOf(s.toString())); cache.put(s, mainObject); txm.commit(notTxOwner); subObject.setId(Long.valueOf(s2.toString())); cache.put(s2, subObject); txm.commit(txOwner);
@Test public void basicTransactionRollbackTest() { Environment env = createEnvironment(context); //TransactionManager txm = (TransactionManager) env.get( EnvironmentName.TRANSACTION_MANAGER ); javax.transaction.TransactionManager tm = (javax.transaction.TransactionManager) env.get( EnvironmentName.TRANSACTION_MANAGER ); TransactionManager txm = new JtaTransactionManager( env.get( EnvironmentName.TRANSACTION ), env.get( EnvironmentName.TRANSACTION_SYNCHRONIZATION_REGISTRY ), tm ); // Create linked transactionTestObjects TransactionTestObject mainObject = new TransactionTestObject(); mainObject.setName("main"); TransactionTestObject subObject = new TransactionTestObject(); subObject.setName("sub"); mainObject.setSubObject(subObject); Cache<Serializable, Object> cache = cm.getCache("jbpm-configured-cache"); try { boolean notTxOwner = txm.begin(); Serializable s = generateId(mainObject); mainObject.setId(Long.valueOf(s.toString())); cache.put(s, mainObject); txm.rollback(notTxOwner); } catch ( Exception e ) { fail("There should not be an exception thrown here: " + e.getMessage()); } }
@Override public void beforeCompletion() { Set<Transformable> toBeUpdated = TransactionManagerHelper.getUpdateableSet(txm); EntityManager appScopedEM = ((EntityManager)environment.get(EnvironmentName.APP_SCOPED_ENTITY_MANAGER)); if (appScopedEM == null) { appScopedEM = (EntityManager) txm.getResource(EnvironmentName.APP_SCOPED_ENTITY_MANAGER); EntityManager cmdScopedEM = (EntityManager) txm.getResource(EnvironmentName.CMD_SCOPED_ENTITY_MANAGER); if (cmdScopedEM == null) { cmdScopedEM = ((EntityManager)environment.get(EnvironmentName.CMD_SCOPED_ENTITY_MANAGER)); TransactionManagerHelper.removeFromUpdatableSet(txm, transformable); flushApp = true; } else if (cmdScopedEM != null &&cmdScopedEM.contains(transformable)) { TransactionManagerHelper.removeFromUpdatableSet(txm, transformable); flushCmd = true;
protected boolean allowedToDispose(Environment environment) { if (hasEnvironmentEntry(environment, "IS_JTA_TRANSACTION", false)) { return true; } TransactionManager transactionManager = null; Object txm = environment.get(EnvironmentName.TRANSACTION_MANAGER); if (txm != null && txm instanceof TransactionManager) { transactionManager = (TransactionManager) txm; } else { transactionManager = TransactionManagerFactory.get().newTransactionManager(); } int status = transactionManager.getStatus(); if (status != TransactionManager.STATUS_NO_TRANSACTION && status != TransactionManager.STATUS_ROLLEDBACK && status != TransactionManager.STATUS_COMMITTED) { return false; } return true; }
public void dispose() { resetApplicationScopedPersistenceContext(); if ( this.internalCmdScopedEntityManagerFlag ) { EntityManager cmdScopedEntityManager = getInternalCommandScopedEntityManager(); if ( cmdScopedEntityManager != null && cmdScopedEntityManager.isOpen() ) { cmdScopedEntityManager.close(); } this.env.set( EnvironmentName.CMD_SCOPED_ENTITY_MANAGER, null ); this.txm.putResource(EnvironmentName.CMD_SCOPED_ENTITY_MANAGER, null ); this.internalCmdScopedEntityManagerFlag = false; } }