sdnr/wireless-transport/code-Carbon-SR1/apps/devicemanager/impl/src/main/java/org/opendaylight/mwtn/devicemanager/impl/listener/NetconfChangeListener.java

   1 /**
   2  * Copyright (c) 2017 highstreet technologies GmbH
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.mwtn.devicemanager.impl.listener;
  10
  11 import java.util.Collection;
  12
  13 import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
  14 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  15 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
  16 import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
  17 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
  18 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  19 import org.opendaylight.mwtn.devicemanager.api.DeviceManagerService;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.network.topology.topology.topology.types.TopologyNetconf;
  23 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  24 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  25 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
  26 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  27 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  28 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  29 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  30 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33
  34 public class NetconfChangeListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
  35
  36         private static final Logger LOG = LoggerFactory.getLogger(NetconfChangeListener.class);
  37
  38         private static final InstanceIdentifier<Node> NETCONF_NODE_TOPO_IID = InstanceIdentifier
  39                         .create(NetworkTopology.class)
  40                         .child(Topology.class, new TopologyKey(new TopologyId(TopologyNetconf.QNAME.getLocalName())))
  41                         .child(Node.class);
  42
  43         // Name of ODL controller NETCONF instance
  44         private static final String CONTROLLER = "controller-config";
  45
  46         private final DeviceManagerService deviceManagerService;
  47         private final DataBroker dataBroker;
  48         private ListenerRegistration<NetconfChangeListener> dlcReg;
  49
  50         public NetconfChangeListener(DeviceManagerService deviceManagerService, DataBroker dataBroker) {
  51                 this.deviceManagerService = deviceManagerService;
  52                 this.dataBroker = dataBroker;
  53         }
  54
  55         public void register() {
  56                 DataTreeIdentifier<Node> treeId = new DataTreeIdentifier<Node>(LogicalDatastoreType.OPERATIONAL,
  57                                 NETCONF_NODE_TOPO_IID);
  58                 dlcReg = dataBroker.registerDataTreeChangeListener(treeId, this);
  59         }
  60
  61         public void close() {
  62                 if (dlcReg != null) {
  63                         dlcReg.close();
  64                 }
  65         }
  66
  67         /*---------------------------------------------------------------------------
  68          * Listener
  69          */
  70
  71         @Override
  72         public void onDataTreeChanged(Collection<DataTreeModification<Node>> changes) {
  73                 if (LOG.isDebugEnabled()) {
  74                         LOG.debug("OnDataChange, TreeChange");
  75                 } else if (LOG.isTraceEnabled()) {
  76                         LOG.trace("OnDataChange, TreeChange {}", changes);
  77                 }
  78                 for (final DataTreeModification<Node> change : changes) {
  79                         final DataObjectModification<Node> root = change.getRootNode();
  80                         switch (root.getModificationType()) {
  81                         case SUBTREE_MODIFIED:
  82                                 // Change of subtree information
  83                                 update(change);
  84                                 break;
  85                         case WRITE:
  86                                 // Create or modify top level node
  87                                 // Treat an overwrite as an update
  88                                 boolean update = change.getRootNode().getDataBefore() != null;
  89                                 if (update) {
  90                                         update(change);
  91                                 } else {
  92                                         add(change);
  93                                 }
  94                                 break;
  95                         case DELETE:
  96                                 // Node removed
  97                                 remove(change);
  98                                 break;
  99                         default:
 100                                 break;
 101                         }
 102                 }
 103         }
 104
 105         public void add(DataTreeModification<Node> newDataObject) {
 106                 Node node = newDataObject.getRootNode().getDataAfter();
 107                 NodeId nodeId = node.getKey().getNodeId();
 108                 LOG.info("Node {} added to topology-netconf", nodeId.getValue());
 109                 NetconfNode netconfAugment = node.getAugmentation(NetconfNode.class);
 110                 if (nodeId != null) {
 111                         if (!nodeId.getValue().equals(CONTROLLER)) {
 112                                 deviceManagerService.mountpointNodeCreation(nodeId, netconfAugment);
 113                         }
 114                 }
 115                 doProcessing(nodeId, netconfAugment);
 116         }
 117
 118         public void remove(DataTreeModification<Node> removedDataObject) {
 119                 Node node = removedDataObject.getRootNode().getDataBefore();
 120                 NodeId nodeId = node.getKey().getNodeId();
 121                 LOG.info("Node {} removed from topology-netconf", nodeId.getValue());
 122                 NetconfNode netconfAugment = node.getAugmentation(NetconfNode.class);
 123                 if (nodeId != null) {
 124                         if (!nodeId.getValue().equals(CONTROLLER)) {
 125                                 deviceManagerService.mountpointNodeRemoved(nodeId);
 126                         }
 127                 }
 128                 doProcessingRemove(nodeId, netconfAugment);
 129         }
 130
 131         public void update(DataTreeModification<Node> modifiedDataObject) {
 132                 // Node node = modifiedDataObject.getRootNode().getDataBefore();
 133                 Node node = modifiedDataObject.getRootNode().getDataAfter();
 134                 NodeId nodeId = node.getKey().getNodeId();
 135                 LOG.info("Node {} modified in topology-netconf", nodeId.getValue());
 136                 NetconfNode netconfAugment = node.getAugmentation(NetconfNode.class);
 137                 doProcessing(nodeId, netconfAugment);
 138         }
 139
 140         /**
 141          * Process event and forward to clients
 142          *
 143          * @param nodeId
 144          *            Id of node
 145          * @param nnode
 146          *            Netconf node
 147          */
 148         private void doProcessing(NodeId nodeId, NetconfNode nnode) {
 149
 150                 if (nodeId == null || nnode == null) {
 151                         LOG.warn("Empty node .. stop processing");
 152                 }
 153
 154                 String nodeIdString = nodeId.getValue();
 155
 156                 if (nodeIdString.equals(CONTROLLER)) {
 157                         LOG.debug("Stop processing for [{}]", CONTROLLER);
 158                         return;
 159                 }
 160
 161                 ConnectionStatus csts = nnode.getConnectionStatus();
 162                 LOG.debug("NETCONF Node handled with status: {}", csts.toString());
 163                 switch (csts) {
 164                 case Connected: {
 165                         deviceManagerService.startListenerOnNode(nodeId, nnode);
 166                         break;
 167                 }
 168                 case Connecting: {
 169                         deviceManagerService.removeListenerOnNode(nodeId, nnode);
 170                         break;
 171                 }
 172                 case UnableToConnect: {
 173                         deviceManagerService.removeListenerOnNode(nodeId, nnode);
 174                         break;
 175                 }
 176                 }
 177         }
 178
 179         /**
 180          * Remove node
 181          *
 182          * @param nodeId
 183          * @param nnode
 184          */
 185         private void doProcessingRemove(NodeId nodeId, NetconfNode nnode) {
 186
 187                 if (nodeId == null || nnode == null) {
 188                         LOG.warn("Empty node .. stop processing");
 189                 }
 190
 191                 String nodeIdString = nodeId.getValue();
 192
 193                 if (nodeIdString.equals(CONTROLLER)) {
 194                         LOG.debug("Stop processing for [{}]", CONTROLLER);
 195                         return;
 196                 }
 197
 198                 deviceManagerService.removeListenerOnNode(nodeId, nnode);
 199
 200         }
 201
 202 }