@Override public void close() throws Exception { if (transactionChain != null) { transactionChain.close(); } }
WriteTransaction beginTransaction() { return chain.newWriteOnlyTransaction(); }
ReadWriteTransaction rwTransaction() { return chain.newReadWriteTransaction(); }
@Override public void close() throws Exception { final WriteTransaction wTx = txChain.newWriteOnlyTransaction(); wTx.delete(LogicalDatastoreType.CONFIGURATION, BGP_IID); wTx.submit().checkedGet(); txChain.close(); }
final ReadWriteTransaction tx = transactionChain.newReadWriteTransaction(); } catch (final IllegalStateException e) { LOG.warn("Stat DataStoreOperation unexpected State!", e); transactionChain.close(); transactionChain = dataBroker.createTransactionChain(this); cleanDataStoreOperQueue();
<T extends DataObject> ListenableFuture<Optional<T>> readOperationalData(final InstanceIdentifier<T> id) { try (final ReadOnlyTransaction t = chain.newReadOnlyTransaction()) { return t.read(LogicalDatastoreType.OPERATIONAL, id); } }
@Override public void close() { this.rpcRegistration.close(); final WriteTransaction dTx = this.txChain.newWriteOnlyTransaction(); dTx.delete(LogicalDatastoreType.CONFIGURATION, this.iid); try { dTx.submit().checkedGet(); } catch (final TransactionCommitFailedException e) { LOG.warn("Failed to clean-up BGP Application RIB.", e); } this.txChain.close(); LOG.info("BGP Application Peer Benchmark Application closed."); }
try { StatDataStoreOperation op = dataStoreOperQueue.take(); final ReadWriteTransaction tx = txChain.newReadWriteTransaction(); LOG.trace("New operations available, starting transaction {}", tx.getIdentifier()); } catch (final Exception e) { LOG.warn("Unhandled exception during processing statistics. Restarting transaction chain.", e); txChain.close(); txChain = dataBroker.createTransactionChain(StatisticsManagerImpl.this); cleanDataStoreOperQueue();
private <U extends org.opendaylight.yangtools.yang.binding.DataObject> U readTransaction( InstanceIdentifier<U> readIID, LogicalDatastoreType logicalDatastoreType) { ReadOnlyTransaction readTx = txChain.newReadOnlyTransaction(); CheckedFuture<Optional<U>, ReadFailedException> readFuture = readTx.read(logicalDatastoreType, readIID); readTx.close(); try { Optional<U> optionalDataObject = readFuture.checkedGet(); if (optionalDataObject != null && optionalDataObject.isPresent()) { return optionalDataObject.get(); } else { LOG.debug("{}: Failed to read", Thread.currentThread().getStackTrace()[1]); } } catch (ReadFailedException e) { LOG.warn("Failed to ....", e); } return null; }
private WriteTransaction getTransactionSafely() { if (wTx == null && !TransactionChainManagerStatus.SHUTTING_DOWN.equals(transactionChainManagerStatus)) { synchronized (txLock) { if (wTx == null) { wTx = txChainFactory.newWriteOnlyTransaction(); } } } return wTx; }
@Override public void close() { chain.close(); }
WriteTransaction tx = chain.newWriteOnlyTransaction(); tx = chain.newWriteOnlyTransaction(); writeCnt = 0; chain.close();
try { op = dataStoreOperQueue.take(); final ReadWriteTransaction tx = txChain.newReadWriteTransaction(); LOG.trace("New operations available, starting transaction {}", tx.getIdentifier()); LOG.warn("Unhandled exception during processing statistics for {}. " + "Restarting transaction chain.",op != null?op.getNodeId().getValue():"",e); txChain.close(); txChain = dataBroker.createTransactionChain(StatisticsManagerImpl.this); cleanDataStoreOperQueue();
/** * Creates new empty ReadWriteTransaction. If transaction chain * was failed, it will allocate new transaction chain * and assign it with this Operation Executor. * * This call is synchronized to prevent reace with {@link #failCurrentChain(TransactionChain)}. * * @return New Empty ReadWrite transaction, which continues this chain or starts new transaction * chain. */ private synchronized ReadWriteTransaction newEmptyTransaction() { try { if(txChain == null) { // Chain was broken so we need to replace it. txChain = dataBroker.createTransactionChain(this); } return txChain.newReadWriteTransaction(); } catch (final IllegalStateException e) { LOG.debug("Chain is broken, need to allocate new transaction chain.",e); /* * Chain was broken by previous transaction, * but there was race between this. * Chain will be closed by #onTransactionChainFailed method. */ txChain = dataBroker.createTransactionChain(this); return txChain.newReadWriteTransaction(); } }
/** * @param path InstanceIdentifier path specifying data * @param logicalDatastoreType Type of datastore where operation will be held * @param <T> Any type extending DataObject * @return CheckedFuture callback of operation */ public <T extends DataObject> CheckedFuture<Optional<T>, ReadFailedException> read(InstanceIdentifier<T> path, LogicalDatastoreType logicalDatastoreType) { checkParams(path, logicalDatastoreType); synchronized (dataBroker) { try (ReadOnlyTransaction transaction = bindingTransactionChain.newReadOnlyTransaction()) { return transaction.read(logicalDatastoreType, path); } } }
private <U extends org.opendaylight.yangtools.yang.binding.DataObject> void writePutTransaction( InstanceIdentifier<U> addIID, U data, LogicalDatastoreType logicalDatastoreType, String errMsg) { WriteTransaction writeTx = txChain.newWriteOnlyTransaction(); writeTx.put(logicalDatastoreType, addIID, data, true); Futures.addCallback(writeTx.submit(), new FutureCallback<Void>() { public void onSuccess(Void result) { } public void onFailure(Throwable throwable) { LOG.error("Transaction failed:", throwable); } }); }
@Override public void onTransactionChainFailed(final TransactionChain<?, ?> transactionChain, final AsyncTransaction<?, ?> asyncTransaction, final Throwable throwable) { LOG.error("Transaction chain {} failed.", transactionChain, throwable); txChain.close(); }
WriteTransaction tx = chain.newWriteOnlyTransaction(); tx = chain.newWriteOnlyTransaction(); writeCnt = 0; chain.close();
@Override public void run() { boolean done = false; while (!done) { try { HostTrackerOperation op = queue.take(); ReadWriteTransaction tx = transactionChain.newReadWriteTransaction(); int ops = 0; while ((op != null) && (ops < OPS_PER_CHAIN)) { op.applyOperation(tx); ops += 1; op = queue.poll(); } submitTransaction(tx, NUM_RETRY_SUBMIT); } catch (InterruptedException e) { done = true; } } clearQueue(); }
private <U extends org.opendaylight.yangtools.yang.binding.DataObject> void deleteTransaction( InstanceIdentifier<U> deleteIID, LogicalDatastoreType logicalDatastoreType, String errMsg) { WriteTransaction writeTx = txChain.newWriteOnlyTransaction(); writeTx.delete(logicalDatastoreType, deleteIID); Futures.addCallback(writeTx.submit(), new FutureCallback<Void>() { public void onSuccess(Void result) { } public void onFailure(Throwable throwable) { LOG.error("Transaction failed:", throwable); } }); }