@Override public void put (final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode < ?,?>data){ delegate.put(store, new NormalizedNodeMessage(path, data)); }
@Override public void onComplete(Throwable failure, NormalizedNodeMessage success) throws Throwable { if (failure != null) { settableFuture.setException(failure); return; } final Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode = codecRegistry.fromNormalizedNode(success.getIdentifier(), success.getNode()); final Node value = (Node) fromNormalizedNode.getValue(); settableFuture.set(value); } }, TypedActor.context().dispatcher());
@Override public Future<NormalizedNodeMessage> onRemoteNodeUpdated(final NormalizedNodeMessage message) { final Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode = codecRegistry.fromNormalizedNode(message.getIdentifier(), message.getNode()); final InstanceIdentifier<Node> iid = (InstanceIdentifier<Node>) fromNormalizedNode.getKey(); final Node value = (Node) fromNormalizedNode.getValue(); LOG.debug("TopologyManager({}) onRemoteNodeUpdated received, nodeid: {}", id, value.getNodeId()); final ListenableFuture<Node> nodeListenableFuture = onNodeUpdated(value.getNodeId(), value); final DefaultPromise<NormalizedNodeMessage> promise = new DefaultPromise<>(); Futures.addCallback(nodeListenableFuture, new FutureCallback<Node>() { @Override public void onSuccess(Node result) { final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecRegistry.toNormalizedNode(iid, result); promise.success(new NormalizedNodeMessage(entry.getKey(), entry.getValue())); } @Override public void onFailure(Throwable t) { promise.failure(t); } }); return promise.future(); }
@Override public Future<NormalizedNodeMessage> onRemoteNodeCreated(final NormalizedNodeMessage message) { final Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode = codecRegistry.fromNormalizedNode(message.getIdentifier(), message.getNode()); final InstanceIdentifier<Node> iid = (InstanceIdentifier<Node>) fromNormalizedNode.getKey(); final Node value = (Node) fromNormalizedNode.getValue(); LOG.debug("TopologyManager({}) onRemoteNodeCreated received, nodeid: {}", value.getNodeId(), value); final ListenableFuture<Node> nodeListenableFuture = onNodeCreated(value.getNodeId(), value); final DefaultPromise<NormalizedNodeMessage> promise = new DefaultPromise<>(); Futures.addCallback(nodeListenableFuture, new FutureCallback<Node>() { @Override public void onSuccess(Node result) { final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecRegistry.toNormalizedNode(iid, result); promise.success(new NormalizedNodeMessage(entry.getKey(), entry.getValue())); } @Override public void onFailure(Throwable t) { promise.failure(t); } }); return promise.future(); }
@Override public void onComplete(Throwable failure, NormalizedNodeMessage success) throws Throwable { if (failure != null) { settableFuture.setException(failure); return; } final Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode = codecRegistry.fromNormalizedNode(success.getIdentifier(), success.getNode()); final Node value = (Node) fromNormalizedNode.getValue(); settableFuture.set(value); } }, TypedActor.context().dispatcher());
@Override public void merge (final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode < ?,?>data){ delegate.merge(store, new NormalizedNodeMessage(path, data)); }
@Override public void merge(final LogicalDatastoreType store, final NormalizedNodeMessage data) { if (writeTx == null) { writeTx = delegateBroker.newWriteOnlyTransaction(); } writeTx.merge(store, data.getIdentifier(), data.getNode()); }
@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 put(final LogicalDatastoreType store, final NormalizedNodeMessage data) { if (writeTx == null) { writeTx = delegateBroker.newWriteOnlyTransaction(); } writeTx.put(store, data.getIdentifier(), data.getNode()); }
@Override public void onSuccess(Node result) { final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecRegistry.toNormalizedNode(iid, result); promise.success(new NormalizedNodeMessage(entry.getKey(), entry.getValue())); }
@Override public void onSuccess(Node result) { final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecRegistry.toNormalizedNode(iid, result); promise.success(new NormalizedNodeMessage(entry.getKey(), entry.getValue())); }
@Override public void onSuccess(Node result) { final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecRegistry.toNormalizedNode(TopologyUtil.createTopologyNodePath(topologyId), result); promise.success(new NormalizedNodeMessage(entry.getKey(), entry.getValue())); }
@Override public void onSuccess(Optional<Topology> result) { if (result.isPresent() && result.get().getNode() != null) { for (final Node node : result.get().getNode()) { final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecRegistry.toNormalizedNode(TopologyUtil.createTopologyNodePath(topologyId), node); peer.onRemoteNodeCreated(new NormalizedNodeMessage(entry.getKey(), entry.getValue())); // we dont care about the future from now on since we will be notified by the onConnected event } } }
private void resyncPeer(final TopologyManager peer) { final ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction(); final CheckedFuture<Optional<Topology>, ReadFailedException> read = rTx.read(LogicalDatastoreType.CONFIGURATION, topologyListPath); Futures.addCallback(read, new FutureCallback<Optional<Topology>>() { @Override public void onSuccess(Optional<Topology> result) { if (result.isPresent() && result.get().getNode() != null) { for (final Node node : result.get().getNode()) { final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecRegistry.toNormalizedNode(TopologyUtil.createTopologyNodePath(topologyId), node); peer.onRemoteNodeCreated(new NormalizedNodeMessage(entry.getKey(), entry.getValue())); // we dont care about the future from now on since we will be notified by the onConnected event } } } @Override public void onFailure(Throwable t) { LOG.error("Unable to read from datastore"); } }); } }
public Future<NormalizedNodeMessage> remoteGetCurrentStatusForNode(final NodeId nodeId) { LOG.debug("TopologyManager({}) remoteGetCurrentStatusForNode received, nodeid: {}", id, nodeId.getValue()); final ListenableFuture<Node> listenableFuture = getCurrentStatusForNode(nodeId); final DefaultPromise<NormalizedNodeMessage> promise = new DefaultPromise<>(); Futures.addCallback(listenableFuture, new FutureCallback<Node>() { @Override public void onSuccess(Node result) { final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecRegistry.toNormalizedNode(TopologyUtil.createTopologyNodePath(topologyId), result); promise.success(new NormalizedNodeMessage(entry.getKey(), entry.getValue())); } @Override public void onFailure(Throwable t) { promise.failure(t); } }); return promise.future(); }
final Future<NormalizedNodeMessage> scalaFuture = topologyManager.onRemoteNodeCreated(new NormalizedNodeMessage(normalizedNodeEntry.getKey(), normalizedNodeEntry.getValue())); scalaFuture.onComplete(new OnComplete<NormalizedNodeMessage>() { @Override