@Override public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegateReadTx.read(store, path); }
@Override public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegate().read(store, path); }
@Override public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegate().read(store, path); }
private <T extends DataObject> Optional<T> read(final InstanceIdentifier<T> currentId, final DOMDataReadOnlyTransaction tx) { final YangInstanceIdentifier path = serializer.toYangInstanceIdentifier(currentId); final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read = tx.read(LogicalDatastoreType.CONFIGURATION, path); try { // TODO HONEYCOMB-169 once the APIs are asynchronous use just Futures.transform final Optional<NormalizedNode<?, ?>> optional = read.checkedGet(); if (!optional.isPresent()) { return Optional.absent(); } final NormalizedNode<?, ?> data = optional.get(); final Map.Entry<InstanceIdentifier<?>, DataObject> entry = serializer.fromNormalizedNode(path, data); final Class<T> targetType = currentId.getTargetType(); checkState(targetType.isAssignableFrom(entry.getValue().getClass()), "Unexpected data object type, should be: %s, but was: %s", targetType, entry.getValue().getClass()); return Optional.of(targetType.cast(entry.getValue())); } catch (ReadFailedException e) { throw new IllegalStateException("Unable to perform read", e); } }
@Override public Future<Optional<NormalizedNodeMessage>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) { final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> readFuture = readTx.read(store, path); final DefaultPromise<Optional<NormalizedNodeMessage>> promise = new DefaultPromise<>(); Futures.addCallback(readFuture, new FutureCallback<Optional<NormalizedNode<?, ?>>>() { @Override public void onSuccess(Optional<NormalizedNode<?, ?>> result) { if (!result.isPresent()) { promise.success(Optional.<NormalizedNodeMessage>absent()); } else { promise.success(Optional.of(new NormalizedNodeMessage(path, result.get()))); } } @Override public void onFailure(Throwable t) { promise.failure(t); } }); return promise.future(); }
/** * Returns list of streams avaliable on device * @return list of streams * @throws ReadFailedException if data read fails */ List<Stream> getAvailableStreams() throws ReadFailedException { DOMDataReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction(); CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> checkFeature = tx .read(LogicalDatastoreType.OPERATIONAL, STREAMS_PATH); Optional<NormalizedNode<?, ?>> streams = checkFeature.checkedGet(); if (streams.isPresent()) { Streams s = (Streams) CODEC_REGISTRY.fromNormalizedNode(STREAMS_PATH, streams.get()).getValue(); return s.getStream(); } return Collections.emptyList(); }
@Override public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read( LogicalDatastoreType logicalDatastoreType, YangInstanceIdentifier yangInstanceIdentifier) { if (AuthzServiceImpl.isAuthorized(logicalDatastoreType, yangInstanceIdentifier, ActionType.Read)) { return ro.read(logicalDatastoreType, yangInstanceIdentifier); } ReadFailedException e = new ReadFailedException("Authorization Failed"); return Futures.immediateFailedCheckedFuture(e); }