private CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> readOperationalData( final YangInstanceIdentifier path) { final ListenableFuture<DOMRpcResult> configCandidate = netconfOps.get(loggingCallback, Optional.fromNullable(path)); // Find data node and normalize its content final ListenableFuture<Optional<NormalizedNode<?, ?>>> transformedFuture = Futures.transform(configCandidate, new Function<DOMRpcResult, Optional<NormalizedNode<?, ?>>>() { @Override public Optional<NormalizedNode<?, ?>> apply(final DOMRpcResult result) { checkReadSuccess(result, path); final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataNode = findDataNode(result); return NormalizedNodes.findNode(dataNode, path.getPathArguments()); } }); if(!readWithTimeout("readOperationalData", configCandidate)) { return null; } return MappingCheckedFuture.create(transformedFuture, ReadFailedException.MAPPER); }
private <T> CheckedFuture<T, ReadFailedException> executeRead(String shardName, final AbstractRead<T> readCmd) { Preconditions.checkState(type != TransactionType.WRITE_ONLY, "Reads from write-only transactions are not allowed"); if(LOG.isDebugEnabled()) { LOG.debug("Tx {} {} {}", getIdentifier(), readCmd.getClass().getSimpleName(), readCmd.getPath()); } final SettableFuture<T> proxyFuture = SettableFuture.create(); TransactionContextWrapper contextWrapper = getContextWrapper(shardName); contextWrapper.maybeExecuteTransactionOperation(new TransactionOperation() { @Override public void invoke(TransactionContext transactionContext) { transactionContext.executeRead(readCmd, proxyFuture); } }); return MappingCheckedFuture.create(proxyFuture, ReadFailedException.MAPPER); }
private CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> readConfigurationData( final YangInstanceIdentifier path) { final ListenableFuture<DOMRpcResult> configRunning = netconfOps.getConfigRunning(loggingCallback, Optional.fromNullable(path)); final ListenableFuture<Optional<NormalizedNode<?, ?>>> transformedFuture = Futures.transform(configRunning, new Function<DOMRpcResult, Optional<NormalizedNode<?, ?>>>() { @Override public Optional<NormalizedNode<?, ?>> apply(final DOMRpcResult result) { checkReadSuccess(result, path); final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataNode = findDataNode(result); return NormalizedNodes.findNode(dataNode, path.getPathArguments()); } }); if(!readWithTimeout("readConfigurationData", configRunning)) { return null; } return MappingCheckedFuture.create(transformedFuture, ReadFailedException.MAPPER); }
@Override protected CheckedFuture<Void, TransactionCommitFailedException> submit(DOMDataWriteTransaction transaction, Collection<DOMStoreThreePhaseCommitCohort> cohorts) { Preconditions.checkArgument(transaction != null, "Transaction must not be null."); Preconditions.checkArgument(cohorts != null, "Cohorts must not be null."); LOG.debug("Tx: {} is submitted for execution.", transaction.getIdentifier()); if(cohorts.isEmpty()){ return Futures.immediateCheckedFuture(null); } final AsyncNotifyingSettableFuture clientSubmitFuture = new AsyncNotifyingSettableFuture(clientFutureCallbackExecutor); doCanCommit(clientSubmitFuture, transaction, cohorts); return MappingCheckedFuture.create(clientSubmitFuture, TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER); }
protected final <D extends DataObject> CheckedFuture<Optional<D>,ReadFailedException> doRead( final DOMDataReadTransaction readTx, final LogicalDatastoreType store, final InstanceIdentifier<D> path) { Preconditions.checkArgument(!path.isWildcarded(), "Invalid read of wildcarded path %s", path); return MappingCheckedFuture.create( Futures.transform(readTx.read(store, codec.toYangInstanceIdentifierBlocking(path)), codec.deserializeFunction(path)), ReadFailedException.MAPPER); } }
@Override protected CheckedFuture<Void,TransactionCommitFailedException> submit(final DOMDataWriteTransaction transaction, final Collection<DOMStoreThreePhaseCommitCohort> cohorts) { Preconditions.checkArgument(transaction != null, "Transaction must not be null."); Preconditions.checkArgument(cohorts != null, "Cohorts must not be null."); LOG.debug("Tx: {} is submitted for execution.", transaction.getIdentifier()); ListenableFuture<Void> commitFuture = null; try { commitFuture = executor.submit(new CommitCoordinationTask(transaction, cohorts, commitStatsTracker)); } catch(RejectedExecutionException e) { LOG.error("The commit executor's queue is full - submit task was rejected. \n" + executor, e); return Futures.immediateFailedCheckedFuture( new TransactionCommitFailedException( "Could not submit the commit task - the commit queue capacity has been exceeded.", e)); } return MappingCheckedFuture.create(commitFuture, TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER); } }
private CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> readAllData() { final Set<String> allShardNames = txContextFactory.getActorContext().getConfiguration().getAllShardNames(); final Collection<CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException>> futures = new ArrayList<>(allShardNames.size()); for (String shardName : allShardNames) { futures.add(singleShardRead(shardName, YangInstanceIdentifier.EMPTY)); } final ListenableFuture<List<Optional<NormalizedNode<?, ?>>>> listFuture = Futures.allAsList(futures); final ListenableFuture<Optional<NormalizedNode<?, ?>>> aggregateFuture; aggregateFuture = Futures.transform(listFuture, new Function<List<Optional<NormalizedNode<?, ?>>>, Optional<NormalizedNode<?, ?>>>() { @Override public Optional<NormalizedNode<?, ?>> apply(final List<Optional<NormalizedNode<?, ?>>> input) { try { return NormalizedNodeAggregator.aggregate(YangInstanceIdentifier.EMPTY, input, txContextFactory.getActorContext().getSchemaContext(), txContextFactory.getActorContext().getDatastoreContext().getLogicalStoreType()); } catch (DataValidationFailedException e) { throw new IllegalArgumentException("Failed to aggregate", e); } } }); return MappingCheckedFuture.create(aggregateFuture, ReadFailedException.MAPPER); }
private <T> CheckedFuture<T, ReadFailedException> sendReadRequest(final AbstractReadTransactionRequest<?> request, final Consumer<Response<?, ?>> completer, final ListenableFuture<T> future) { // Check if a previous operation failed. If it has, do not bother sending anything and report a failure final Exception local = operationFailure; if (local != null) { return Futures.immediateFailedCheckedFuture(new ReadFailedException("Previous operation failed", local)); } // Make sure we send any modifications before issuing a read ensureFlushedBuider(); client().sendRequest(nextSequence(), request, completer); return MappingCheckedFuture.create(future, ReadFailedException.MAPPER); }