@Override public void remove(DataTreeModification<Evc> removedDataObject) { if (removedDataObject.getRootPath() != null && removedDataObject.getRootNode() != null) { log.info("evc {} deleted", removedDataObject.getRootNode().getIdentifier()); removeEvc(removedDataObject); } }
/** * {@inheritDoc} */ @Override protected final void handleTree(TreeChangeContext<T> ctx, C ectx, DataTreeModification<T> change) { handleTreeNode(ctx, ectx, change.getRootNode()); } }
private InstanceIdentifier<ForwardingConstruct> getFcIid(DataTreeModification<ForwardingConstruct> fcModification) { return fcModification.getRootPath().getRootIdentifier(); }
@Override public List<DataObjectModification<C>> getModifications(DataTreeModification<P> treeModification) { List<DataObjectModification<C>> modifications = new ArrayList<>(); if (treeModification != null) { modifications.add(treeModification.getRootNode().getModifiedChildContainer(container)); } return modifications; }
private void processRemovedNode(final DataTreeModification<FlowCapableNode> modification) { final InstanceIdentifier<FlowCapableNode> iiToNodeInInventory = modification.getRootPath().getRootIdentifier(); final NodeId nodeId = provideTopologyNodeId(iiToNodeInInventory); final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node> iiToTopologyRemovedNode = provideIIToTopologyNode(nodeId); if (iiToTopologyRemovedNode != null) { operationProcessor.enqueueOperation(new TopologyOperation() { @Override public void applyOperation(final ReadWriteTransaction transaction) { transaction.delete(LogicalDatastoreType.OPERATIONAL, iiToTopologyRemovedNode); TopologyManagerUtil.removeAffectedLinks(nodeId, transaction, II_TO_TOPOLOGY); } }); } else { LOG.debug("Instance identifier to inventory wasn't translated to topology while deleting node."); } }
@Override public void add(DataTreeModification<Evc> newDataObject) { if (newDataObject.getRootPath() != null && newDataObject.getRootNode() != null) { log.info("evc {} created", newDataObject.getRootNode().getIdentifier()); addEvc(newDataObject); } }
/** * @param c Modification that will be checked * @param function Function pointing to field that will be checked * @param <R> Parent type * @param <T> Child type * @return If Child field was changed */ public static <R, T extends DataObject> boolean checkDifference(DataTreeModification<T> c, Function<T, R> function) { Preconditions.checkNotNull(c); Preconditions.checkNotNull(function); return checkDifference(c.getRootNode(), function); }
private void processAddedNode(final DataTreeModification<FlowCapableNode> modification) { final InstanceIdentifier<FlowCapableNode> iiToNodeInInventory = modification.getRootPath().getRootIdentifier(); final NodeId nodeIdInTopology = provideTopologyNodeId(iiToNodeInInventory); if (nodeIdInTopology != null) { final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node> iiToTopologyNode = provideIIToTopologyNode(nodeIdInTopology); sendToTransactionChain(prepareTopologyNode(nodeIdInTopology, iiToNodeInInventory), iiToTopologyNode); } else { LOG.debug("Inventory node key is null. Data can't be written to topology"); } }
@Override public void update(DataTreeModification<Evc> modifiedDataObject) { if (modifiedDataObject.getRootPath() != null && modifiedDataObject.getRootNode() != null) { log.info("evc {} updated", modifiedDataObject.getRootNode().getIdentifier()); updateEvc(modifiedDataObject); } }
private ForwardingConstruct getFcForDeactivation(DataTreeModification<ForwardingConstruct> fcModification) { return fcModification.getRootNode().getDataBefore(); }
private void processRemovedConnector(final DataTreeModification<T> modification) { final InstanceIdentifier<T> identifier = modification.getRootPath().getRootIdentifier(); if (compareIITail(identifier, II_TO_FLOW_CAPABLE_NODE_CONNECTOR)) { InstanceIdentifier<NodeConnector> nodeConnectorInstanceId = identifier.firstIdentifierOf(NodeConnector.class); notifyNodeConnectorDisappeared(nodeConnectorInstanceId); } }
@Override public void update(DataTreeModification<FlowCapableNodeConnector> modifiedDataObject) { if (modifiedDataObject.getRootPath() != null && modifiedDataObject.getRootNode() != null) { log.info("node connector {} updated", modifiedDataObject.getRootNode().getIdentifier()); updateFlowCapableNodeConnector(modifiedDataObject); } }
private ForwardingConstruct getFcForActivation(DataTreeModification<ForwardingConstruct> fcModification) { return fcModification.getRootNode().getDataAfter(); }
private String getDpnIdFromNodeConnector(DataTreeModification<FlowCapableNodeConnector> newDataObject) { InstanceIdentifier<FlowCapableNodeConnector> key = newDataObject.getRootPath().getRootIdentifier(); NodeConnectorId nodeConnectorId = InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId(); String dpnFromNodeConnectorId = getDpnFromNodeConnectorId(nodeConnectorId); return dpnFromNodeConnectorId; }
@Override public void remove(DataTreeModification<FlowCapableNodeConnector> removedDataObject) { if (removedDataObject.getRootPath() != null && removedDataObject.getRootNode() != null) { log.info("node connector {} deleted", removedDataObject.getRootNode().getIdentifier()); removeFlowCapableNodeConnector(removedDataObject); } }
@Override public List<DataObjectModification<C>> getModifications(DataTreeModification<P> treeModification) { List<DataObjectModification<C>> modifications = new ArrayList<>(); if (treeModification != null) { treeModification.getRootNode().getModifiedChildren().forEach(c -> { if (c.getDataType().equals(container)) modifications.add((DataObjectModification<C>) c); }); } return modifications; }
private void processRemovedTerminationPoints(final DataTreeModification<FlowCapableNodeConnector> modification) { final InstanceIdentifier<FlowCapableNodeConnector> removedNode = modification.getRootPath().getRootIdentifier(); final TpId terminationPointId = provideTopologyTerminationPointId(removedNode); final InstanceIdentifier<TerminationPoint> iiToTopologyTerminationPoint = provideIIToTopologyTerminationPoint( terminationPointId, removedNode); if (iiToTopologyTerminationPoint != null) { final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node> node = iiToTopologyTerminationPoint.firstIdentifierOf(org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node.class); operationProcessor.enqueueOperation(new TopologyOperation() { @Override public void applyOperation(final ReadWriteTransaction transaction) { Optional<org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node> nodeOptional = Optional.absent(); try { nodeOptional = transaction.read(LogicalDatastoreType.OPERATIONAL, node).checkedGet(); } catch (ReadFailedException e) { LOG.warn("Error occured when trying to read NodeConnector: {}", e.getMessage()); LOG.debug("Error occured when trying to read NodeConnector.. ", e); } if (nodeOptional.isPresent()) { TopologyManagerUtil.removeAffectedLinks(terminationPointId, transaction, II_TO_TOPOLOGY); transaction.delete(LogicalDatastoreType.OPERATIONAL, iiToTopologyTerminationPoint); } } }); } else { LOG.debug("Instance identifier to inventory wasn't translated to topology while deleting termination point."); } }
@Override public void add(DataTreeModification<FlowCapableNodeConnector> newDataObject) { if (newDataObject.getRootPath() != null && newDataObject.getRootNode() != null) { log.info("node connector {} created", newDataObject.getRootNode().getIdentifier()); addFlowCapableNodeConnector(newDataObject); } }
private void updateFlowCapableNodeConnector(DataTreeModification<FlowCapableNodeConnector> modifiedDataObject) { try { FlowCapableNodeConnector original = modifiedDataObject.getRootNode().getDataBefore(); FlowCapableNodeConnector update = modifiedDataObject.getRootNode().getDataAfter(); String dpnFromNodeConnectorId = getDpnIdFromNodeConnector(modifiedDataObject); handleNodeConnectorUpdated(dataBroker, dpnFromNodeConnectorId, original, update); } catch (final Exception e) { log.error("Update node connector failed !", e); } }
/** * Invoked when the specified data tree has been modified. * * @param changes A collection of data tree modifications. */ @Override public final void onDataTreeChanged( @Nonnull Collection<DataTreeModification<T>> changes) { TreeChangeContext<T> ctx = new TreeChangeContext<>(); C ectx = enterEvent(); try { for (DataTreeModification<T> change: changes) { ctx.setRootPath(change.getRootPath().getRootIdentifier()); handleTree(ctx, ectx, change); } } catch (RuntimeException e) { getLogger().error( "Unexpected exception in data tree change event listener.", e); } finally { exitEvent(ectx); } } }