opendaylight/md-sal/topology-manager/src/main/java/org/opendaylight/md/controller/topology/manager/FlowCapableTopologyExporter.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   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 package org.opendaylight.md.controller.topology.manager;
   9
  10 import static org.opendaylight.md.controller.topology.manager.FlowCapableNodeMapping.getNodeConnectorKey;
  11 import static org.opendaylight.md.controller.topology.manager.FlowCapableNodeMapping.getNodeKey;
  12 import static org.opendaylight.md.controller.topology.manager.FlowCapableNodeMapping.toTerminationPoint;
  13 import static org.opendaylight.md.controller.topology.manager.FlowCapableNodeMapping.toTerminationPointId;
  14 import static org.opendaylight.md.controller.topology.manager.FlowCapableNodeMapping.toTopologyLink;
  15 import static org.opendaylight.md.controller.topology.manager.FlowCapableNodeMapping.toTopologyNode;
  16 import static org.opendaylight.md.controller.topology.manager.FlowCapableNodeMapping.toTopologyNodeId;
  17
  18 import java.util.concurrent.Future;
  19
  20 import org.opendaylight.controller.md.sal.binding.util.TypeSafeDataReader;
  21 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  22 import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
  23 import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorUpdated;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeUpdated;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.FlowTopologyDiscoveryListener;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkDiscovered;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkOverutilized;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkRemoved;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkUtilizationNormal;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRemoved;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRemoved;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.OpendaylightInventoryListener;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  39 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  40 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  41 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
  42 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
  43 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  44 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  46 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
  47 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  48 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  49 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  50 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
  51 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  52 import org.opendaylight.yangtools.yang.common.RpcResult;
  53 import org.slf4j.Logger;
  54 import org.slf4j.LoggerFactory;
  55
  56 import com.google.common.util.concurrent.FutureCallback;
  57 import com.google.common.util.concurrent.Futures;
  58 import com.google.common.util.concurrent.JdkFutureAdapters;
  59
  60 class FlowCapableTopologyExporter implements FlowTopologyDiscoveryListener, OpendaylightInventoryListener {
  61     protected final static Logger LOG = LoggerFactory.getLogger(FlowCapableTopologyExporter.class);
  62     public static final TopologyKey TOPOLOGY = new TopologyKey(new TopologyId("flow:1"));
  63     private static final InstanceIdentifier<Topology> TOPOLOGY_PATH =
  64             InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class, TOPOLOGY).build();
  65
  66     // FIXME: Flow capable topology exporter should use transaction chaining API
  67     private DataProviderService dataService;
  68
  69     public DataProviderService getDataService() {
  70         return dataService;
  71     }
  72
  73     public void setDataService(final DataProviderService dataService) {
  74         this.dataService = dataService;
  75     }
  76
  77     public void start() {
  78         TopologyBuilder tb = new TopologyBuilder().setKey(TOPOLOGY);
  79         DataModificationTransaction tx = dataService.beginTransaction();
  80         tx.putOperationalData(TOPOLOGY_PATH, tb.build());
  81         listenOnTransactionState(tx.getIdentifier(),tx.commit());
  82     }
  83
  84     @Override
  85     public void onNodeRemoved(final NodeRemoved notification) {
  86         NodeId nodeId = toTopologyNodeId(getNodeKey(notification.getNodeRef()).getId());
  87         InstanceIdentifier<Node> nodeInstance = toNodeIdentifier(notification.getNodeRef());
  88
  89         synchronized (this) {
  90             DataModificationTransaction tx = dataService.beginTransaction();
  91             tx.removeOperationalData(nodeInstance);
  92             removeAffectedLinks(tx, nodeId);
  93             listenOnTransactionState(tx.getIdentifier(),tx.commit());
  94         }
  95     }
  96
  97     @Override
  98     public void onNodeUpdated(final NodeUpdated notification) {
  99         FlowCapableNodeUpdated fcnu = notification.getAugmentation(FlowCapableNodeUpdated.class);
 100         if (fcnu != null) {
 101             Node node = toTopologyNode(toTopologyNodeId(notification.getId()), notification.getNodeRef());
 102             InstanceIdentifier<Node> path = getNodePath(toTopologyNodeId(notification.getId()));
 103
 104             synchronized (this) {
 105                 DataModificationTransaction tx = dataService.beginTransaction();
 106                 tx.putOperationalData(path, node);
 107                 listenOnTransactionState(tx.getIdentifier(),tx.commit());
 108             }
 109         }
 110     }
 111
 112     @Override
 113     public void onNodeConnectorRemoved(final NodeConnectorRemoved notification) {
 114         InstanceIdentifier<TerminationPoint> tpInstance = toTerminationPointIdentifier(notification
 115                 .getNodeConnectorRef());
 116         TpId tpId = toTerminationPointId(getNodeConnectorKey(notification.getNodeConnectorRef()).getId());
 117
 118         synchronized (this) {
 119             DataModificationTransaction tx = dataService.beginTransaction();
 120             tx.removeOperationalData(tpInstance);
 121             removeAffectedLinks(tx, tpId);
 122             listenOnTransactionState(tx.getIdentifier(),tx.commit());
 123         }
 124     }
 125
 126     @Override
 127     public void onNodeConnectorUpdated(final NodeConnectorUpdated notification) {
 128         FlowCapableNodeConnectorUpdated fcncu = notification.getAugmentation(FlowCapableNodeConnectorUpdated.class);
 129         if (fcncu != null) {
 130             NodeId nodeId = toTopologyNodeId(getNodeKey(notification.getNodeConnectorRef()).getId());
 131             TerminationPoint point = toTerminationPoint(toTerminationPointId(notification.getId()),
 132                     notification.getNodeConnectorRef());
 133             InstanceIdentifier<TerminationPoint> path = tpPath(nodeId, point.getKey().getTpId());
 134
 135             synchronized (this) {
 136                 DataModificationTransaction tx = dataService.beginTransaction();
 137                 tx.putOperationalData(path, point);
 138                 if ((fcncu.getState() != null && fcncu.getState().isLinkDown())
 139                         || (fcncu.getConfiguration() != null && fcncu.getConfiguration().isPORTDOWN())) {
 140                     removeAffectedLinks(tx, point.getTpId());
 141                 }
 142                 listenOnTransactionState(tx.getIdentifier(),tx.commit());
 143             }
 144         }
 145     }
 146
 147     @Override
 148     public void onLinkDiscovered(final LinkDiscovered notification) {
 149         Link link = toTopologyLink(notification);
 150         InstanceIdentifier<Link> path = linkPath(link);
 151
 152         synchronized (this) {
 153             DataModificationTransaction tx = dataService.beginTransaction();
 154             tx.putOperationalData(path, link);
 155             listenOnTransactionState(tx.getIdentifier(),tx.commit());
 156         }
 157     }
 158
 159     @Override
 160     public void onLinkOverutilized(final LinkOverutilized notification) {
 161         // NOOP
 162     }
 163
 164     @Override
 165     public void onLinkRemoved(final LinkRemoved notification) {
 166         InstanceIdentifier<Link> path = linkPath(toTopologyLink(notification));
 167
 168         synchronized (this) {
 169             DataModificationTransaction tx = dataService.beginTransaction();
 170             tx.removeOperationalData(path);
 171             listenOnTransactionState(tx.getIdentifier(),tx.commit());
 172         }
 173     }
 174
 175     @Override
 176     public void onLinkUtilizationNormal(final LinkUtilizationNormal notification) {
 177         // NOOP
 178     }
 179
 180     private static InstanceIdentifier<Node> toNodeIdentifier(final NodeRef ref) {
 181         org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey invNodeKey = getNodeKey(ref);
 182         NodeKey nodeKey = new NodeKey(toTopologyNodeId(invNodeKey.getId()));
 183         return TOPOLOGY_PATH.child(Node.class, nodeKey);
 184     }
 185
 186     private static InstanceIdentifier<TerminationPoint> toTerminationPointIdentifier(final NodeConnectorRef ref) {
 187         org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey invNodeKey = getNodeKey(ref);
 188         NodeConnectorKey invNodeConnectorKey = getNodeConnectorKey(ref);
 189         return tpPath(toTopologyNodeId(invNodeKey.getId()), toTerminationPointId(invNodeConnectorKey.getId()));
 190     }
 191
 192     private void removeAffectedLinks(final DataModificationTransaction transaction, final NodeId id) {
 193         TypeSafeDataReader reader = TypeSafeDataReader.forReader(transaction);
 194
 195         Topology topologyData = reader.readOperationalData(TOPOLOGY_PATH);
 196         if (topologyData == null) {
 197             return;
 198         }
 199         for (Link link : topologyData.getLink()) {
 200             if (id.equals(link.getSource().getSourceNode()) || id.equals(link.getDestination().getDestNode())) {
 201                 transaction.removeOperationalData(linkPath(link));
 202             }
 203         }
 204     }
 205
 206     private void removeAffectedLinks(final DataModificationTransaction transaction, final TpId id) {
 207         TypeSafeDataReader reader = TypeSafeDataReader.forReader(transaction);
 208         Topology topologyData = reader.readOperationalData(TOPOLOGY_PATH);
 209         if (topologyData == null) {
 210             return;
 211         }
 212         for (Link link : topologyData.getLink()) {
 213             if (id.equals(link.getSource().getSourceTp()) || id.equals(link.getDestination().getDestTp())) {
 214                 transaction.removeOperationalData(linkPath(link));
 215             }
 216         }
 217     }
 218
 219     private static InstanceIdentifier<Node> getNodePath(final NodeId nodeId) {
 220         return TOPOLOGY_PATH.child(Node.class, new NodeKey(nodeId));
 221     }
 222
 223     private static InstanceIdentifier<TerminationPoint> tpPath(final NodeId nodeId, final TpId tpId) {
 224         NodeKey nodeKey = new NodeKey(nodeId);
 225         TerminationPointKey tpKey = new TerminationPointKey(tpId);
 226         return TOPOLOGY_PATH.child(Node.class, nodeKey).child(TerminationPoint.class, tpKey);
 227     }
 228
 229     private static InstanceIdentifier<Link> linkPath(final Link link) {
 230         return TOPOLOGY_PATH.child(Link.class, link.getKey());
 231     }
 232
 233     /**
 234      * @param txId transaction identificator
 235      * @param future transaction result
 236      */
 237     private static void listenOnTransactionState(final Object txId, final Future<RpcResult<TransactionStatus>> future) {
 238         Futures.addCallback(JdkFutureAdapters.listenInPoolThread(future),new FutureCallback<RpcResult<TransactionStatus>>() {
 239             @Override
 240             public void onFailure(final Throwable t) {
 241                 LOG.error("Topology export failed for Tx:{}", txId, t);
 242             }
 243
 244             @Override
 245             public void onSuccess(final RpcResult<TransactionStatus> result) {
 246                 if(!result.isSuccessful()) {
 247                     LOG.error("Topology export failed for Tx:{}", txId);
 248                 }
 249             }
 250         });
 251     }
 252 }