public void commit(final Xid xid, final boolean onePhase) throws XAException { xaTerminator.commit(xid, onePhase); }
@Override public void commit(Xid xid, boolean onePhase) throws XAException { contextXATerminator.commit(xid, onePhase); }
@Override public void commit(Xid xid, boolean onePhase) throws XAException { contextXATerminator.commit(xid, onePhase); }
/** * @see javax.resource.spi.XATerminator */ public void commit(Xid xid, boolean onePhase) throws XAException { xat.commit(xid, onePhase); }
@Override public void commit(Xid xid, boolean onePhase) throws XAException { contextXATerminator.commit(xid, onePhase); }
public void commit(final Xid xid, final boolean onePhase) throws XAException { xaTerminator.commit(xid, onePhase); }
public void commit(final Xid xid, final boolean onePhase) throws XAException { xaTerminator.commit(xid, onePhase); }
/** * The participant should make permanent the work that it controls. * * @throws WrongStateException * @throws SystemException */ public void commit() throws WrongStateException, SystemException { txbridgeLogger.logger.trace("BridgeDurableParticipant.commit(Xid="+xid+")"); try { xaTerminator.commit(xid, false); txbridgeLogger.logger.trace("commit on Xid="+xid+" OK"); } catch (XAException e) { txbridgeLogger.i18NLogger.error_ibdp_commitfailed(XAHelper.xidToString(xid), e); } finally { cleanupRefs(); } }
/** * Global Transaction */ public void commit(final String threadId, XidImpl xid, boolean onePhase, boolean singleTM) throws XATransactionException { TransactionContext tc = checkXAState(threadId, xid, true, false); try { if (singleTM || (onePhase && XAResource.XA_RDONLY == prepare(threadId, xid, singleTM))) { return; //nothing to do } //TODO: we have no way of knowing for sure if we can safely use the onephase optimization this.xaTerminator.commit(tc.getXid(), false); } catch (XAException e) { throw new XATransactionException(QueryPlugin.Event.TEIID30507, e); } finally { this.transactions.removeTransactionContext(tc); } }
private void commitSubordinate() throws HeuristicException { final InboundBridge inboundBridge = getInboundBridge(); try { if (inboundBridge != null) { SubordinationManager.getXATerminator().commit(inboundBridge.getXid(), false); } } catch (XAException e) { LOG.warn(e.getMessage(), e); switch (e.errorCode) { case XAException.XA_HEURCOM: throw new HeuristicException(HeuristicType.HEURISTIC_COMMIT); case XAException.XA_HEURRB: throw new HeuristicException(HeuristicType.HEURISTIC_ROLLBACK); case XAException.XA_HEURMIX: throw new HeuristicException(HeuristicType.HEURISTIC_MIXED); case XAException.XA_HEURHAZ: throw new HeuristicException(HeuristicType.HEURISTIC_MIXED); } } }
@Test public void testOnePhaseCommitSyncViaXATerminator() throws Exception { final Xid xid = new XidImple(new Uid()); final Transaction t = SubordinationManager.getTransactionImporter().importTransaction(xid); final TestSynchronization sync = new TestSynchronization(); t.registerSynchronization(sync); final XATerminator xaTerminator = SubordinationManager.getXATerminator(); xaTerminator.commit(xid, true); assertTrue(sync.isBeforeCompletionDone()); assertTrue(sync.isAfterCompletionDone()); assertEquals(javax.transaction.Status.STATUS_COMMITTED, t.getStatus()); }
@Test public void testOnePhaseCommitSyncWithRollbackOnlyViaXATerminator() throws Exception { final Xid xid = new XidImple(new Uid()); final Transaction t = SubordinationManager.getTransactionImporter().importTransaction(xid); final TestSynchronization sync = new TestSynchronization(); t.registerSynchronization(sync); t.setRollbackOnly(); final XATerminator xaTerminator = SubordinationManager.getXATerminator(); try { xaTerminator.commit(xid, true); ((TransactionImple)t).doOnePhaseCommit(); fail("did not get expected rollback exception"); } catch(XAException e) { assertEquals("javax.transaction.RollbackException", e.getCause().getClass().getName()); assertEquals(XAException.XA_RBROLLBACK, e.errorCode); // expected - we tried to commit a rollbackonly tx. } assertFalse(sync.isBeforeCompletionDone()); assertTrue(sync.isAfterCompletionDone()); assertEquals(javax.transaction.Status.STATUS_ROLLEDBACK, t.getStatus()); }
@Test public void testOnePhaseCommitSyncViaXATerminatorWithSeparateSync() throws Exception { final Xid xid = new XidImple(new Uid()); final Transaction t = SubordinationManager.getTransactionImporter().importTransaction(xid); final TestSynchronization sync = new TestSynchronization(); t.registerSynchronization(sync); final XATerminator xaTerminator = SubordinationManager.getXATerminator(); final XATerminatorExtensions xaTerminatorExtensions = (XATerminatorExtensions)xaTerminator; xaTerminatorExtensions.beforeCompletion(xid); xaTerminator.commit(xid, true); assertTrue(sync.isBeforeCompletionDone()); assertTrue(sync.isAfterCompletionDone()); assertEquals(javax.transaction.Status.STATUS_COMMITTED, t.getStatus()); }
@Test public void testOnePhaseCommitSyncWithRollbackOnlyViaXATerminatorWithSeparateSync() throws Exception { final Xid xid = new XidImple(new Uid()); final Transaction t = SubordinationManager.getTransactionImporter().importTransaction(xid); final TestSynchronization sync = new TestSynchronization(); t.registerSynchronization(sync); t.setRollbackOnly(); final XATerminator xaTerminator = SubordinationManager.getXATerminator(); final XATerminatorExtensions xaTerminatorExtensions = (XATerminatorExtensions)xaTerminator; xaTerminatorExtensions.beforeCompletion(xid); try { xaTerminator.commit(xid, true); ((TransactionImple)t).doOnePhaseCommit(); fail("did not get expected rollback exception"); } catch(XAException e) { assertEquals("javax.transaction.RollbackException", e.getCause().getClass().getName()); assertEquals(XAException.XA_RBROLLBACK, e.errorCode); // expected - we tried to commit a rollbackonly tx. } assertTrue(sync.isBeforeCompletionDone()); assertTrue(sync.isAfterCompletionDone()); assertEquals(javax.transaction.Status.STATUS_ROLLEDBACK, t.getStatus()); }
@Test public void testFailOnCommitOnePhase () throws Exception { final Xid xid = new XidImple(new Uid()); final Transaction t = SubordinationManager.getTransactionImporter().importTransaction(xid); final TestXAResource xaResource = new TestXAResource(); // provoke commit into failing with TwoPhaseOutcome.FINISH_ERROR // warning: this is sensitive to the impl exception handling in // XAResourceRecord.topLevelCommit xaResource.setCommitException(new XAException(XAException.XA_HEURRB)); // should cause an exception! t.enlistResource(xaResource); final XATerminator xaTerminator = SubordinationManager.getXATerminator(); try { xaTerminator.commit(xid, true); } catch (final XAException ex) { // success! return; } assertTrue("commit should throw an exception and not get to here", false); }
@Test public void testTwoPhaseCommitSyncWithXAOKViaXATerminator() throws Exception { final Xid xid = new XidImple(new Uid()); final Transaction t = SubordinationManager.getTransactionImporter().importTransaction(xid); final TestSynchronization sync = new TestSynchronization(); t.registerSynchronization(sync); final TestXAResource xaResource = new TestXAResource(); xaResource.setPrepareReturnValue(XAResource.XA_OK); t.enlistResource(xaResource); final XATerminator xaTerminator = SubordinationManager.getXATerminator(); assertEquals(XAResource.XA_OK, xaTerminator.prepare(xid)); xaTerminator.commit(xid, false); assertTrue(sync.isBeforeCompletionDone()); assertTrue(sync.isAfterCompletionDone()); assertEquals(javax.transaction.Status.STATUS_COMMITTED, t.getStatus()); }
@Test public void testFailOnCommit() throws Exception { final Xid xid = new XidImple(new Uid()); final Transaction t = SubordinationManager.getTransactionImporter().importTransaction(xid); final TestXAResource xaResource = new TestXAResource(); // provoke commit into failing with TwoPhaseOutcome.FINISH_ERROR // warning: this is sensitive to the impl exception handling in // XAResourceRecord.topLevelCommit xaResource.setCommitException(new XAException(XAException.XA_HEURHAZ)); // throw a little spice into things! t.enlistResource(xaResource); final XATerminator xaTerminator = SubordinationManager.getXATerminator(); try { xaTerminator.prepare(xid); xaTerminator.commit(xid, false); } catch (final XAException ex) { // success!! return; } assertTrue("commit should throw an exception and not get to here", false); }
@Test public void testTwoPhaseCommitSyncWithXAOKViaXATerminatorWithSeparateSync() throws Exception { final Xid xid = new XidImple(new Uid()); final Transaction t = SubordinationManager.getTransactionImporter().importTransaction(xid); final TestSynchronization sync = new TestSynchronization(); t.registerSynchronization(sync); final TestXAResource xaResource = new TestXAResource(); xaResource.setPrepareReturnValue(XAResource.XA_OK); t.enlistResource(xaResource); final XATerminator xaTerminator = SubordinationManager.getXATerminator(); final XATerminatorExtensions xaTerminatorExtensions = (XATerminatorExtensions)xaTerminator; xaTerminatorExtensions.beforeCompletion(xid); assertEquals(XAResource.XA_OK, xaTerminator.prepare(xid)); xaTerminator.commit(xid, false); assertTrue(sync.isBeforeCompletionDone()); assertTrue(sync.isAfterCompletionDone()); assertEquals(javax.transaction.Status.STATUS_COMMITTED, t.getStatus()); }
xaTerminator.commit(xid, false); fail("Expected an error"); } catch (XAException e) {