public XATransactionContextImpl(NodeEngineImpl nodeEngine, Xid xid, String txOwnerUuid, int timeout, boolean originatedFromClient) { this.nodeEngine = nodeEngine; this.transaction = new XATransaction(nodeEngine, xid, txOwnerUuid, timeout, originatedFromClient); }
private void finalizeTransaction(XATransaction xaTransaction, ExecutionCallback callback) { if (isCommit) { xaTransaction.commitAsync(callback); } else { xaTransaction.rollbackAsync(callback); } }
public XATransactionDTO(XATransaction xaTransaction) { txnId = xaTransaction.getTxnId(); xid = xaTransaction.getXid(); ownerUuid = xaTransaction.getOwnerUuid(); timeoutMilis = xaTransaction.getTimeoutMillis(); startTime = xaTransaction.getStartTime(); records = xaTransaction.getTransactionRecords(); }
@Override public void prepare() throws TransactionException { if (state != ACTIVE) { throw new TransactionNotActiveException("Transaction is not active"); } checkTimeout(); try { state = PREPARING; List<Future> futures = transactionLog.prepare(nodeEngine); waitWithDeadline(futures, timeoutMillis, MILLISECONDS, RETHROW_TRANSACTION_EXCEPTION); futures.clear(); putTransactionInfoRemote(); state = PREPARED; } catch (Throwable e) { throw ExceptionUtil.rethrow(e, TransactionException.class); } }
public void commitAsync(ExecutionCallback callback) { if (state != PREPARED) { throw new IllegalStateException("Transaction is not prepared"); } checkTimeout(); state = COMMITTING; transactionLog.commitAsync(nodeEngine, callback); // We should rethrow exception if transaction is not TWO_PHASE state = COMMITTED; }
public void putTransaction(XATransaction transaction) { SerializableXID xid = transaction.getXid(); List<XATransaction> list = transactions.get(xid); if (list == null) { list = new CopyOnWriteArrayList<XATransaction>(); transactions.put(xid, list); } list.add(transaction); }
@Override public String getTxnId() { return transaction.getTxnId(); }
@SuppressWarnings("unchecked") @Override public TransactionalObject getTransactionalObject(String serviceName, String name) { if (transaction.getState() != Transaction.State.ACTIVE) { throw new TransactionNotActiveException("No transaction is found while accessing " + "transactional object -> " + serviceName + "[" + name + "]!"); } TransactionalObjectKey key = new TransactionalObjectKey(serviceName, name); TransactionalObject obj = txnObjectMap.get(key); if (obj != null) { return obj; } final Object service = nodeEngine.getService(serviceName); if (service instanceof TransactionalService) { nodeEngine.getProxyService().initializeDistributedObject(serviceName, name); obj = ((TransactionalService) service).createTransactionalObject(name, transaction); txnObjectMap.put(key, obj); } else { throw new IllegalArgumentException("Service[" + serviceName + "] is not transactional!"); } return obj; }
@Override public void prepare() throws TransactionException { if (state != ACTIVE) { throw new TransactionNotActiveException("Transaction is not active"); } checkTimeout(); try { state = PREPARING; List<Future> futures = transactionLog.prepare(nodeEngine); waitWithDeadline(futures, timeoutMillis, MILLISECONDS, RETHROW_TRANSACTION_EXCEPTION); futures.clear(); putTransactionInfoRemote(); state = PREPARED; } catch (Throwable e) { throw ExceptionUtil.rethrow(e, TransactionException.class); } }
public void commitAsync(ExecutionCallback callback) { if (state != PREPARED) { throw new IllegalStateException("Transaction is not prepared"); } checkTimeout(); state = COMMITTING; transactionLog.commitAsync(nodeEngine, callback); // We should rethrow exception if transaction is not TWO_PHASE state = COMMITTED; }
public void putTransaction(XATransaction transaction) { SerializableXID xid = transaction.getXid(); List<XATransaction> list = transactions.get(xid); if (list == null) { list = new CopyOnWriteArrayList<XATransaction>(); transactions.put(xid, list); } list.add(transaction); }
@Override public String getTxnId() { return transaction.getTxnId(); }
@SuppressWarnings("unchecked") @Override public TransactionalObject getTransactionalObject(String serviceName, String name) { if (transaction.getState() != Transaction.State.ACTIVE) { throw new TransactionNotActiveException("No transaction is found while accessing " + "transactional object -> " + serviceName + "[" + name + "]!"); } TransactionalObjectKey key = new TransactionalObjectKey(serviceName, name); TransactionalObject obj = txnObjectMap.get(key); if (obj != null) { return obj; } final Object service = nodeEngine.getService(serviceName); if (service instanceof TransactionalService) { nodeEngine.getProxyService().initializeDistributedObject(serviceName, name); obj = ((TransactionalService) service).createTransactionalObject(name, transaction); txnObjectMap.put(key, obj); } else { throw new IllegalArgumentException("Service[" + serviceName + "] is not transactional!"); } return obj; }
public XATransactionDTO(XATransaction xaTransaction) { txnId = xaTransaction.getTxnId(); xid = xaTransaction.getXid(); ownerUuid = xaTransaction.getOwnerUuid(); timeoutMilis = xaTransaction.getTimeoutMillis(); startTime = xaTransaction.getStartTime(); records = xaTransaction.getTransactionRecords(); }
private void finalizeTransaction(XATransaction xaTransaction, ExecutionCallback callback) { if (isCommit) { xaTransaction.commitAsync(callback); } else { xaTransaction.rollbackAsync(callback); } }
public XATransactionContextImpl(NodeEngineImpl nodeEngine, Xid xid, String txOwnerUuid, int timeout, boolean originatedFromClient) { this.nodeEngine = nodeEngine; this.transaction = new XATransaction(nodeEngine, xid, txOwnerUuid, timeout, originatedFromClient); }
@Override public void commit() throws TransactionException, IllegalStateException { if (state != PREPARED) { throw new IllegalStateException("Transaction is not prepared"); } checkTimeout(); try { state = COMMITTING; List<Future> futures = transactionLog.commit(nodeEngine); // We should rethrow exception if transaction is not TWO_PHASE waitWithDeadline(futures, COMMIT_TIMEOUT_MINUTES, MINUTES, commitExceptionHandler); state = COMMITTED; } catch (Throwable e) { state = COMMIT_FAILED; throw ExceptionUtil.rethrow(e, TransactionException.class); } }
@Override public void run() throws Exception { XAService xaService = getService(); NodeEngine nodeEngine = getNodeEngine(); XATransaction transaction = new XATransaction(nodeEngine, records, txnId, xid, txOwnerUuid, timeoutMillis, startTime); xaService.putTransaction(transaction); }
@Override public void commit() throws TransactionException, IllegalStateException { if (state != PREPARED) { throw new IllegalStateException("Transaction is not prepared"); } checkTimeout(); try { state = COMMITTING; List<Future> futures = transactionLog.commit(nodeEngine); // We should rethrow exception if transaction is not TWO_PHASE waitWithDeadline(futures, COMMIT_TIMEOUT_MINUTES, MINUTES, commitExceptionHandler); state = COMMITTED; } catch (Throwable e) { state = COMMIT_FAILED; throw ExceptionUtil.rethrow(e, TransactionException.class); } }
@Override public void run() throws Exception { XAService xaService = getService(); NodeEngine nodeEngine = getNodeEngine(); XATransaction transaction = new XATransaction(nodeEngine, records, txnId, xid, txOwnerUuid, timeoutMillis, startTime); xaService.putTransaction(transaction); }