opendaylight/adsal/topologymanager/implementation/src/main/java/org/opendaylight/controller/topologymanager/internal/TopologyManagerImpl.java

   1 /*
   2  * Copyright (c) 2013 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
   9 package org.opendaylight.controller.topologymanager.internal;
  10
  11 import org.apache.commons.lang3.tuple.ImmutablePair;
  12 import org.apache.felix.dm.Component;
  13 import org.eclipse.osgi.framework.console.CommandInterpreter;
  14 import org.eclipse.osgi.framework.console.CommandProvider;
  15 import org.opendaylight.controller.clustering.services.CacheConfigException;
  16 import org.opendaylight.controller.clustering.services.CacheExistException;
  17 import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
  18 import org.opendaylight.controller.clustering.services.IClusterContainerServices;
  19 import org.opendaylight.controller.clustering.services.IClusterServices;
  20 import org.opendaylight.controller.configuration.ConfigurationObject;
  21 import org.opendaylight.controller.configuration.IConfigurationContainerAware;
  22 import org.opendaylight.controller.configuration.IConfigurationContainerService;
  23 import org.opendaylight.controller.sal.core.Edge;
  24 import org.opendaylight.controller.sal.core.Host;
  25 import org.opendaylight.controller.sal.core.Node;
  26 import org.opendaylight.controller.sal.core.NodeConnector;
  27 import org.opendaylight.controller.sal.core.Property;
  28 import org.opendaylight.controller.sal.core.TimeStamp;
  29 import org.opendaylight.controller.sal.core.UpdateType;
  30 import org.opendaylight.controller.sal.topology.IListenTopoUpdates;
  31 import org.opendaylight.controller.sal.topology.ITopologyService;
  32 import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
  33 import org.opendaylight.controller.sal.utils.IObjectReader;
  34 import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
  35 import org.opendaylight.controller.sal.utils.Status;
  36 import org.opendaylight.controller.sal.utils.StatusCode;
  37 import org.opendaylight.controller.switchmanager.ISwitchManager;
  38 import org.opendaylight.controller.topologymanager.ITopologyManager;
  39 import org.opendaylight.controller.topologymanager.ITopologyManagerAware;
  40 import org.opendaylight.controller.topologymanager.ITopologyManagerClusterWideAware;
  41 import org.opendaylight.controller.topologymanager.ITopologyManagerShell;
  42 import org.opendaylight.controller.topologymanager.TopologyUserLinkConfig;
  43 import org.osgi.framework.BundleContext;
  44 import org.osgi.framework.FrameworkUtil;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 import java.io.FileNotFoundException;
  49 import java.io.IOException;
  50 import java.io.ObjectInputStream;
  51 import java.util.ArrayList;
  52 import java.util.Dictionary;
  53 import java.util.EnumSet;
  54 import java.util.HashMap;
  55 import java.util.HashSet;
  56 import java.util.Iterator;
  57 import java.util.LinkedList;
  58 import java.util.List;
  59 import java.util.Map;
  60 import java.util.Set;
  61 import java.util.concurrent.BlockingQueue;
  62 import java.util.concurrent.ConcurrentHashMap;
  63 import java.util.concurrent.ConcurrentMap;
  64 import java.util.concurrent.CopyOnWriteArraySet;
  65 import java.util.concurrent.LinkedBlockingQueue;
  66
  67 /**
  68  * The class describes TopologyManager which is the central repository of the
  69  * network topology. It provides service for applications to interact with
  70  * topology database and notifies all the listeners of topology changes.
  71  */
  72 public class TopologyManagerImpl implements
  73         ICacheUpdateAware<Object, Object>,
  74         ITopologyManager,
  75         ITopologyManagerShell,
  76         IConfigurationContainerAware,
  77         IListenTopoUpdates,
  78         IObjectReader,
  79         CommandProvider {
  80     protected static final String TOPOEDGESDB = "topologymanager.edgesDB";
  81     protected static final String TOPOHOSTSDB = "topologymanager.hostsDB";
  82     protected static final String TOPONODECONNECTORDB = "topologymanager.nodeConnectorDB";
  83     protected static final String TOPOUSERLINKSDB = "topologymanager.userLinksDB";
  84     private static final String USER_LINKS_FILE_NAME = "userTopology.conf";
  85     private static final Logger log = LoggerFactory.getLogger(TopologyManagerImpl.class);
  86     private ITopologyService topoService;
  87     private IClusterContainerServices clusterContainerService;
  88     private IConfigurationContainerService configurationService;
  89     private ISwitchManager switchManager;
  90     // DB of all the Edges with properties which constitute our topology
  91     private ConcurrentMap<Edge, Set<Property>> edgesDB;
  92     // DB of all NodeConnector which are part of ISL Edges, meaning they
  93     // are connected to another NodeConnector on the other side of an ISL link.
  94     // NodeConnector of a Production Edge is not part of this DB.
  95     private ConcurrentMap<NodeConnector, Set<Property>> nodeConnectorsDB;
  96     // DB of all the NodeConnectors with an Host attached to it
  97     private ConcurrentMap<NodeConnector, Set<ImmutablePair<Host, Set<Property>>>> hostsDB;
  98     // Topology Manager Aware listeners
  99     private Set<ITopologyManagerAware> topologyManagerAware = new CopyOnWriteArraySet<ITopologyManagerAware>();
 100     // Topology Manager Aware listeners - for clusterwide updates
 101     private Set<ITopologyManagerClusterWideAware> topologyManagerClusterWideAware =
 102             new CopyOnWriteArraySet<ITopologyManagerClusterWideAware>();
 103     private ConcurrentMap<String, TopologyUserLinkConfig> userLinksDB;
 104     private BlockingQueue<TopoEdgeUpdate> notifyQ = new LinkedBlockingQueue<TopoEdgeUpdate>();
 105     private volatile Boolean shuttingDown = false;
 106     private Thread notifyThread;
 107
 108
 109     void nonClusterObjectCreate() {
 110         edgesDB = new ConcurrentHashMap<Edge, Set<Property>>();
 111         hostsDB = new ConcurrentHashMap<NodeConnector, Set<ImmutablePair<Host, Set<Property>>>>();
 112         nodeConnectorsDB = new ConcurrentHashMap<NodeConnector, Set<Property>>();
 113         userLinksDB = new ConcurrentHashMap<String, TopologyUserLinkConfig>();
 114     }
 115
 116     void setTopologyManagerAware(ITopologyManagerAware s) {
 117         if (this.topologyManagerAware != null) {
 118             log.debug("Adding ITopologyManagerAware: {}", s);
 119             this.topologyManagerAware.add(s);
 120         }
 121     }
 122
 123     void unsetTopologyManagerAware(ITopologyManagerAware s) {
 124         if (this.topologyManagerAware != null) {
 125             log.debug("Removing ITopologyManagerAware: {}", s);
 126             this.topologyManagerAware.remove(s);
 127         }
 128     }
 129
 130     void setTopologyManagerClusterWideAware(ITopologyManagerClusterWideAware s) {
 131         if (this.topologyManagerClusterWideAware != null) {
 132             log.debug("Adding ITopologyManagerClusterWideAware: {}", s);
 133             this.topologyManagerClusterWideAware.add(s);
 134         }
 135     }
 136
 137     void unsetTopologyManagerClusterWideAware(ITopologyManagerClusterWideAware s) {
 138         if (this.topologyManagerClusterWideAware != null) {
 139             log.debug("Removing ITopologyManagerClusterWideAware: {}", s);
 140             this.topologyManagerClusterWideAware.remove(s);
 141         }
 142     }
 143
 144     void setTopoService(ITopologyService s) {
 145         log.debug("Adding ITopologyService: {}", s);
 146         this.topoService = s;
 147     }
 148
 149     void unsetTopoService(ITopologyService s) {
 150         if (this.topoService == s) {
 151             log.debug("Removing ITopologyService: {}", s);
 152             this.topoService = null;
 153         }
 154     }
 155
 156     void setClusterContainerService(IClusterContainerServices s) {
 157         log.debug("Cluster Service set");
 158         this.clusterContainerService = s;
 159     }
 160
 161     void unsetClusterContainerService(IClusterContainerServices s) {
 162         if (this.clusterContainerService == s) {
 163             log.debug("Cluster Service removed!");
 164             this.clusterContainerService = null;
 165         }
 166     }
 167
 168     public void setConfigurationContainerService(IConfigurationContainerService service) {
 169         log.trace("Got configuration service set request {}", service);
 170         this.configurationService = service;
 171     }
 172
 173     public void unsetConfigurationContainerService(IConfigurationContainerService service) {
 174         log.trace("Got configuration service UNset request");
 175         this.configurationService = null;
 176     }
 177
 178     void setSwitchManager(ISwitchManager s) {
 179         log.debug("Adding ISwitchManager: {}", s);
 180         this.switchManager = s;
 181     }
 182
 183     void unsetSwitchManager(ISwitchManager s) {
 184         if (this.switchManager == s) {
 185             log.debug("Removing ISwitchManager: {}", s);
 186             this.switchManager = null;
 187         }
 188     }
 189
 190     /**
 191      * Function called by the dependency manager when all the required
 192      * dependencies are satisfied
 193      *
 194      */
 195     void init(Component c) {
 196         allocateCaches();
 197         retrieveCaches();
 198         String containerName = null;
 199         Dictionary<?, ?> props = c.getServiceProperties();
 200         if (props != null) {
 201             containerName = (String) props.get("containerName");
 202         } else {
 203             // In the Global instance case the containerName is empty
 204             containerName = "UNKNOWN";
 205         }
 206
 207         registerWithOSGIConsole();
 208         loadConfiguration();
 209
 210         // Restore the shuttingDown status on init of the component
 211         shuttingDown = false;
 212         notifyThread = new Thread(new TopologyNotify(notifyQ));
 213     }
 214
 215     @SuppressWarnings({ "unchecked" })
 216     private void allocateCaches() {
 217             this.edgesDB =
 218                     (ConcurrentMap<Edge, Set<Property>>) allocateCache(TOPOEDGESDB,EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 219
 220             this.hostsDB =
 221                     (ConcurrentMap<NodeConnector, Set<ImmutablePair<Host, Set<Property>>>>) allocateCache(TOPOHOSTSDB, EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 222
 223             this.nodeConnectorsDB =
 224                     (ConcurrentMap<NodeConnector, Set<Property>>) allocateCache(
 225                             TOPONODECONNECTORDB, EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 226             this.userLinksDB =
 227                     (ConcurrentMap<String, TopologyUserLinkConfig>) allocateCache(
 228                             TOPOUSERLINKSDB, EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 229     }
 230
 231     private ConcurrentMap<?, ?> allocateCache(String cacheName, Set<IClusterServices.cacheMode> cacheModes) {
 232         ConcurrentMap<?, ?> cache = null;
 233         try {
 234             cache = this.clusterContainerService.createCache(cacheName, cacheModes);
 235         } catch (CacheExistException e) {
 236             log.debug(cacheName + " cache already exists - destroy and recreate if needed");
 237         } catch (CacheConfigException e) {
 238             log.error(cacheName + " cache configuration invalid - check cache mode");
 239         }
 240         return cache;
 241     }
 242
 243     @SuppressWarnings({ "unchecked" })
 244     private void retrieveCaches() {
 245         if (this.clusterContainerService == null) {
 246             log.error("Cluster Services is null, can't retrieve caches.");
 247             return;
 248         }
 249
 250         this.edgesDB = (ConcurrentMap<Edge, Set<Property>>) this.clusterContainerService.getCache(TOPOEDGESDB);
 251         if (edgesDB == null) {
 252             log.error("Failed to get cache for " + TOPOEDGESDB);
 253         }
 254
 255         this.hostsDB =
 256                 (ConcurrentMap<NodeConnector, Set<ImmutablePair<Host, Set<Property>>>>) this.clusterContainerService.getCache(TOPOHOSTSDB);
 257         if (hostsDB == null) {
 258             log.error("Failed to get cache for " + TOPOHOSTSDB);
 259         }
 260
 261         this.nodeConnectorsDB =
 262                 (ConcurrentMap<NodeConnector, Set<Property>>) this.clusterContainerService.getCache(TOPONODECONNECTORDB);
 263         if (nodeConnectorsDB == null) {
 264             log.error("Failed to get cache for " + TOPONODECONNECTORDB);
 265         }
 266
 267         this.userLinksDB =
 268                 (ConcurrentMap<String, TopologyUserLinkConfig>) this.clusterContainerService.getCache(TOPOUSERLINKSDB);
 269         if (userLinksDB == null) {
 270             log.error("Failed to get cache for " + TOPOUSERLINKSDB);
 271         }
 272     }
 273
 274     /**
 275      * Function called after the topology manager has registered the service in
 276      * OSGi service registry.
 277      *
 278      */
 279     void started() {
 280         // Start the batcher thread for the cluster wide topology updates
 281         notifyThread.start();
 282         // SollicitRefresh MUST be called here else if called at init
 283         // time it may sollicit refresh too soon.
 284         log.debug("Sollicit topology refresh");
 285         topoService.sollicitRefresh();
 286     }
 287
 288     void stop() {
 289         shuttingDown = true;
 290         notifyThread.interrupt();
 291     }
 292
 293     /**
 294      * Function called by the dependency manager when at least one dependency
 295      * become unsatisfied or when the component is shutting down because for
 296      * example bundle is being stopped.
 297      *
 298      */
 299     void destroy() {
 300         notifyQ.clear();
 301         notifyThread = null;
 302     }
 303
 304     private void loadConfiguration() {
 305         for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, USER_LINKS_FILE_NAME)) {
 306             addUserLink((TopologyUserLinkConfig) conf);
 307         }
 308     }
 309
 310     @Override
 311     public Status saveConfig() {
 312         return saveConfigInternal();
 313     }
 314
 315     public Status saveConfigInternal() {
 316         Status saveStatus = configurationService.persistConfiguration(
 317                 new ArrayList<ConfigurationObject>(userLinksDB.values()), USER_LINKS_FILE_NAME);
 318
 319         if (!saveStatus.isSuccess()) {
 320             return new Status(StatusCode.INTERNALERROR, "Topology save failed: " + saveStatus.getDescription());
 321         }
 322         return saveStatus;
 323     }
 324
 325     @Override
 326     public Map<Node, Set<Edge>> getNodeEdges() {
 327         if (this.edgesDB == null) {
 328             return null;
 329         }
 330
 331         Map<Node, Set<Edge>> res = new HashMap<Node, Set<Edge>>();
 332         for (Edge edge : this.edgesDB.keySet()) {
 333             // Lets analyze the tail
 334             Node node = edge.getTailNodeConnector().getNode();
 335             Set<Edge> nodeEdges = res.get(node);
 336             if (nodeEdges == null) {
 337                 nodeEdges = new HashSet<Edge>();
 338                 res.put(node, nodeEdges);
 339             }
 340             nodeEdges.add(edge);
 341
 342             // Lets analyze the head
 343             node = edge.getHeadNodeConnector().getNode();
 344             nodeEdges = res.get(node);
 345             if (nodeEdges == null) {
 346                 nodeEdges = new HashSet<Edge>();
 347                 res.put(node, nodeEdges);
 348             }
 349             nodeEdges.add(edge);
 350         }
 351
 352         return res;
 353     }
 354
 355     @Override
 356     public boolean isInternal(NodeConnector p) {
 357         if (this.nodeConnectorsDB == null) {
 358             return false;
 359         }
 360
 361         // This is an internal NodeConnector if is connected to
 362         // another Node i.e it's part of the nodeConnectorsDB
 363         return (this.nodeConnectorsDB.get(p) != null);
 364     }
 365
 366     /**
 367      * This method returns true if the edge is an ISL link.
 368      *
 369      * @param e
 370      *            The edge
 371      * @return true if it is an ISL link
 372      */
 373     public boolean isISLink(Edge e) {
 374         return (!isProductionLink(e));
 375     }
 376
 377     /**
 378      * This method returns true if the edge is a production link.
 379      *
 380      * @param e
 381      *            The edge
 382      * @return true if it is a production link
 383      */
 384     public boolean isProductionLink(Edge e) {
 385         return (e.getHeadNodeConnector().getType().equals(NodeConnector.NodeConnectorIDType.PRODUCTION)
 386                 || e.getTailNodeConnector().getType().equals(NodeConnector.NodeConnectorIDType.PRODUCTION));
 387     }
 388
 389     /**
 390      * This method cross checks the determination of nodeConnector type by Discovery Service
 391      * against the information in SwitchManager and updates it accordingly.
 392      * @param e
 393      *          The edge
 394      */
 395     private void crossCheckNodeConnectors(Edge e) {
 396         NodeConnector nc;
 397         if (e.getHeadNodeConnector().getType().equals(NodeConnector.NodeConnectorIDType.PRODUCTION)) {
 398             nc = updateNCTypeFromSwitchMgr(e.getHeadNodeConnector());
 399             if (nc != null) {
 400                 e.setHeadNodeConnector(nc);
 401             }
 402         }
 403         if (e.getTailNodeConnector().getType().equals(NodeConnector.NodeConnectorIDType.PRODUCTION)) {
 404             nc = updateNCTypeFromSwitchMgr(e.getTailNodeConnector());
 405             if (nc != null) {
 406                 e.setTailNodeConnector(nc);
 407             }
 408         }
 409     }
 410
 411     /**
 412      * A NodeConnector may have been categorized as of type Production by Discovery Service.
 413      * But at the time when this determination was made, only OF nodes were known to Discovery
 414      * Service. This method checks if the node of nodeConnector is known to SwitchManager. If
 415      * so, then it returns a new NodeConnector with correct type.
 416      *
 417      * @param nc
 418      *       NodeConnector as passed on in the edge
 419      * @return
 420      *       If Node of the NodeConnector is in SwitchManager, then return a new NodeConnector
 421      *       with correct type, null otherwise
 422      */
 423
 424     private NodeConnector updateNCTypeFromSwitchMgr(NodeConnector nc) {
 425
 426         for (Node node : switchManager.getNodes()) {
 427             String nodeName = node.getNodeIDString();
 428             log.trace("Switch Manager Node Name: {}, NodeConnector Node Name: {}", nodeName,
 429                     nc.getNode().getNodeIDString());
 430             if (nodeName.equals(nc.getNode().getNodeIDString())) {
 431                 NodeConnector nodeConnector = NodeConnectorCreator
 432                         .createNodeConnector(node.getType(), nc.getID(), node);
 433                 return nodeConnector;
 434             }
 435         }
 436         return null;
 437     }
 438
 439     /**
 440      * The Map returned is a copy of the current topology hence if the topology
 441      * changes the copy doesn't
 442      *
 443      * @return A Map representing the current topology expressed as edges of the
 444      *         network
 445      */
 446     @Override
 447     public Map<Edge, Set<Property>> getEdges() {
 448         if (this.edgesDB == null) {
 449             return null;
 450         }
 451
 452         Map<Edge, Set<Property>> edgeMap = new HashMap<Edge, Set<Property>>();
 453         Set<Property> props;
 454         for (Map.Entry<Edge, Set<Property>> edgeEntry : edgesDB.entrySet()) {
 455             // Sets of props are copied because the composition of
 456             // those properties could change with time
 457             props = new HashSet<Property>(edgeEntry.getValue());
 458             // We can simply reuse the key because the object is
 459             // immutable so doesn't really matter that we are
 460             // referencing the only owned by a different table, the
 461             // meaning is the same because doesn't change with time.
 462             edgeMap.put(edgeEntry.getKey(), props);
 463         }
 464
 465         return edgeMap;
 466     }
 467
 468     @Override
 469     public Set<NodeConnector> getNodeConnectorWithHost() {
 470         if (this.hostsDB == null) {
 471             return null;
 472         }
 473
 474         return (new HashSet<NodeConnector>(this.hostsDB.keySet()));
 475     }
 476
 477     @Override
 478     public Map<Node, Set<NodeConnector>> getNodesWithNodeConnectorHost() {
 479         if (this.hostsDB == null) {
 480             return null;
 481         }
 482         HashMap<Node, Set<NodeConnector>> res = new HashMap<Node, Set<NodeConnector>>();
 483         Node node;
 484         Set<NodeConnector> portSet;
 485         for (NodeConnector nc : this.hostsDB.keySet()) {
 486             node = nc.getNode();
 487             portSet = res.get(node);
 488             if (portSet == null) {
 489                 // Create the HashSet if null
 490                 portSet = new HashSet<NodeConnector>();
 491                 res.put(node, portSet);
 492             }
 493
 494             // Keep updating the HashSet, given this is not a
 495             // clustered map we can just update the set without
 496             // worrying to update the hashmap.
 497             portSet.add(nc);
 498         }
 499
 500         return (res);
 501     }
 502
 503     @Override
 504     public Host getHostAttachedToNodeConnector(NodeConnector port) {
 505         List<Host> hosts = getHostsAttachedToNodeConnector(port);
 506         if(hosts != null && !hosts.isEmpty()){
 507             return hosts.get(0);
 508         }
 509         return null;
 510     }
 511
 512     @Override
 513     public List<Host> getHostsAttachedToNodeConnector(NodeConnector p) {
 514         Set<ImmutablePair<Host, Set<Property>>> hosts;
 515         if (this.hostsDB == null || (hosts = this.hostsDB.get(p)) == null) {
 516             return null;
 517         }
 518         // create a list of hosts
 519         List<Host> retHosts = new LinkedList<Host>();
 520         for(ImmutablePair<Host, Set<Property>> host : hosts) {
 521             retHosts.add(host.getLeft());
 522         }
 523         return retHosts;
 524     }
 525
 526     @Override
 527     public synchronized void updateHostLink(NodeConnector port, Host h, UpdateType t, Set<Property> props) {
 528
 529         // Clone the property set in case non null else just
 530         // create an empty one. Caches allocated via infinispan
 531         // don't allow null values
 532         if (props == null) {
 533             props = new HashSet<Property>();
 534         } else {
 535             props = new HashSet<Property>(props);
 536         }
 537         ImmutablePair<Host, Set<Property>> thisHost = new ImmutablePair<Host, Set<Property>>(h, props);
 538
 539         // get the host list
 540         Set<ImmutablePair<Host, Set<Property>>> hostSet = this.hostsDB.get(port);
 541         if(hostSet == null) {
 542             hostSet = new HashSet<ImmutablePair<Host, Set<Property>>>();
 543         }
 544         switch (t) {
 545         case ADDED:
 546         case CHANGED:
 547             hostSet.add(thisHost);
 548             this.hostsDB.put(port, hostSet);
 549             break;
 550         case REMOVED:
 551             hostSet.remove(thisHost);
 552             if(hostSet.isEmpty()) {
 553                 //remove only if hasn't been concurrently modified
 554                 this.hostsDB.remove(port, hostSet);
 555             } else {
 556                 this.hostsDB.put(port, hostSet);
 557             }
 558             break;
 559         }
 560     }
 561
 562     private boolean headNodeConnectorExist(Edge e) {
 563         /*
 564          * Only check the head end point which is supposed to be part of a
 565          * network node we control (present in our inventory). If we checked the
 566          * tail end point as well, we would not store the edges that connect to
 567          * a non sdn enable port on a non sdn capable production switch. We want
 568          * to be able to see these switches on the topology.
 569          */
 570         NodeConnector head = e.getHeadNodeConnector();
 571         return (switchManager.doesNodeConnectorExist(head));
 572     }
 573
 574     private TopoEdgeUpdate edgeUpdate(Edge e, UpdateType type, Set<Property> props) {
 575         switch (type) {
 576         case ADDED:
 577
 578
 579             if (this.edgesDB.containsKey(e)) {
 580                 // Avoid redundant updates (e.g. cluster switch-over) as notifications trigger expensive tasks
 581                 log.trace("Skipping redundant edge addition: {}", e);
 582                 return null;
 583             }
 584
 585             // Make sure the props are non-null or create a copy
 586             if (props == null) {
 587                 props = new HashSet<Property>();
 588             } else {
 589                 props = new HashSet<Property>(props);
 590             }
 591
 592
 593             // Ensure that head node connector exists
 594             if (!headNodeConnectorExist(e)) {
 595                 log.warn("Ignore edge that contains invalid node connector: {}", e);
 596                 return null;
 597             }
 598
 599             // Check if nodeConnectors of the edge were correctly categorized
 600             // by protocol plugin
 601             crossCheckNodeConnectors(e);
 602
 603             // Now make sure there is the creation timestamp for the
 604             // edge, if not there, stamp with the first update
 605             boolean found_create = false;
 606             for (Property prop : props) {
 607                 if (prop instanceof TimeStamp) {
 608                     TimeStamp t = (TimeStamp) prop;
 609                     if (t.getTimeStampName().equals("creation")) {
 610                         found_create = true;
 611                         break;
 612                     }
 613                 }
 614             }
 615
 616             if (!found_create) {
 617                 TimeStamp t = new TimeStamp(System.currentTimeMillis(), "creation");
 618                 props.add(t);
 619             }
 620
 621             // Now add this in the database eventually overriding
 622             // something that may have been already existing
 623             this.edgesDB.put(e, props);
 624
 625             // Now populate the DB of NodeConnectors
 626             // NOTE WELL: properties are empty sets, not really needed
 627             // for now.
 628             // The DB only contains ISL ports
 629             if (isISLink(e)) {
 630                 this.nodeConnectorsDB.put(e.getHeadNodeConnector(), new HashSet<Property>(1));
 631                 this.nodeConnectorsDB.put(e.getTailNodeConnector(), new HashSet<Property>(1));
 632             }
 633             log.trace("Edge {}  {}", e.toString(), type.name());
 634             break;
 635         case REMOVED:
 636             // Now remove the edge from edgesDB
 637             this.edgesDB.remove(e);
 638
 639             // Now lets update the NodeConnectors DB, the assumption
 640             // here is that two NodeConnector are exclusively
 641             // connected by 1 and only 1 edge, this is reasonable in
 642             // the same plug (virtual of phisical) we can assume two
 643             // cables won't be plugged. This could break only in case
 644             // of devices in the middle that acts as hubs, but it
 645             // should be safe to assume that won't happen.
 646             this.nodeConnectorsDB.remove(e.getHeadNodeConnector());
 647             this.nodeConnectorsDB.remove(e.getTailNodeConnector());
 648             log.trace("Edge {}  {}", e.toString(), type.name());
 649             break;
 650         case CHANGED:
 651             Set<Property> oldProps = this.edgesDB.get(e);
 652
 653             // When property(s) changes lets make sure we can change it
 654             // all except the creation time stamp because that should
 655             // be set only when the edge is created
 656             TimeStamp timeStamp = null;
 657             if (oldProps != null) {
 658                 for (Property prop : oldProps) {
 659                     if (prop instanceof TimeStamp) {
 660                         TimeStamp tsProp = (TimeStamp) prop;
 661                         if (tsProp.getTimeStampName().equals("creation")) {
 662                             timeStamp = tsProp;
 663                             break;
 664                         }
 665                     }
 666                 }
 667             }
 668
 669             // Now lets make sure new properties are non-null
 670             if (props == null) {
 671                 props = new HashSet<Property>();
 672             } else {
 673                 // Copy the set so noone is going to change the content
 674                 props = new HashSet<Property>(props);
 675             }
 676
 677             // Now lets remove the creation property if exist in the
 678             // new props
 679             for (Iterator<Property> i = props.iterator(); i.hasNext();) {
 680                 Property prop = i.next();
 681                 if (prop instanceof TimeStamp) {
 682                     TimeStamp t = (TimeStamp) prop;
 683                     if (t.getTimeStampName().equals("creation")) {
 684                         if (timeStamp != null) {
 685                             i.remove();
 686                         }
 687                         break;
 688                     }
 689                 }
 690             }
 691
 692             // Now lets add the creation timestamp in it
 693             if (timeStamp != null) {
 694                 props.add(timeStamp);
 695             }
 696
 697             // Finally update
 698             this.edgesDB.put(e, props);
 699             log.trace("Edge {}  {}", e.toString(), type.name());
 700             break;
 701         }
 702         return new TopoEdgeUpdate(e, props, type);
 703     }
 704
 705     @Override
 706     public void edgeUpdate(List<TopoEdgeUpdate> topoedgeupdateList) {
 707         List<TopoEdgeUpdate> teuList = new ArrayList<TopoEdgeUpdate>();
 708         for (int i = 0; i < topoedgeupdateList.size(); i++) {
 709             Edge e = topoedgeupdateList.get(i).getEdge();
 710             Set<Property> p = topoedgeupdateList.get(i).getProperty();
 711             UpdateType type = topoedgeupdateList.get(i).getUpdateType();
 712             TopoEdgeUpdate teu = edgeUpdate(e, type, p);
 713             if (teu != null) {
 714                 teuList.add(teu);
 715             }
 716         }
 717
 718         if (!teuList.isEmpty()) {
 719             // Now update the listeners
 720             for (ITopologyManagerAware s : this.topologyManagerAware) {
 721                 try {
 722                     s.edgeUpdate(teuList);
 723                 } catch (Exception exc) {
 724                     log.error("Exception on edge update:", exc);
 725                 }
 726             }
 727         }
 728     }
 729
 730     private Edge getReverseLinkTuple(TopologyUserLinkConfig link) {
 731         TopologyUserLinkConfig rLink = new TopologyUserLinkConfig(
 732                 link.getName(), link.getDstNodeConnector(), link.getSrcNodeConnector());
 733         return getLinkTuple(rLink);
 734     }
 735
 736
 737     private Edge getLinkTuple(TopologyUserLinkConfig link) {
 738         NodeConnector srcNodeConnector = NodeConnector.fromString(link.getSrcNodeConnector());
 739         NodeConnector dstNodeConnector = NodeConnector.fromString(link.getDstNodeConnector());
 740         try {
 741             return new Edge(srcNodeConnector, dstNodeConnector);
 742         } catch (Exception e) {
 743             return null;
 744         }
 745     }
 746
 747     @Override
 748     public ConcurrentMap<String, TopologyUserLinkConfig> getUserLinks() {
 749         return new ConcurrentHashMap<String, TopologyUserLinkConfig>(userLinksDB);
 750     }
 751
 752     @Override
 753     public Status addUserLink(TopologyUserLinkConfig userLink) {
 754         if (!userLink.isValid()) {
 755             return new Status(StatusCode.BADREQUEST,
 756                     "User link configuration invalid.");
 757         }
 758         userLink.setStatus(TopologyUserLinkConfig.STATUS.LINKDOWN);
 759
 760         //Check if this link already configured
 761         //NOTE: infinispan cache doesn't support Map.containsValue()
 762         // (which is linear time in most ConcurrentMap impl anyway)
 763         for (TopologyUserLinkConfig existingLink : userLinksDB.values()) {
 764             if (existingLink.equals(userLink)) {
 765                 return new Status(StatusCode.CONFLICT, "Link configuration exists");
 766             }
 767         }
 768         //attempt put, if mapping for this key already existed return conflict
 769         if (userLinksDB.putIfAbsent(userLink.getName(), userLink) != null) {
 770             return new Status(StatusCode.CONFLICT, "Link with name : " + userLink.getName()
 771                     + " already exists. Please use another name");
 772         }
 773
 774         Edge linkTuple = getLinkTuple(userLink);
 775         if (linkTuple != null) {
 776             if (!isProductionLink(linkTuple)) {
 777                 TopoEdgeUpdate teu = edgeUpdate(linkTuple, UpdateType.ADDED,
 778                                                 new HashSet<Property>());
 779                 if (teu == null) {
 780                     userLinksDB.remove(userLink.getName());
 781                     return new Status(StatusCode.NOTFOUND,
 782                            "Link configuration contains invalid node connector: "
 783                            + userLink);
 784                 }
 785             }
 786
 787             linkTuple = getReverseLinkTuple(userLink);
 788             if (linkTuple != null) {
 789                 userLink.setStatus(TopologyUserLinkConfig.STATUS.SUCCESS);
 790                 if (!isProductionLink(linkTuple)) {
 791                     edgeUpdate(linkTuple, UpdateType.ADDED, new HashSet<Property>());
 792                 }
 793             }
 794         }
 795         return new Status(StatusCode.SUCCESS);
 796     }
 797
 798     @Override
 799     public Status deleteUserLink(String linkName) {
 800         if (linkName == null) {
 801             return new Status(StatusCode.BADREQUEST, "User link name cannot be null.");
 802         }
 803
 804         TopologyUserLinkConfig link = userLinksDB.remove(linkName);
 805         Edge linkTuple;
 806         if ((link != null) && ((linkTuple = getLinkTuple(link)) != null)) {
 807             if (! isProductionLink(linkTuple)) {
 808                 edgeUpdate(linkTuple, UpdateType.REMOVED, null);
 809             }
 810
 811             linkTuple = getReverseLinkTuple(link);
 812             if (! isProductionLink(linkTuple)) {
 813                 edgeUpdate(linkTuple, UpdateType.REMOVED, null);
 814             }
 815         }
 816         return new Status(StatusCode.SUCCESS);
 817     }
 818
 819     private void registerWithOSGIConsole() {
 820         BundleContext bundleContext = FrameworkUtil.getBundle(this.getClass())
 821                 .getBundleContext();
 822         bundleContext.registerService(CommandProvider.class.getName(), this,
 823                 null);
 824     }
 825
 826     @Override
 827     public String getHelp() {
 828         StringBuffer help = new StringBuffer();
 829         help.append("---Topology Manager---\n");
 830         help.append("\t addUserLink <name> <node connector string> <node connector string>\n");
 831         help.append("\t deleteUserLink <name>\n");
 832         help.append("\t printUserLink\n");
 833         help.append("\t printNodeEdges\n");
 834         return help.toString();
 835     }
 836
 837     public void _printUserLink(CommandInterpreter ci) {
 838         for (String name : this.userLinksDB.keySet()) {
 839             TopologyUserLinkConfig linkConfig = userLinksDB.get(name);
 840             ci.println("Name : " + name);
 841             ci.println(linkConfig);
 842             ci.println("Edge " + getLinkTuple(linkConfig));
 843             ci.println("Reverse Edge " + getReverseLinkTuple(linkConfig));
 844         }
 845     }
 846
 847     public void _addUserLink(CommandInterpreter ci) {
 848         String name = ci.nextArgument();
 849         if ((name == null)) {
 850             ci.println("Please enter a valid Name");
 851             return;
 852         }
 853
 854         String ncStr1 = ci.nextArgument();
 855         if (ncStr1 == null) {
 856             ci.println("Please enter two node connector strings");
 857             return;
 858         }
 859         String ncStr2 = ci.nextArgument();
 860         if (ncStr2 == null) {
 861             ci.println("Please enter second node connector string");
 862             return;
 863         }
 864
 865         NodeConnector nc1 = NodeConnector.fromString(ncStr1);
 866         if (nc1 == null) {
 867             ci.println("Invalid input node connector 1 string: " + ncStr1);
 868             return;
 869         }
 870         NodeConnector nc2 = NodeConnector.fromString(ncStr2);
 871         if (nc2 == null) {
 872             ci.println("Invalid input node connector 2 string: " + ncStr2);
 873             return;
 874         }
 875
 876         TopologyUserLinkConfig config = new TopologyUserLinkConfig(name, ncStr1, ncStr2);
 877         ci.println(this.addUserLink(config));
 878     }
 879
 880     public void _deleteUserLink(CommandInterpreter ci) {
 881         String name = ci.nextArgument();
 882         if ((name == null)) {
 883             ci.println("Please enter a valid Name");
 884             return;
 885         }
 886         this.deleteUserLink(name);
 887     }
 888
 889     public void _printNodeEdges(CommandInterpreter ci) {
 890         Map<Node, Set<Edge>> nodeEdges = getNodeEdges();
 891         if (nodeEdges == null) {
 892             return;
 893         }
 894         Set<Node> nodeSet = nodeEdges.keySet();
 895         if (nodeSet == null) {
 896             return;
 897         }
 898         ci.println("        Node                                         Edge");
 899         for (Node node : nodeSet) {
 900             Set<Edge> edgeSet = nodeEdges.get(node);
 901             if (edgeSet == null) {
 902                 continue;
 903             }
 904             for (Edge edge : edgeSet) {
 905                 ci.println(node + "             " + edge);
 906             }
 907         }
 908     }
 909
 910     @Override
 911     public Object readObject(ObjectInputStream ois)
 912             throws FileNotFoundException, IOException, ClassNotFoundException {
 913         return ois.readObject();
 914     }
 915
 916     @Override
 917     public Status saveConfiguration() {
 918         return saveConfig();
 919     }
 920
 921     @Override
 922     public void edgeOverUtilized(Edge edge) {
 923         log.warn("Link Utilization above normal: {}", edge);
 924     }
 925
 926     @Override
 927     public void edgeUtilBackToNormal(Edge edge) {
 928         log.warn("Link Utilization back to normal: {}", edge);
 929     }
 930
 931     private void edgeUpdateClusterWide(Edge e, UpdateType type, Set<Property> props, boolean isLocal) {
 932         TopoEdgeUpdate upd = new TopoEdgeUpdate(e, props, type);
 933         upd.setLocal(isLocal);
 934         notifyQ.add(upd);
 935     }
 936
 937     @Override
 938     public void entryCreated(final Object key, final String cacheName, final boolean originLocal) {
 939         if (cacheName.equals(TOPOEDGESDB)) {
 940             // This is the case of an Edge being added to the topology DB
 941             final Edge e = (Edge) key;
 942             log.trace("Edge {} CREATED isLocal:{}", e, originLocal);
 943             edgeUpdateClusterWide(e, UpdateType.ADDED, null, originLocal);
 944         }
 945     }
 946
 947     @Override
 948     public void entryUpdated(final Object key, final Object new_value, final String cacheName, final boolean originLocal) {
 949         if (cacheName.equals(TOPOEDGESDB)) {
 950             final Edge e = (Edge) key;
 951             log.trace("Edge {} UPDATED isLocal:{}", e, originLocal);
 952             final Set<Property> props = (Set<Property>) new_value;
 953             edgeUpdateClusterWide(e, UpdateType.CHANGED, props, originLocal);
 954         }
 955     }
 956
 957     @Override
 958     public void entryDeleted(final Object key, final String cacheName, final boolean originLocal) {
 959         if (cacheName.equals(TOPOEDGESDB)) {
 960             final Edge e = (Edge) key;
 961             log.trace("Edge {} DELETED isLocal:{}", e, originLocal);
 962             edgeUpdateClusterWide(e, UpdateType.REMOVED, null, originLocal);
 963         }
 964     }
 965
 966     class TopologyNotify implements Runnable {
 967         private final BlockingQueue<TopoEdgeUpdate> notifyQ;
 968         private TopoEdgeUpdate entry;
 969         private List<TopoEdgeUpdate> teuList = new ArrayList<TopoEdgeUpdate>();
 970         private boolean notifyListeners;
 971
 972         TopologyNotify(BlockingQueue<TopoEdgeUpdate> notifyQ) {
 973             this.notifyQ = notifyQ;
 974         }
 975
 976         @Override
 977         public void run() {
 978             while (true) {
 979                 try {
 980                     log.trace("New run of TopologyNotify");
 981                     notifyListeners = false;
 982                     // First we block waiting for an element to get in
 983                     entry = notifyQ.take();
 984                     // Then we drain the whole queue if elements are
 985                     // in it without getting into any blocking condition
 986                     for (; entry != null; entry = notifyQ.poll()) {
 987                         teuList.add(entry);
 988                         notifyListeners = true;
 989                     }
 990
 991                     // Notify listeners only if there were updates drained else
 992                     // give up
 993                     if (notifyListeners) {
 994                         log.trace("Notifier thread, notified a listener");
 995                         // Now update the listeners
 996                         for (ITopologyManagerClusterWideAware s : topologyManagerClusterWideAware) {
 997                             try {
 998                                 s.edgeUpdate(teuList);
 999                             } catch (Exception exc) {
1000                                 log.error("Exception on edge update:", exc);
1001                             }
1002                         }
1003                     }
1004                     teuList.clear();
1005
1006                     // Lets sleep for sometime to allow aggregation of event
1007                     Thread.sleep(100);
1008                 } catch (InterruptedException e1) {
1009                     if (shuttingDown) {
1010                         return;
1011                     }
1012                     log.warn("TopologyNotify interrupted {}", e1.getMessage());
1013                 } catch (Exception e2) {
1014                     log.error("", e2);
1015                 }
1016             }
1017         }
1018     }
1019
1020     public List<String> printUserLink() {
1021         List<String> result = new ArrayList<String>();
1022         for (String name : this.userLinksDB.keySet()) {
1023             TopologyUserLinkConfig linkConfig = userLinksDB.get(name);
1024             result.add("Name : " + name);
1025             result.add(linkConfig.toString());
1026             result.add("Edge " + getLinkTuple(linkConfig));
1027             result.add("Reverse Edge " + getReverseLinkTuple(linkConfig));
1028         }
1029         return result;
1030     }
1031
1032     public List<String> addUserLink(String name, String ncStr1, String ncStr2) {
1033         List<String> result = new ArrayList<String>();
1034         if ((name == null)) {
1035             result.add("Please enter a valid Name");
1036             return result;
1037         }
1038
1039         if (ncStr1 == null) {
1040             result.add("Please enter two node connector strings");
1041             return result;
1042         }
1043         if (ncStr2 == null) {
1044             result.add("Please enter second node connector string");
1045             return result;
1046         }
1047
1048         NodeConnector nc1 = NodeConnector.fromString(ncStr1);
1049         if (nc1 == null) {
1050             result.add("Invalid input node connector 1 string: " + ncStr1);
1051             return result;
1052         }
1053         NodeConnector nc2 = NodeConnector.fromString(ncStr2);
1054         if (nc2 == null) {
1055             result.add("Invalid input node connector 2 string: " + ncStr2);
1056             return result;
1057         }
1058
1059         TopologyUserLinkConfig config = new TopologyUserLinkConfig(name, ncStr1, ncStr2);
1060         result.add(this.addUserLink(config).toString());
1061         return result;
1062     }
1063
1064     public List<String> deleteUserLinkShell(String name) {
1065         List<String> result = new ArrayList<String>();
1066         if ((name == null)) {
1067             result.add("Please enter a valid Name");
1068             return result;
1069         }
1070         this.deleteUserLink(name);
1071         return result;
1072     }
1073
1074     public List<String> printNodeEdges() {
1075         List<String> result = new ArrayList<String>();
1076         Map<Node, Set<Edge>> nodeEdges = getNodeEdges();
1077         if (nodeEdges == null) {
1078             return result;
1079         }
1080         Set<Node> nodeSet = nodeEdges.keySet();
1081         if (nodeSet == null) {
1082             return result;
1083         }
1084         result.add("        Node                                         Edge");
1085         for (Node node : nodeSet) {
1086             Set<Edge> edgeSet = nodeEdges.get(node);
1087             if (edgeSet == null) {
1088                 continue;
1089             }
1090             for (Edge edge : edgeSet) {
1091                 result.add(node + "             " + edge);
1092             }
1093         }
1094         return result;
1095     }
1096
1097 }