private Optional<NormalizedNode<?, ?>> getRootNode() { return dataTree.takeSnapshot().readNode(rootIdentifier); } }
public Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier path) { return dataTree.takeSnapshot().readNode(path); }
private Optional<DataTreeCandidate> readCurrentData() { final Optional<NormalizedNode<?, ?>> currentState = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.EMPTY); return currentState.isPresent() ? Optional.of(DataTreeCandidates.fromNormalizedNode( YangInstanceIdentifier.EMPTY, currentState.get())) : Optional.<DataTreeCandidate>absent(); }
<L extends DOMDataTreeChangeListener> ListenerRegistration<L> registerTreeChangeListener(final YangInstanceIdentifier treeId, final L listener, final DataTreeSnapshot snapshot) { final AbstractDOMDataTreeChangeListenerRegistration<L> reg = registerTreeChangeListener(treeId, listener); final Optional<NormalizedNode<?, ?>> node = snapshot.readNode(treeId); if (node.isPresent()) { final DataTreeCandidate candidate = DataTreeCandidates.fromNormalizedNode(treeId, node.get()); notificationManager.submitNotification(reg, candidate); } return reg; }
@Override public void commit(final DataTreeCandidate dataTreeCandidate) { LOG.trace("Commit detected"); delegateDependency.commit(dataTreeCandidate); LOG.debug("Delegate commit successful. Persisting data"); // TODO(HONEYCOMB-163): doing full read and full write might not be the fastest way of persisting data here final DataTreeSnapshot dataTreeSnapshot = delegateDependency.takeSnapshot(); // TODO this can be handled in background by a dedicated thread + a limited blocking queue // TODO enable configurable granularity for persists. Maybe doing write on every modification is too much // and we could do bulk persist persister.persistCurrentData(dataTreeSnapshot.readNode(YangInstanceIdentifier.EMPTY)); }
/** * Take a snapshot of current state for later recovery. * * @return A state snapshot */ @Nonnull ShardDataTreeSnapshot takeStateSnapshot() { final NormalizedNode<?, ?> rootNode = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.EMPTY).get(); final Builder<Class<? extends ShardDataTreeSnapshotMetadata<?>>, ShardDataTreeSnapshotMetadata<?>> metaBuilder = ImmutableMap.builder(); for (ShardDataTreeMetadata<?> m : metadata) { final ShardDataTreeSnapshotMetadata<?> meta = m.toSnapshot(); if (meta != null) { metaBuilder.put(meta.getType(), meta); } } return new MetadataShardDataTreeSnapshot(rootNode, metaBuilder.build()); }
@Override public Optional<EntityOwnershipState> getOwnershipState(final DOMEntity forEntity) { Preconditions.checkNotNull(forEntity, "forEntity cannot be null"); DataTree dataTree = getLocalEntityOwnershipShardDataTree(); if (dataTree == null) { return Optional.absent(); } Optional<NormalizedNode<?, ?>> entityNode = dataTree.takeSnapshot().readNode( entityPath(forEntity.getType(), forEntity.getIdentifier())); if (!entityNode.isPresent()) { return Optional.absent(); } // Check if there are any candidates, if there are none we do not really have ownership state final MapEntryNode entity = (MapEntryNode) entityNode.get(); final Optional<DataContainerChild<? extends PathArgument, ?>> optionalCandidates = entity.getChild(CANDIDATE_NODE_ID); final boolean hasCandidates = optionalCandidates.isPresent() && ((MapNode) optionalCandidates.get()).getValue().size() > 0; if(!hasCandidates){ return Optional.absent(); } MemberName localMemberName = context.getCurrentMemberName(); Optional<DataContainerChild<? extends PathArgument, ?>> ownerLeaf = entity.getChild(ENTITY_OWNER_NODE_ID); String owner = ownerLeaf.isPresent() ? ownerLeaf.get().getValue().toString() : null; boolean hasOwner = !Strings.isNullOrEmpty(owner); boolean isOwner = hasOwner && localMemberName.getName().equals(owner); return Optional.of(EntityOwnershipState.from(isOwner, hasOwner)); }
<L extends DOMDataTreeChangeListener> ListenerRegistration<L> registerTreeChangeListener( final YangInstanceIdentifier treeId, final L listener, final DataTreeSnapshot snapshot) { final AbstractDOMDataTreeChangeListenerRegistration<L> reg = registerTreeChangeListener(treeId, listener); final Optional<NormalizedNode<?, ?>> node = snapshot.readNode(YangInstanceIdentifier.EMPTY); if (node.isPresent()) { final DataTreeCandidate candidate = DataTreeCandidates.fromNormalizedNode( YangInstanceIdentifier.EMPTY, node.get()); InMemoryDOMStoreTreeChangePublisher publisher = new InMemoryDOMStoreTreeChangePublisher(notificationManager); publisher.registerTreeChangeListener(treeId, listener); publisher.publishChange(candidate); } return reg; }
@Override public CheckedFuture<Optional<NormalizedNode<?,?>>, ReadFailedException> read(final YangInstanceIdentifier path) { LOG.debug("Tx: {} Read: {}", getIdentifier(), path); checkNotNull(path, "Path must not be null."); final DataTreeSnapshot snapshot = stableSnapshot; if (snapshot == null) { return Futures.immediateFailedCheckedFuture(new ReadFailedException("Transaction is closed")); } try { return Futures.immediateCheckedFuture(snapshot.readNode(path)); } catch (Exception e) { LOG.error("Tx: {} Failed Read of {}", getIdentifier(), path, e); return Futures.immediateFailedCheckedFuture(new ReadFailedException("Read failed",e)); } }
@SuppressWarnings("checkstyle:IllegalCatch") @Override public FluentFuture<Optional<NormalizedNode<?,?>>> read(final YangInstanceIdentifier path) { LOG.debug("Tx: {} Read: {}", getIdentifier(), path); requireNonNull(path, "Path must not be null."); final DataTreeSnapshot snapshot = stableSnapshot; if (snapshot == null) { return FluentFutures.immediateFailedFluentFuture(new ReadFailedException("Transaction is closed")); } try { return FluentFutures.immediateFluentFuture(snapshot.readNode(path)); } catch (Exception e) { LOG.error("Tx: {} Failed Read of {}", getIdentifier(), path, e); return FluentFutures.immediateFailedFluentFuture(new ReadFailedException("Read failed", e)); } }
@Override @SuppressWarnings("checkstyle:IllegalCatch") public CheckedFuture<Optional<NormalizedNode<?,?>>, ReadFailedException> read(final YangInstanceIdentifier path) { LOG.debug("Tx: {} Read: {}", getIdentifier(), path); checkNotNull(path, "Path must not be null."); final DataTreeSnapshot snapshot = stableSnapshot; if (snapshot == null) { return Futures.immediateFailedCheckedFuture(new ReadFailedException("Transaction is closed")); } try { return Futures.immediateCheckedFuture(Optional.fromJavaUtil(snapshot.readNode(path))); } catch (RuntimeException e) { LOG.error("Tx: {} Failed Read of {}", getIdentifier(), path, e); return Futures.immediateFailedCheckedFuture(new ReadFailedException("Read failed",e)); } }
private <L extends DOMDataTreeChangeListener> void initialDataChangeEvent( final YangInstanceIdentifier listenerPath, final L listener) { // FIXME Add support for wildcard listeners final Optional<NormalizedNode<?, ?>> preExistingData = dataTree.takeSnapshot() .readNode(YangInstanceIdentifier.create(stripShardPath(listenerPath))); final DataTreeCandidate initialCandidate; if (preExistingData.isPresent()) { final NormalizedNode<?, ?> data = preExistingData.get(); checkState(data instanceof DataContainerNode, "Expected DataContainer node, but was {}", data.getClass()); // if we are listening on root of some shard we still get // empty normalized node, root is always present if (((DataContainerNode<?>) data).getValue().isEmpty()) { initialCandidate = DataTreeCandidates.newDataTreeCandidate(listenerPath, DataTreeCandidateNodes.empty(data.getIdentifier())); } else { initialCandidate = DataTreeCandidates.fromNormalizedNode(listenerPath, translateRootShardIdentifierToListenerPath(listenerPath, preExistingData.get())); } } else { initialCandidate = DataTreeCandidates.newDataTreeCandidate(listenerPath, DataTreeCandidateNodes.empty(listenerPath.getLastPathArgument())); } listener.onDataTreeChanged(Collections.singleton(initialCandidate)); }
Optional<NormalizedNode<?, ?>> currentState = dataTree.takeSnapshot().readNode(path); if (currentState.isPresent()) { final NormalizedNode<?, ?> data = currentState.get();
<L extends DOMDataTreeChangeListener> ListenerRegistration<L> registerTreeChangeListener( final YangInstanceIdentifier treeId, final L listener, final DataTreeSnapshot snapshot) { final AbstractDOMDataTreeChangeListenerRegistration<L> reg = registerTreeChangeListener(treeId, listener); final Optional<NormalizedNode<?, ?>> preExistingData = snapshot.readNode(YangInstanceIdentifier.EMPTY); if (!preExistingData.isPresent()) { listener.onInitialData();
protected void readData(AbstractShardDataTreeTransaction<?> transaction, ReadData message) { if (checkClosed(transaction)) { return; } final YangInstanceIdentifier path = message.getPath(); Optional<NormalizedNode<?, ?>> optional = transaction.getSnapshot().readNode(path); ReadDataReply readDataReply = new ReadDataReply(optional.orNull(), message.getVersion()); sender().tell(readDataReply.toSerializable(), self()); }
protected void dataExists(AbstractShardDataTreeTransaction<?> transaction, DataExists message) { if (checkClosed(transaction)) { return; } final YangInstanceIdentifier path = message.getPath(); boolean exists = transaction.getSnapshot().readNode(path).isPresent(); getSender().tell(new DataExistsReply(exists, message.getVersion()).toSerializable(), getSelf()); }