nemo-renderers/openflow-renderer/src/main/java/org/opendaylight/nemo/renderer/openflow/physicalnetwork/PhysicalNetworkAdapter.java

   1 /*
   2  * Copyright (c) 2015 Huawei, 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
   9 package org.opendaylight.nemo.renderer.openflow.physicalnetwork;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.util.concurrent.FutureCallback;
  13 import com.google.common.util.concurrent.Futures;
  14 import com.google.common.util.concurrent.ListenableFuture;
  15 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  16 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  17 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  18 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  19 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
  20 import org.opendaylight.nemo.renderer.openflow.FlowUtils;
  21 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.links.PhysicalLink;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.links.PhysicalLinkBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.links.PhysicalLinkKey;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.nodes.PhysicalNode;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.nodes.PhysicalNodeBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.nodes.PhysicalNodeKey;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.node.instance.PhysicalPort;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.node.instance.PhysicalPortBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.node.instance.PhysicalPortKey;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.PhysicalLinkId;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.PhysicalNodeId;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.PhysicalPortId;
  40 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  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.network.topology.Topology;
  43 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  44 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
  45 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  46 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  47 import org.opendaylight.yangtools.yang.binding.NotificationListener;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 import java.util.ArrayList;
  52 import java.util.List;
  53 import java.util.Timer;
  54 import java.util.TimerTask;
  55 import java.util.concurrent.CopyOnWriteArraySet;
  56 import java.util.concurrent.CountDownLatch;
  57
  58 public class PhysicalNetworkAdapter {
  59     private static final Logger log = LoggerFactory.getLogger(PhysicalNetworkAdapter.class);
  60     private static final String DEFAULT_TOPOLOGY_ID = "flow:1";
  61
  62     final private DataBroker dataBroker;
  63     private PhyConfigLoader phyConfigLoader;
  64     private DataBrokerAdapter dataBrokerAdapter;
  65     private PhysicalFlowUtils physicalFlowUtils;
  66     private FlowUtils ofFlowUtils;
  67     private NotificationProviderService notificationProviderService;
  68
  69     private CopyOnWriteArraySet<String> nodeIdSet;
  70     private CopyOnWriteArraySet<PhysicalLink> physicalLinkSet;
  71     private Timer phyTimer;
  72     private boolean running = false;
  73     private Integer mutex = 0;
  74     private ListenerRegistration<NotificationListener> ofPacketInListenerReg;
  75     private ListenerRegistration<DataChangeListener> ofNodesListenerReg;
  76     private ListenerRegistration<DataChangeListener> ofLinksListenerReg;
  77
  78     public PhysicalNetworkAdapter(DataBroker dataBroker
  79             , NotificationProviderService notificationProviderService
  80             , PhyConfigLoader phyConfigLoader
  81             , FlowUtils ofFlowUtils) {
  82         this.dataBroker = dataBroker;
  83         this.notificationProviderService = notificationProviderService;
  84         this.ofFlowUtils = ofFlowUtils;
  85         this.phyConfigLoader = phyConfigLoader;
  86         this.dataBrokerAdapter = new DataBrokerAdapter(dataBroker);
  87         physicalFlowUtils = new PhysicalFlowUtils(dataBroker);
  88         nodeIdSet = new CopyOnWriteArraySet<String>();
  89         physicalLinkSet = new CopyOnWriteArraySet<PhysicalLink>();
  90
  91         phyTimer = new Timer();
  92
  93
  94         registerListeners();
  95         initOFNodes();
  96         initOFLinks();
  97     }
  98
  99     public void close() {
 100         if (ofPacketInListenerReg != null)
 101             ofPacketInListenerReg.close();
 102         if (ofLinksListenerReg != null)
 103             ofLinksListenerReg.close();
 104         if (ofNodesListenerReg != null)
 105             ofNodesListenerReg.close();
 106         if (phyConfigLoader != null)
 107             phyConfigLoader.close();
 108         log.debug("Clear....\r\n{}", nodeIdSet);
 109         nodeIdSet.clear();
 110         physicalLinkSet.clear();
 111     }
 112
 113     public PhyConfigLoader getPhyConfigLoader() {
 114         return phyConfigLoader;
 115     }
 116
 117     /**
 118      * OFNode instance identifier
 119      *
 120      * @return
 121      */
 122     private InstanceIdentifier<Node> getOFNodeInstanceIdentifier() {
 123         return InstanceIdentifier.builder(Nodes.class).child(Node.class).build();
 124     }
 125
 126     private InstanceIdentifier<Link> getOFLinkInstanceIdentifier() {
 127         return InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class, new TopologyKey(new TopologyId(DEFAULT_TOPOLOGY_ID))).child(Link.class).build();
 128     }
 129
 130     private InstanceIdentifier<Topology> getOFTopologyInstanceIdentifier() {
 131         return InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class, new TopologyKey(new TopologyId(DEFAULT_TOPOLOGY_ID))).build();
 132     }
 133
 134     private InstanceIdentifier<Nodes> getOFNodesInstanceIdentifier() {
 135         return InstanceIdentifier.builder(Nodes.class).build();
 136     }
 137
 138     private InstanceIdentifier<NodeConnector> getOFPortInstanceIdentifier(NodeKey nodeKey, NodeConnectorKey connectorKey) {
 139         return InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey).child(NodeConnector.class, connectorKey).build();
 140     }
 141
 142     private void registerListeners() {
 143         InstanceIdentifier<Node> nodeInsId = getOFNodeInstanceIdentifier();
 144         InstanceIdentifier<Link> linkInsId = getOFLinkInstanceIdentifier();
 145         ofNodesListenerReg = dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, nodeInsId, new OFNodeListener(this), DataChangeScope.BASE);
 146         ofLinksListenerReg = dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, linkInsId, new OFLinkListener(this), DataChangeScope.BASE);
 147         ofPacketInListenerReg = notificationProviderService.registerNotificationListener(new OFPacketInListener(ofFlowUtils));
 148     }
 149
 150     private void initOFLinks() {
 151         InstanceIdentifier<Topology> topologyInsId = getOFTopologyInstanceIdentifier();
 152         ListenableFuture<Optional<Topology>> topologyFuture = dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL, topologyInsId);
 153         Futures.addCallback(topologyFuture, new FutureCallback<Optional<Topology>>() {
 154             @Override
 155             public void onSuccess(Optional<Topology> result) {
 156                 if (result.isPresent() && result.get() instanceof Topology) {
 157                     Topology topology = result.get();
 158                     if (topology != null && topology.getLink() != null)
 159                         for (Link link : topology.getLink()) {
 160                             ofLinkAdded(link);
 161                         }
 162                 }
 163
 164                 return;
 165             }
 166
 167             @Override
 168             public void onFailure(Throwable t) {
 169                 log.error("Can not read the link info of topology {}: {}", DEFAULT_TOPOLOGY_ID, t);
 170                 return;
 171             }
 172         });
 173     }
 174
 175     private void initOFNodes() {
 176         InstanceIdentifier<Nodes> nodesInsId = getOFNodesInstanceIdentifier();
 177         ListenableFuture<Optional<Nodes>> nodesFuture = dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL, nodesInsId);
 178         Futures.addCallback(nodesFuture, new FutureCallback<Optional<Nodes>>() {
 179             @Override
 180             public void onSuccess(Optional<Nodes> result) {
 181                 if (result.isPresent() && result.get() instanceof Nodes) {
 182                     Nodes nodes = result.get();
 183                     if (nodes != null && nodes.getNode() != null)
 184                         for (Node node : nodes.getNode()) {
 185                             ofNodeAdded(node);
 186                         }
 187                 }
 188                 return;
 189             }
 190
 191             @Override
 192             public void onFailure(Throwable t) {
 193                 log.error("Can not read node information: {}", t);
 194                 return;
 195             }
 196         });
 197
 198     }
 199
 200     protected void ofNodeAdded(Node node) {
 201         log.debug("OF node added: {}.", node.getKey());
 202         String strNodeId = node.getId().getValue();
 203         //add default flow entry.
 204         physicalFlowUtils.configArpPEntry(strNodeId);
 205         physicalFlowUtils.configLLDPEntry(strNodeId);
 206
 207         PhysicalNodeId nodeId = new PhysicalNodeId(strNodeId);
 208         PhysicalNodeBuilder nodeBuilder = new PhysicalNodeBuilder();
 209         nodeBuilder.setNodeId(nodeId);
 210         nodeBuilder.setKey(new PhysicalNodeKey(nodeId));
 211         List<PhysicalPort> physicalPortList = new ArrayList<PhysicalPort>();
 212         List<NodeConnector> nodeConnectors = node.getNodeConnector();
 213         if (nodeConnectors != null) {
 214             for (NodeConnector nodeConnector : nodeConnectors) {
 215                 PhysicalPort physicalPort = getPhysicalPort(node.getKey(), nodeConnector);
 216                 if (physicalPort != null) {
 217                     physicalPortList.add(physicalPort);
 218                 }
 219             }
 220         }
 221         nodeBuilder.setPhysicalPort(physicalPortList);
 222
 223         PhysicalNode confPhyNode = phyConfigLoader.getPhysicalNode(nodeId);
 224         if (confPhyNode != null) {
 225             nodeBuilder.setNodeType(confPhyNode.getNodeType());
 226             nodeBuilder.setAttribute(confPhyNode.getAttribute());
 227         } else {
 228             log.warn("Find one OF Node {},does not have info in config file.", node.getKey());
 229         }
 230         boolean result = dataBrokerAdapter.addPhysicalNode(nodeBuilder.build());
 231 //        if (result) {
 232         nodeIdSet.add(strNodeId);
 233         log.debug("Add....{}\r\n{}", strNodeId, nodeIdSet);
 234 //        }
 235     }
 236
 237     protected void ofNodeRemoved(Node node) {
 238         log.debug("OF node removed: {}.", node.getKey());
 239         String strNodeId = node.getId().getValue();
 240         PhysicalNodeId nodeId = new PhysicalNodeId(strNodeId);
 241         PhysicalNode confPhyNode = phyConfigLoader.getPhysicalNode(nodeId);
 242         if (confPhyNode == null) {
 243             log.warn("Find one OF Node removed {},does not have info in config file.", node.getKey());
 244         }
 245         boolean result = dataBrokerAdapter.removePhysicalNode(new PhysicalNodeKey(nodeId));
 246 //        if (result) {
 247         nodeIdSet.remove(strNodeId);
 248         log.debug("Remove....{}\r\n{}", strNodeId, nodeIdSet);
 249 //        }
 250     }
 251
 252     private PhysicalPort getPhysicalPort(NodeKey nodeKey, NodeConnector nodeConnector) {
 253         String strConnectorId = nodeConnector.getId().getValue();
 254         if (strConnectorId.contains("LOCAL"))
 255             return null;
 256         PhysicalPortId physicalPortId = new PhysicalPortId(strConnectorId);
 257         log.debug("Get port {} : {}.", nodeKey, nodeConnector.getId().getValue());
 258         FlowCapableNodeConnector flowCapableNodeConnector = getOFPort(nodeKey, nodeConnector.getKey());
 259         if (flowCapableNodeConnector != null) {
 260             PhysicalPortBuilder physicalPortBuilder = new PhysicalPortBuilder();
 261             physicalPortBuilder.setPortId(physicalPortId);
 262             physicalPortBuilder.setKey(new PhysicalPortKey(physicalPortId));
 263             physicalPortBuilder.setBandwidth(PhyConfigLoader.DEFAULT_LINK_BANDWIDTH);
 264             MacAddress macAddress = flowCapableNodeConnector.getHardwareAddress();
 265             physicalPortBuilder.setMacAddress(macAddress);
 266
 267             PhysicalPort confPhyPort = phyConfigLoader.getPhysicalPort(physicalPortId);
 268             if (confPhyPort != null) {
 269                 log.debug("Set port {} : {}.\r\n {} \r\n{}", nodeKey, nodeConnector.getId().getValue(), confPhyPort.getPortType().toString(), confPhyPort.getAttribute());
 270 //                long bandwidth = flowCapableNodeConnector.getMaximumSpeed() > 0 ? flowCapableNodeConnector.getMaximumSpeed() : confPhyPort.getBandwidth();
 271                 physicalPortBuilder.setPortType(confPhyPort.getPortType());
 272                 physicalPortBuilder.setAttribute(confPhyPort.getAttribute());
 273             } else {
 274                 log.warn("Can not get config info of {}-{} form data broker.", nodeKey.getId(), strConnectorId);
 275             }
 276             return physicalPortBuilder.build();
 277         } else {
 278             log.warn("Can not read OF port info of {}-{} form .", nodeKey.getId(), strConnectorId);
 279         }
 280         return null;
 281     }
 282
 283     private FlowCapableNodeConnector getOFPort(final NodeKey nodeKey, final NodeConnectorKey nodeConnectorKey) {
 284         final FlowCapableNodeConnector[] flowCapableNodeConnector = {null};
 285
 286         InstanceIdentifier<NodeConnector> nodeConnectorInsId = getOFPortInstanceIdentifier(nodeKey, nodeConnectorKey);
 287         final CountDownLatch downLatch = new CountDownLatch(1);
 288         ListenableFuture<Optional<NodeConnector>> nodeConnectorFuture = dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL, nodeConnectorInsId);
 289         Futures.addCallback(nodeConnectorFuture, new FutureCallback<Optional<NodeConnector>>() {
 290             @Override
 291             public void onSuccess(Optional<NodeConnector> result) {
 292                 if (result.isPresent() && result.get() instanceof NodeConnector) {
 293                     flowCapableNodeConnector[0] = result.get().getAugmentation(FlowCapableNodeConnector.class);
 294                     downLatch.countDown();
 295                 }
 296
 297                 return;
 298             }
 299
 300             @Override
 301             public void onFailure(Throwable t) {
 302                 log.error("Can not read the information of node connector {}-{} : {}", nodeKey, nodeConnectorKey, t);
 303                 downLatch.countDown();
 304                 return;
 305             }
 306         });
 307
 308         try {
 309             downLatch.await();
 310         } catch (InterruptedException e) {
 311             e.printStackTrace();
 312         }
 313
 314         return flowCapableNodeConnector[0];
 315     }
 316
 317     protected void ofLinkAdded(Link link) {
 318         log.debug("OF link added:{}.", link.getKey());
 319
 320         String srcNode = link.getSource().getSourceNode().getValue();
 321         String srcTp = link.getSource().getSourceTp().getValue();
 322         String dstNode = link.getDestination().getDestNode().getValue();
 323         String dstTp = link.getDestination().getDestTp().getValue();
 324
 325         String strLinkId = link.getLinkId().getValue();
 326         PhysicalLinkBuilder linkBuilder = new PhysicalLinkBuilder();
 327         linkBuilder.setLinkId(new PhysicalLinkId(strLinkId));
 328         linkBuilder.setSrcNodeId(new PhysicalNodeId(srcNode));
 329         linkBuilder.setSrcPortId(new PhysicalPortId(srcTp));
 330         linkBuilder.setDestNodeId(new PhysicalNodeId(dstNode));
 331         linkBuilder.setDestPortId(new PhysicalPortId(dstTp));
 332
 333         linkBuilder.setBandwidth(PhyConfigLoader.DEFAULT_LINK_BANDWIDTH);
 334         linkBuilder.setDelay(PhyConfigLoader.DEFAULT_LINK_DELAY);
 335         linkBuilder.setLossRate(PhyConfigLoader.DEFAULT_LINK_LOSS_RATE);
 336
 337         PhysicalLinkId physicalLinkId = new PhysicalLinkId(strLinkId);
 338         PhysicalLink physicalLink = phyConfigLoader.getPhysicalLink(physicalLinkId);
 339         if (physicalLink != null) {
 340             linkBuilder.setMetric(physicalLink.getMetric());
 341         } else {
 342             log.warn("Can not find conf info of {}.", link.getKey());
 343         }
 344         synchronized (mutex) {
 345             physicalLinkSet.add(linkBuilder.build());
 346             if (!running) {
 347                 phyTimer.schedule(new PhyTransmit(), 10, 100);
 348                 running = true;
 349             }
 350         }
 351     }
 352
 353     protected void ofLinkRemoved(Link link) {
 354         log.debug("OF link removed:{}.", link.getKey());
 355         String strLinkId = link.getLinkId().getValue();
 356         PhysicalLinkId linkId = new PhysicalLinkId(strLinkId);
 357         PhysicalLink confPhyLink = phyConfigLoader.getPhysicalLink(linkId);
 358         if (confPhyLink == null) {
 359             log.warn("Can not find conf info of {} while remove.", link);
 360         }
 361
 362         dataBrokerAdapter.removePhysicalLink(new PhysicalLinkKey(linkId));
 363     }
 364
 365     class PhyTransmit extends TimerTask {
 366
 367         @Override
 368         public void run() {
 369             synchronized (mutex) {
 370                 for (PhysicalLink physicalLink : physicalLinkSet) {
 371                     handleLink(physicalLink);
 372                 }
 373                 if (physicalLinkSet.size() == 0) {
 374                     phyTimer.cancel();
 375                     running = false;
 376                 }
 377             }
 378         }
 379
 380         private void handleLink(PhysicalLink physicalLink) {
 381             String srcNodeId = physicalLink.getSrcNodeId().getValue();
 382             String dsrNodeId = physicalLink.getDestNodeId().getValue();
 383             if (nodeIdSet.contains(srcNodeId) && nodeIdSet.contains(dsrNodeId)) {
 384                 physicalLinkSet.remove(physicalLink);
 385                 log.debug("Put [{}]-[{}] to data broker.", srcNodeId, dsrNodeId);
 386                 dataBrokerAdapter.addPhysicalLink(physicalLink);
 387             }
 388         }
 389     }
 390 }