/** * Create a new WS-AT Durable Participant which wraps the subordinate XA tx terminator. * * @param externalTxId the WS-AT Tx identifier * @param xid the Xid to use when driving the subordinate XA transaction. */ BridgeDurableParticipant(String externalTxId, Xid xid) { txbridgeLogger.logger.trace("BridgeDurableParticipant.<ctor>(TxId="+externalTxId+", Xid="+xid+")"); this.xid = xid; this.externalTxId = externalTxId; xaTerminator = SubordinationManager.getXATerminator(); }
/** * Create a new WS-AT Volatile Participant which wraps the subordinate XA tx terminator. * * @param externalTxId the WS-AT Tx identifier * @param xid the Xid to use when driving the subordinate XA transaction. */ BridgeVolatileParticipant(String externalTxId, Xid xid) { txbridgeLogger.logger.trace("BridgeVolatileParticipant.<ctor>(TxId="+externalTxId+", Xid="+xid+")"); this.xid = xid; this.externalTxId = externalTxId; this.xaTerminatorExtensions = (XATerminatorExtensions)SubordinationManager.getXATerminator(); }
public Xid[] getXidsToRecoverForParentNode(boolean recoverInFlight, String parentNodeName, int recoveryFlags) throws XAException { final Set<Xid> xidsToRecover = new HashSet<Xid>(); if (recoverInFlight) { final TransactionImporter transactionImporter = SubordinationManager.getTransactionImporter(); if (transactionImporter instanceof TransactionImporterImple) { throw new UnsupportedOperationException(jtaxLogger.i18NLogger.get_not_supported()); } } final javax.resource.spi.XATerminator xaTerminator = SubordinationManager.getXATerminator(); if (xaTerminator instanceof XATerminatorImple) { throw new UnsupportedOperationException(jtaxLogger.i18NLogger.get_not_supported()); } else { final Xid[] inDoubtTransactions = xaTerminator.recover(recoveryFlags); if (inDoubtTransactions != null) { xidsToRecover.addAll(Arrays.asList(inDoubtTransactions)); } } return xidsToRecover.toArray(NO_XIDS); }
public Xid[] getXidsToRecoverForParentNode(boolean recoverInFlight, String parentNodeName, int recoveryFlags) throws XAException { final Set<Xid> xidsToRecover = new HashSet<Xid>(); if (recoverInFlight) { final TransactionImporter transactionImporter = SubordinationManager.getTransactionImporter(); if (transactionImporter instanceof TransactionImporterImple) { final Set<Xid> inFlightXids = ((TransactionImporterImple) transactionImporter).getInflightXids(parentNodeName); if (inFlightXids != null) { xidsToRecover.addAll(inFlightXids); } } } final javax.resource.spi.XATerminator xaTerminator = SubordinationManager.getXATerminator(); if (xaTerminator instanceof XATerminatorImple) { final Xid[] inDoubtTransactions = ((XATerminatorImple) xaTerminator).doRecover(null, parentNodeName); if (inDoubtTransactions != null) { xidsToRecover.addAll(Arrays.asList(inDoubtTransactions)); } } else { final Xid[] inDoubtTransactions = xaTerminator.recover(recoveryFlags); if (inDoubtTransactions != null) { xidsToRecover.addAll(Arrays.asList(inDoubtTransactions)); } } return xidsToRecover.toArray(NO_XIDS); }
/** * Adds bridges with active REST-AT to inbound bridge manager's mapping. * Rollback subordinate transaction, if bridge cannot be added. */ private void addBridgesToMapping() { if (LOG.isTraceEnabled()) { LOG.trace("InboundBridgeRecoveryModule.addBridgesToMapping"); } final InboundBridgeManager inboundBridgeManager = InboundBridgeManager.getInstance(); for (final InboundBridge bridge : recoveredBridges) { if (!inboundBridgeManager.addInboundBridge(bridge)) { final XATerminator xaTerminator = SubordinationManager.getXATerminator(); try { xaTerminator.rollback(bridge.getXid()); } catch (XAException e) { LOG.warn(e.getMessage(), e); } } } }
private Vote prepareSubordinate() { final InboundBridge inboundBridge = getInboundBridge(); int prepareResult = -1; try { if (inboundBridge != null) { prepareResult = SubordinationManager.getXATerminator().prepare(inboundBridge.getXid()); } } catch (XAException e) { } return prepareResultToVote(prepareResult); }
private void rollbackSubordinate() throws HeuristicException { final InboundBridge inboundBridge = getInboundBridge(); try { if (inboundBridge != null) { SubordinationManager.getXATerminator().rollback(inboundBridge.getXid()); } } 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); } } }
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 testRollbackSyncViaXATerminator() 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.rollback(xid); assertFalse(sync.isBeforeCompletionDone()); assertTrue(sync.isAfterCompletionDone()); assertEquals(javax.transaction.Status.STATUS_ROLLEDBACK, t.getStatus()); }
@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 testRollbackSyncViaXATerminatorWithSeparateSync() 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.rollback(xid); assertTrue(sync.isBeforeCompletionDone()); assertTrue(sync.isAfterCompletionDone()); assertEquals(javax.transaction.Status.STATUS_ROLLEDBACK, t.getStatus()); }
@Test public void testTwoPhaseCommitSyncViaXATerminator() 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(); assertEquals(XAResource.XA_RDONLY, xaTerminator.prepare(xid)); // don't call commit for read only case assertTrue(sync.isBeforeCompletionDone()); assertTrue(sync.isAfterCompletionDone()); assertEquals(javax.transaction.Status.STATUS_COMMITTED, 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 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 testTwoPhaseCommitSyncViaXATerminatorWithSeparateSync() 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); assertEquals(XAResource.XA_RDONLY, xaTerminator.prepare(xid)); // don't call commit for read only case assertTrue(sync.isBeforeCompletionDone()); assertTrue(sync.isAfterCompletionDone()); assertEquals(javax.transaction.Status.STATUS_COMMITTED, t.getStatus()); }
@Test public void testTwoPhaseCommitSyncWithRollbackOnlyViaXATerminator() 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.prepare(xid); } catch(XAException e) { assertEquals(XAException.XA_RBROLLBACK, e.errorCode); // expected - we tried to prepare a rollbackonly tx. } // no need to call rollback - the XA_RBROLLBACK code indicates its been done. assertFalse(sync.isBeforeCompletionDone()); assertTrue(sync.isAfterCompletionDone()); assertEquals(javax.transaction.Status.STATUS_ROLLEDBACK, t.getStatus()); }
@Test public void testTwoPhaseCommitSyncWithRollbackOnlyViaXATerminatorWithSeparateSync() 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.prepare(xid); } catch(XAException e) { assertEquals(XAException.XA_RBROLLBACK, e.errorCode); // expected - we tried to prepare a rollbackonly tx. } // no need to call rollback - the XA_RBROLLBACK code indicates its been done. assertTrue(sync.isBeforeCompletionDone()); assertTrue(sync.isAfterCompletionDone()); assertEquals(javax.transaction.Status.STATUS_ROLLEDBACK, t.getStatus()); }
@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 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 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()); }