opendaylight/switchmanager/implementation/src/main/java/org/opendaylight/controller/switchmanager/internal/SwitchManager.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.switchmanager.internal;
  10
  11 import java.io.FileNotFoundException;
  12 import java.io.IOException;
  13 import java.io.ObjectInputStream;
  14 import java.net.InetAddress;
  15 import java.net.NetworkInterface;
  16 import java.net.SocketException;
  17 import java.util.ArrayList;
  18 import java.util.Collections;
  19 import java.util.Dictionary;
  20 import java.util.EnumSet;
  21 import java.util.Enumeration;
  22 import java.util.HashMap;
  23 import java.util.HashSet;
  24 import java.util.List;
  25 import java.util.Map;
  26 import java.util.Set;
  27 import java.util.concurrent.ConcurrentHashMap;
  28 import java.util.concurrent.ConcurrentMap;
  29 import java.util.concurrent.CopyOnWriteArrayList;
  30
  31 import org.apache.felix.dm.Component;
  32 import org.eclipse.osgi.framework.console.CommandInterpreter;
  33 import org.eclipse.osgi.framework.console.CommandProvider;
  34 import org.opendaylight.controller.clustering.services.CacheConfigException;
  35 import org.opendaylight.controller.clustering.services.CacheExistException;
  36 import org.opendaylight.controller.clustering.services.IClusterContainerServices;
  37 import org.opendaylight.controller.clustering.services.IClusterServices;
  38 import org.opendaylight.controller.configuration.IConfigurationContainerAware;
  39 import org.opendaylight.controller.sal.core.Bandwidth;
  40 import org.opendaylight.controller.sal.core.Config;
  41 import org.opendaylight.controller.sal.core.ConstructionException;
  42 import org.opendaylight.controller.sal.core.Description;
  43 import org.opendaylight.controller.sal.core.ForwardingMode;
  44 import org.opendaylight.controller.sal.core.MacAddress;
  45 import org.opendaylight.controller.sal.core.Name;
  46 import org.opendaylight.controller.sal.core.Node;
  47 import org.opendaylight.controller.sal.core.NodeConnector;
  48 import org.opendaylight.controller.sal.core.NodeConnector.NodeConnectorIDType;
  49 import org.opendaylight.controller.sal.core.Property;
  50 import org.opendaylight.controller.sal.core.State;
  51 import org.opendaylight.controller.sal.core.Tier;
  52 import org.opendaylight.controller.sal.core.UpdateType;
  53 import org.opendaylight.controller.sal.inventory.IInventoryService;
  54 import org.opendaylight.controller.sal.inventory.IListenInventoryUpdates;
  55 import org.opendaylight.controller.sal.reader.NodeDescription;
  56 import org.opendaylight.controller.sal.utils.GlobalConstants;
  57 import org.opendaylight.controller.sal.utils.HexEncode;
  58 import org.opendaylight.controller.sal.utils.IObjectReader;
  59 import org.opendaylight.controller.sal.utils.ObjectReader;
  60 import org.opendaylight.controller.sal.utils.ObjectWriter;
  61 import org.opendaylight.controller.sal.utils.Status;
  62 import org.opendaylight.controller.sal.utils.StatusCode;
  63 import org.opendaylight.controller.statisticsmanager.IStatisticsManager;
  64 import org.opendaylight.controller.switchmanager.IInventoryListener;
  65 import org.opendaylight.controller.switchmanager.ISpanAware;
  66 import org.opendaylight.controller.switchmanager.ISwitchManager;
  67 import org.opendaylight.controller.switchmanager.ISwitchManagerAware;
  68 import org.opendaylight.controller.switchmanager.SpanConfig;
  69 import org.opendaylight.controller.switchmanager.Subnet;
  70 import org.opendaylight.controller.switchmanager.SubnetConfig;
  71 import org.opendaylight.controller.switchmanager.Switch;
  72 import org.opendaylight.controller.switchmanager.SwitchConfig;
  73 import org.osgi.framework.BundleContext;
  74 import org.osgi.framework.FrameworkUtil;
  75 import org.slf4j.Logger;
  76 import org.slf4j.LoggerFactory;
  77
  78 /**
  79  * The class describes SwitchManager which is the central repository of all the
  80  * inventory data including nodes, node connectors, properties attached, Layer3
  81  * configurations, Span configurations, node configurations, network device
  82  * representations viewed by Controller Web applications. One SwitchManager
  83  * instance per container of the network. All the node/nodeConnector properties
  84  * are maintained in the default container only.
  85  */
  86 public class SwitchManager implements ISwitchManager, IConfigurationContainerAware,
  87                                       IObjectReader, IListenInventoryUpdates, CommandProvider {
  88     private static Logger log = LoggerFactory.getLogger(SwitchManager.class);
  89     private static String ROOT = GlobalConstants.STARTUPHOME.toString();
  90     private String subnetFileName, spanFileName, switchConfigFileName;
  91     private final List<NodeConnector> spanNodeConnectors = new CopyOnWriteArrayList<NodeConnector>();
  92     // Collection of Subnets keyed by the InetAddress
  93     private ConcurrentMap<InetAddress, Subnet> subnets;
  94     private ConcurrentMap<String, SubnetConfig> subnetsConfigList;
  95     private ConcurrentMap<SpanConfig, SpanConfig> spanConfigList;
  96     // manually configured parameters for the node such as name, tier, mode
  97     private ConcurrentMap<String, SwitchConfig> nodeConfigList;
  98     private ConcurrentMap<Node, Map<String, Property>> nodeProps;
  99     private ConcurrentMap<NodeConnector, Map<String, Property>> nodeConnectorProps;
 100     private ConcurrentMap<Node, Map<String, NodeConnector>> nodeConnectorNames;
 101     private ConcurrentMap<String, Property> controllerProps;
 102     private IInventoryService inventoryService;
 103     private IStatisticsManager statisticsManager;
 104     private final Set<ISwitchManagerAware> switchManagerAware = Collections
 105             .synchronizedSet(new HashSet<ISwitchManagerAware>());
 106     private final Set<IInventoryListener> inventoryListeners = Collections
 107             .synchronizedSet(new HashSet<IInventoryListener>());
 108     private final Set<ISpanAware> spanAware = Collections.synchronizedSet(new HashSet<ISpanAware>());
 109     private IClusterContainerServices clusterContainerService = null;
 110     private String containerName = null;
 111     private boolean isDefaultContainer = true;
 112     private static final int REPLACE_RETRY = 1;
 113
 114     /* Information about the default subnet. If there have been no configured subnets, i.e.,
 115      * subnets.size() == 0 or subnetsConfigList.size() == 0, then this subnet will be the
 116      * only subnet returned. As soon as a user-configured subnet is created this one will
 117      * vanish.
 118      */
 119     protected static SubnetConfig DEFAULT_SUBNETCONFIG;
 120     protected static Subnet DEFAULT_SUBNET;
 121     protected static String DEFAULT_SUBNET_NAME = "default (cannot be modifed)";
 122     static{
 123         DEFAULT_SUBNETCONFIG = new SubnetConfig(DEFAULT_SUBNET_NAME, "0.0.0.0/0", new ArrayList<String>());
 124         DEFAULT_SUBNET = new Subnet(DEFAULT_SUBNETCONFIG);
 125     }
 126
 127     public void notifySubnetChange(Subnet sub, boolean add) {
 128         synchronized (switchManagerAware) {
 129             for (Object subAware : switchManagerAware) {
 130                 try {
 131                     ((ISwitchManagerAware) subAware).subnetNotify(sub, add);
 132                 } catch (Exception e) {
 133                     log.error("Failed to notify Subnet change {}",
 134                             e.getMessage());
 135                 }
 136             }
 137         }
 138     }
 139
 140     public void notifySpanPortChange(Node node, List<NodeConnector> ports, boolean add) {
 141         synchronized (spanAware) {
 142             for (Object sa : spanAware) {
 143                 try {
 144                     ((ISpanAware) sa).spanUpdate(node, ports, add);
 145                 } catch (Exception e) {
 146                     log.error("Failed to notify Span Interface change {}",
 147                             e.getMessage());
 148                 }
 149             }
 150         }
 151     }
 152
 153     private void notifyModeChange(Node node, boolean proactive) {
 154         synchronized (switchManagerAware) {
 155             for (ISwitchManagerAware service : switchManagerAware) {
 156                 try {
 157                     service.modeChangeNotify(node, proactive);
 158                 } catch (Exception e) {
 159                     log.error("Failed to notify Subnet change {}",
 160                             e.getMessage());
 161                 }
 162             }
 163         }
 164     }
 165
 166     public void startUp() {
 167         String container = this.getContainerName();
 168         // Initialize configuration file names
 169         subnetFileName = ROOT + "subnets_" + container + ".conf";
 170         spanFileName = ROOT + "spanPorts_" + container + ".conf";
 171         switchConfigFileName = ROOT + "switchConfig_" + container + ".conf";
 172
 173         // Instantiate cluster synced variables
 174         allocateCaches();
 175         retrieveCaches();
 176
 177         /*
 178          * Read startup and build database if we are the coordinator
 179          */
 180         if ((clusterContainerService != null) && (clusterContainerService.amICoordinator())) {
 181             loadSubnetConfiguration();
 182             loadSpanConfiguration();
 183             loadSwitchConfiguration();
 184         }
 185
 186         // Add controller MAC, if first node in the cluster
 187         if (!controllerProps.containsKey(MacAddress.name)) {
 188             byte controllerMac[] = getHardwareMAC();
 189             if (controllerMac != null) {
 190                 Property existing = controllerProps.putIfAbsent(MacAddress.name, new MacAddress(controllerMac));
 191                 if (existing == null && log.isTraceEnabled()) {
 192                     log.trace("Container {}: Setting controller MAC address in the cluster: {}", container,
 193                             HexEncode.bytesToHexStringFormat(controllerMac));
 194                 }
 195             }
 196         }
 197     }
 198
 199     public void shutDown() {
 200     }
 201
 202     private void allocateCaches() {
 203         if (this.clusterContainerService == null) {
 204             this.nonClusterObjectCreate();
 205             log.warn("un-initialized clusterContainerService, can't create cache");
 206             return;
 207         }
 208
 209         try {
 210             clusterContainerService.createCache(
 211                     "switchmanager.subnetsConfigList",
 212                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 213             clusterContainerService.createCache("switchmanager.spanConfigList",
 214                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 215             clusterContainerService.createCache("switchmanager.nodeConfigList",
 216                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 217             clusterContainerService.createCache("switchmanager.subnets",
 218                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 219             clusterContainerService.createCache("switchmanager.nodeProps",
 220                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 221             clusterContainerService.createCache(
 222                     "switchmanager.nodeConnectorProps",
 223                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 224             clusterContainerService.createCache(
 225                     "switchmanager.nodeConnectorNames",
 226                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 227             clusterContainerService.createCache(
 228                     "switchmanager.controllerProps",
 229                     EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
 230         } catch (CacheConfigException cce) {
 231             log.error("\nCache configuration invalid - check cache mode");
 232         } catch (CacheExistException ce) {
 233             log.error("\nCache already exits - destroy and recreate if needed");
 234         }
 235     }
 236
 237     @SuppressWarnings({ "unchecked" })
 238     private void retrieveCaches() {
 239         if (this.clusterContainerService == null) {
 240             log.warn("un-initialized clusterContainerService, can't create cache");
 241             return;
 242         }
 243
 244         subnetsConfigList = (ConcurrentMap<String, SubnetConfig>) clusterContainerService
 245                 .getCache("switchmanager.subnetsConfigList");
 246         if (subnetsConfigList == null) {
 247             log.error("\nFailed to get cache for subnetsConfigList");
 248         }
 249
 250         spanConfigList = (ConcurrentMap<SpanConfig, SpanConfig>) clusterContainerService
 251                 .getCache("switchmanager.spanConfigList");
 252         if (spanConfigList == null) {
 253             log.error("\nFailed to get cache for spanConfigList");
 254         }
 255
 256         nodeConfigList = (ConcurrentMap<String, SwitchConfig>) clusterContainerService
 257                 .getCache("switchmanager.nodeConfigList");
 258         if (nodeConfigList == null) {
 259             log.error("\nFailed to get cache for nodeConfigList");
 260         }
 261
 262         subnets = (ConcurrentMap<InetAddress, Subnet>) clusterContainerService
 263                 .getCache("switchmanager.subnets");
 264         if (subnets == null) {
 265             log.error("\nFailed to get cache for subnets");
 266         }
 267
 268         nodeProps = (ConcurrentMap<Node, Map<String, Property>>) clusterContainerService
 269                 .getCache("switchmanager.nodeProps");
 270         if (nodeProps == null) {
 271             log.error("\nFailed to get cache for nodeProps");
 272         }
 273
 274         nodeConnectorProps = (ConcurrentMap<NodeConnector, Map<String, Property>>) clusterContainerService
 275                 .getCache("switchmanager.nodeConnectorProps");
 276         if (nodeConnectorProps == null) {
 277             log.error("\nFailed to get cache for nodeConnectorProps");
 278         }
 279
 280         nodeConnectorNames = (ConcurrentMap<Node, Map<String, NodeConnector>>) clusterContainerService
 281                 .getCache("switchmanager.nodeConnectorNames");
 282         if (nodeConnectorNames == null) {
 283             log.error("\nFailed to get cache for nodeConnectorNames");
 284         }
 285
 286         controllerProps = (ConcurrentMap<String, Property>) clusterContainerService
 287                 .getCache("switchmanager.controllerProps");
 288         if (controllerProps == null) {
 289             log.error("\nFailed to get cache for controllerProps");
 290         }
 291     }
 292
 293     private void nonClusterObjectCreate() {
 294         subnetsConfigList = new ConcurrentHashMap<String, SubnetConfig>();
 295         spanConfigList = new ConcurrentHashMap<SpanConfig, SpanConfig>();
 296         nodeConfigList = new ConcurrentHashMap<String, SwitchConfig>();
 297         subnets = new ConcurrentHashMap<InetAddress, Subnet>();
 298         nodeProps = new ConcurrentHashMap<Node, Map<String, Property>>();
 299         nodeConnectorProps = new ConcurrentHashMap<NodeConnector, Map<String, Property>>();
 300         nodeConnectorNames = new ConcurrentHashMap<Node, Map<String, NodeConnector>>();
 301         controllerProps = new ConcurrentHashMap<String, Property>();
 302     }
 303
 304     @Override
 305     public List<SubnetConfig> getSubnetsConfigList() {
 306         // if there are no subnets, return the default subnet
 307         if(subnetsConfigList.size() == 0){
 308             return Collections.singletonList(DEFAULT_SUBNETCONFIG);
 309         }else{
 310             return new ArrayList<SubnetConfig>(subnetsConfigList.values());
 311         }
 312     }
 313
 314     @Override
 315     public SubnetConfig getSubnetConfig(String subnet) {
 316         // if there are no subnets, return the default subnet
 317         if(subnetsConfigList.isEmpty() && subnet.equalsIgnoreCase(DEFAULT_SUBNET_NAME)){
 318             return DEFAULT_SUBNETCONFIG;
 319         }else{
 320             return subnetsConfigList.get(subnet);
 321         }
 322     }
 323
 324     private List<SpanConfig> getSpanConfigList(Node node) {
 325         List<SpanConfig> confList = new ArrayList<SpanConfig>();
 326         String nodeId = node.toString();
 327         for (SpanConfig conf : spanConfigList.values()) {
 328             if (conf.matchNode(nodeId)) {
 329                 confList.add(conf);
 330             }
 331         }
 332         return confList;
 333     }
 334
 335     public List<SwitchConfig> getNodeConfigList() {
 336         return new ArrayList<SwitchConfig>(nodeConfigList.values());
 337     }
 338
 339     @Override
 340     public SwitchConfig getSwitchConfig(String switchId) {
 341         return nodeConfigList.get(switchId);
 342     }
 343
 344     public Switch getSwitchByNode(Node node) {
 345         Switch sw = new Switch(node);
 346         sw.setNode(node);
 347         MacAddress mac = (MacAddress) this.getNodeProp(node,
 348                 MacAddress.name);
 349         if (mac != null) {
 350             sw.setDataLayerAddress(mac.getMacAddress());
 351         }
 352         Set<NodeConnector> ncSet = getPhysicalNodeConnectors(node);
 353         sw.setNodeConnectors(ncSet);
 354
 355         List<NodeConnector> ncList = new ArrayList<NodeConnector>();
 356         for (NodeConnector nodeConnector : ncSet) {
 357             if (spanNodeConnectors.contains(nodeConnector)) {
 358                 ncList.add(nodeConnector);
 359             }
 360         }
 361         sw.addSpanPorts(ncList);
 362
 363         return sw;
 364     }
 365
 366     @Override
 367     public List<Switch> getNetworkDevices() {
 368         Set<Node> nodeSet = getNodes();
 369         List<Switch> swList = new ArrayList<Switch>();
 370         if (nodeSet != null) {
 371             for (Node node : nodeSet) {
 372                 swList.add(getSwitchByNode(node));
 373             }
 374         }
 375
 376         return swList;
 377     }
 378
 379     private Status updateConfig(SubnetConfig conf, boolean add) {
 380         if (add) {
 381             if(subnetsConfigList.putIfAbsent(conf.getName(), conf) != null) {
 382                 String msg = "Cluster conflict: Subnet with name " + conf.getName() + "already exists.";
 383                 return new Status(StatusCode.CONFLICT, msg);
 384             }
 385         } else {
 386             subnetsConfigList.remove(conf.getName());
 387         }
 388         return new Status(StatusCode.SUCCESS);
 389     }
 390
 391     private Status updateDatabase(SubnetConfig conf, boolean add) {
 392         if (add) {
 393             Subnet subnetCurr = subnets.get(conf.getIPAddress());
 394             Subnet subnet;
 395             if (subnetCurr == null) {
 396                 subnet = new Subnet(conf);
 397             } else {
 398                 subnet = subnetCurr.clone();
 399             }
 400             // In case of API3 call we may receive the ports along with the
 401             // subnet creation
 402             if (!conf.isGlobal()) {
 403                 subnet.addNodeConnectors(conf.getNodeConnectors());
 404             }
 405             boolean putNewSubnet = false;
 406             if(subnetCurr == null) {
 407                 if(subnets.putIfAbsent(conf.getIPAddress(), subnet) == null) {
 408                     putNewSubnet = true;
 409                 }
 410             } else {
 411                 putNewSubnet = subnets.replace(conf.getIPAddress(), subnetCurr, subnet);
 412             }
 413             if(!putNewSubnet) {
 414                 String msg = "Cluster conflict: Conflict while adding the subnet " + conf.getIPAddress();
 415                 return new Status(StatusCode.CONFLICT, msg);
 416             }
 417
 418         // Subnet removal case
 419         } else {
 420             subnets.remove(conf.getIPAddress());
 421         }
 422         return new Status(StatusCode.SUCCESS);
 423     }
 424
 425     private Status semanticCheck(SubnetConfig conf) {
 426         Set<InetAddress> IPs = subnets.keySet();
 427         if (IPs == null) {
 428             return new Status(StatusCode.SUCCESS);
 429         }
 430         Subnet newSubnet = new Subnet(conf);
 431         for (InetAddress i : IPs) {
 432             Subnet existingSubnet = subnets.get(i);
 433             if ((existingSubnet != null) && !existingSubnet.isMutualExclusive(newSubnet)) {
 434                 return new Status(StatusCode.CONFLICT, "This subnet conflicts with an existing one.");
 435             }
 436         }
 437         return new Status(StatusCode.SUCCESS);
 438     }
 439
 440     private Status addRemoveSubnet(SubnetConfig conf, boolean isAdding) {
 441         // Valid configuration check
 442         Status status = conf.validate();
 443         if (!status.isSuccess()) {
 444             log.warn(status.getDescription());
 445             return status;
 446         }
 447
 448         if (isAdding) {
 449             // Presence check
 450             if (subnetsConfigList.containsKey(conf.getName())) {
 451                 return new Status(StatusCode.CONFLICT,
 452                         "Subnet with the specified name already exists.");
 453             }
 454             // Semantic check
 455             status = semanticCheck(conf);
 456             if (!status.isSuccess()) {
 457                 return status;
 458             }
 459         } else {
 460             if (conf.getName().equalsIgnoreCase(DEFAULT_SUBNET_NAME)) {
 461                 return new Status(StatusCode.NOTALLOWED, "The specified subnet gateway cannot be removed");
 462             }
 463         }
 464
 465         // Update Database
 466         status = updateDatabase(conf, isAdding);
 467
 468         if (status.isSuccess()) {
 469             // Update Configuration
 470             status = updateConfig(conf, isAdding);
 471             if(!status.isSuccess()) {
 472                 updateDatabase(conf, (!isAdding));
 473             } else {
 474                 // update the listeners
 475                 Subnet subnetCurr = subnets.get(conf.getIPAddress());
 476                 Subnet subnet;
 477                 if (subnetCurr == null) {
 478                     subnet = new Subnet(conf);
 479                 } else {
 480                     subnet = subnetCurr.clone();
 481                 }
 482                 notifySubnetChange(subnet, isAdding);
 483             }
 484         }
 485
 486         return status;
 487     }
 488
 489     /**
 490      * Adds Subnet configured in GUI or API3
 491      */
 492     @Override
 493     public Status addSubnet(SubnetConfig conf) {
 494         return this.addRemoveSubnet(conf, true);
 495     }
 496
 497     @Override
 498     public Status removeSubnet(SubnetConfig conf) {
 499         return this.addRemoveSubnet(conf, false);
 500     }
 501
 502     @Override
 503     public Status removeSubnet(String name) {
 504         if (name.equalsIgnoreCase(DEFAULT_SUBNET_NAME)) {
 505             return new Status(StatusCode.NOTALLOWED, "The specified subnet gateway cannot be removed");
 506         }
 507         SubnetConfig conf = subnetsConfigList.get(name);
 508         if (conf == null) {
 509             return new Status(StatusCode.SUCCESS, "Subnet not present");
 510         }
 511         return this.addRemoveSubnet(conf, false);
 512     }
 513
 514     @Override
 515     public Status modifySubnet(SubnetConfig conf) {
 516         // Sanity check
 517         if (conf == null) {
 518             return new Status(StatusCode.BADREQUEST, "Invalid Subnet configuration: null");
 519         }
 520
 521         // Valid configuration check
 522         Status status = conf.validate();
 523         if (!status.isSuccess()) {
 524             log.warn(status.getDescription());
 525             return status;
 526         }
 527
 528         // If a subnet configuration with this name does not exist, consider this is a creation
 529         SubnetConfig target = subnetsConfigList.get(conf.getName());
 530         if (target == null) {
 531             return this.addSubnet(conf);
 532         }
 533
 534         // No change
 535         if (target.equals(conf)) {
 536             return new Status(StatusCode.SUCCESS);
 537         }
 538
 539         // Check not allowed modifications
 540         if (!target.getSubnet().equals(conf.getSubnet())) {
 541             return new Status(StatusCode.BADREQUEST, "IP address change is not allowed");
 542         }
 543
 544         // Derive the set of node connectors that are being removed
 545         Set<NodeConnector> toRemove = target.getNodeConnectors();
 546         toRemove.removeAll(conf.getNodeConnectors());
 547         List<String> nodeConnectorStrings = null;
 548         if (!toRemove.isEmpty()) {
 549             nodeConnectorStrings = new ArrayList<String>();
 550             for (NodeConnector nc : toRemove) {
 551                 nodeConnectorStrings.add(nc.toString());
 552             }
 553             status = this.removePortsFromSubnet(conf.getName(), nodeConnectorStrings);
 554             if (!status.isSuccess()) {
 555                 return status;
 556             }
 557         }
 558
 559         // Derive the set of node connectors that are being added
 560         Set<NodeConnector> toAdd = conf.getNodeConnectors();
 561         toAdd.removeAll(target.getNodeConnectors());
 562         if (!toAdd.isEmpty()) {
 563             List<String> nodeConnectorStringRemoved = nodeConnectorStrings;
 564             nodeConnectorStrings = new ArrayList<String>();
 565             for (NodeConnector nc : toAdd) {
 566                 nodeConnectorStrings.add(nc.toString());
 567             }
 568             status = this.addPortsToSubnet(conf.getName(), nodeConnectorStrings);
 569             if (!status.isSuccess()) {
 570                 // If any port was removed, add it back as a best recovery effort
 571                 if (!toRemove.isEmpty()) {
 572                     this.addPortsToSubnet(conf.getName(), nodeConnectorStringRemoved);
 573                 }
 574                 return status;
 575             }
 576         }
 577
 578         // Update Configuration
 579         subnetsConfigList.put(conf.getName(), conf);
 580
 581         return new Status(StatusCode.SUCCESS);
 582     }
 583
 584     @Override
 585     public Status addPortsToSubnet(String name, List<String> switchPorts) {
 586         if (name == null) {
 587             return new Status(StatusCode.BADREQUEST, "Null subnet name");
 588         }
 589         SubnetConfig confCurr = subnetsConfigList.get(name);
 590         if (confCurr == null) {
 591             return new Status(StatusCode.NOTFOUND, "Subnet does not exist");
 592         }
 593
 594         if (switchPorts == null || switchPorts.isEmpty()) {
 595             return new Status(StatusCode.BADREQUEST, "Null or empty port set");
 596         }
 597
 598         Subnet subCurr = subnets.get(confCurr.getIPAddress());
 599         if (subCurr == null) {
 600             log.debug("Cluster conflict: Subnet entry {} is not present in the subnets cache.", confCurr.getIPAddress());
 601             return new Status(StatusCode.NOTFOUND, "Subnet does not exist");
 602         }
 603
 604         // Update Database
 605         Subnet sub = subCurr.clone();
 606         Set<NodeConnector> sp = NodeConnector.fromString(switchPorts);
 607         sub.addNodeConnectors(sp);
 608         boolean subnetsReplaced = subnets.replace(confCurr.getIPAddress(), subCurr, sub);
 609         if (!subnetsReplaced) {
 610             String msg = "Cluster conflict: Conflict while adding ports to the subnet " + name;
 611             return new Status(StatusCode.CONFLICT, msg);
 612         }
 613
 614         // Update Configuration
 615         SubnetConfig conf = confCurr.clone();
 616         conf.addNodeConnectors(switchPorts);
 617         boolean configReplaced = subnetsConfigList.replace(name, confCurr, conf);
 618         if (!configReplaced) {
 619             // TODO: recovery using Transactionality
 620             String msg = "Cluster conflict: Conflict while adding ports to the subnet " + name;
 621             return new Status(StatusCode.CONFLICT, msg);
 622         }
 623
 624         return new Status(StatusCode.SUCCESS);
 625     }
 626
 627     @Override
 628     public Status removePortsFromSubnet(String name, List<String> switchPorts) {
 629         if (name == null) {
 630             return new Status(StatusCode.BADREQUEST, "Null subnet name");
 631         }
 632         SubnetConfig confCurr = subnetsConfigList.get(name);
 633         if (confCurr == null) {
 634             return new Status(StatusCode.NOTFOUND, "Subnet does not exist");
 635         }
 636
 637         if (switchPorts == null || switchPorts.isEmpty()) {
 638             return new Status(StatusCode.BADREQUEST, "Null or empty port set");
 639         }
 640
 641         Subnet subCurr = subnets.get(confCurr.getIPAddress());
 642         if (subCurr == null) {
 643             log.debug("Cluster conflict: Subnet entry {} is not present in the subnets cache.", confCurr.getIPAddress());
 644             return new Status(StatusCode.NOTFOUND, "Subnet does not exist");
 645         }
 646
 647         // Validation check
 648         Status status = SubnetConfig.validatePorts(switchPorts);
 649         if (!status.isSuccess()) {
 650             return status;
 651         }
 652         // Update Database
 653         Subnet sub = subCurr.clone();
 654         Set<NodeConnector> sp = NodeConnector.fromString(switchPorts);
 655         sub.deleteNodeConnectors(sp);
 656         boolean subnetsReplace = subnets.replace(confCurr.getIPAddress(), subCurr, sub);
 657         if (!subnetsReplace) {
 658             String msg = "Cluster conflict: Conflict while removing ports from the subnet " + name;
 659             return new Status(StatusCode.CONFLICT, msg);
 660         }
 661
 662         // Update Configuration
 663         SubnetConfig conf = confCurr.clone();
 664         conf.removeNodeConnectors(switchPorts);
 665         boolean result = subnetsConfigList.replace(name, confCurr, conf);
 666         if (!result) {
 667             // TODO: recovery using Transactionality
 668             String msg = "Cluster conflict: Conflict while removing ports from " + conf;
 669             return new Status(StatusCode.CONFLICT, msg);
 670         }
 671
 672         return new Status(StatusCode.SUCCESS);
 673     }
 674
 675     public String getContainerName() {
 676         if (containerName == null) {
 677             return GlobalConstants.DEFAULT.toString();
 678         }
 679         return containerName;
 680     }
 681
 682     @Override
 683     public Subnet getSubnetByNetworkAddress(InetAddress networkAddress) {
 684         // if there are no subnets, return the default subnet
 685         if (subnets.size() == 0) {
 686             return DEFAULT_SUBNET;
 687         }
 688
 689         for(Map.Entry<InetAddress,Subnet> subnetEntry : subnets.entrySet()) {
 690             if(subnetEntry.getValue().isSubnetOf(networkAddress)) {
 691                 return subnetEntry.getValue();
 692             }
 693         }
 694         return null;
 695     }
 696
 697     @Override
 698     public Object readObject(ObjectInputStream ois)
 699             throws FileNotFoundException, IOException, ClassNotFoundException {
 700         // Perform the class deserialization locally, from inside the package
 701         // where the class is defined
 702         return ois.readObject();
 703     }
 704
 705     @SuppressWarnings("unchecked")
 706     private void loadSubnetConfiguration() {
 707         ObjectReader objReader = new ObjectReader();
 708         ConcurrentMap<String, SubnetConfig> confList = (ConcurrentMap<String, SubnetConfig>) objReader
 709                 .read(this, subnetFileName);
 710
 711         if (confList == null) {
 712             return;
 713         }
 714
 715         for (SubnetConfig conf : confList.values()) {
 716             addSubnet(conf);
 717         }
 718     }
 719
 720     @SuppressWarnings("unchecked")
 721     private void loadSpanConfiguration() {
 722         ObjectReader objReader = new ObjectReader();
 723         ConcurrentMap<Integer, SpanConfig> confList = (ConcurrentMap<Integer, SpanConfig>) objReader
 724                 .read(this, spanFileName);
 725
 726         if (confList == null) {
 727             return;
 728         }
 729
 730         for (SpanConfig conf : confList.values()) {
 731             addSpanConfig(conf);
 732         }
 733     }
 734
 735     @SuppressWarnings("unchecked")
 736     private void loadSwitchConfiguration() {
 737         ObjectReader objReader = new ObjectReader();
 738         ConcurrentMap<String, SwitchConfig> confList = (ConcurrentMap<String, SwitchConfig>) objReader
 739                 .read(this, switchConfigFileName);
 740
 741         if (confList == null) {
 742             return;
 743         }
 744
 745         for (SwitchConfig conf : confList.values()) {
 746             updateNodeConfig(conf);
 747         }
 748     }
 749
 750     @SuppressWarnings("deprecation")
 751     @Override
 752     public void updateSwitchConfig(SwitchConfig cfgObject) {
 753         // update default container only
 754         if (!isDefaultContainer) {
 755             return;
 756         }
 757
 758         SwitchConfig sc = nodeConfigList.get(cfgObject.getNodeId());
 759         if (sc == null) {
 760             if (nodeConfigList.putIfAbsent(cfgObject.getNodeId(), cfgObject) != null) {
 761                 return;
 762             }
 763         } else {
 764             if (!nodeConfigList.replace(cfgObject.getNodeId(), sc, cfgObject)) {
 765                 return;
 766             }
 767         }
 768
 769         boolean modeChange = false;
 770
 771         if ((sc == null) || !cfgObject.getMode().equals(sc.getMode())) {
 772             modeChange = true;
 773         }
 774
 775         String nodeId = cfgObject.getNodeId();
 776         Node node = Node.fromString(nodeId);
 777         Map<String, Property> propMapCurr = nodeProps.get(node);
 778         if (propMapCurr == null) {
 779             return;
 780         }
 781         Map<String, Property> propMap = new HashMap<String, Property>(propMapCurr);
 782         Property desc = new Description(cfgObject.getNodeDescription());
 783         propMap.put(desc.getName(), desc);
 784         Property tier = new Tier(Integer.parseInt(cfgObject.getTier()));
 785         propMap.put(tier.getName(), tier);
 786
 787         if (!nodeProps.replace(node, propMapCurr, propMap)) {
 788             // TODO rollback using Transactionality
 789             return;
 790         }
 791
 792         log.trace("Set Node {}'s Mode to {}", nodeId, cfgObject.getMode());
 793
 794         if (modeChange) {
 795             notifyModeChange(node, cfgObject.isProactive());
 796         }
 797     }
 798
 799     @Override
 800     public Status updateNodeConfig(SwitchConfig switchConfig) {
 801         Status status = switchConfig.validate();
 802         if (!status.isSuccess()) {
 803             return status;
 804         }
 805
 806         Map<String, Property> updateProperties = switchConfig.getNodeProperties();
 807         ForwardingMode mode = (ForwardingMode) updateProperties.get(ForwardingMode.name);
 808         if (mode != null) {
 809             if (isDefaultContainer) {
 810                 if (!mode.isValid()) {
 811                     return new Status(StatusCode.BADREQUEST, "Invalid Forwarding Mode Value");
 812                 }
 813             } else {
 814                 return new Status(StatusCode.NOTACCEPTABLE,
 815                         "Forwarding Mode modification is allowed only in default container");
 816             }
 817         }
 818
 819         Description description = (Description) switchConfig.getProperty(Description.propertyName);
 820         String nodeId = switchConfig.getNodeId();
 821         Node node = Node.fromString(nodeId);
 822         NodeDescription nodeDesc = (this.statisticsManager == null) ? null : this.statisticsManager
 823                 .getNodeDescription(node);
 824         String advertisedDesc = (nodeDesc == null) ? "" : nodeDesc.getDescription();
 825         if (description != null && description.getValue() != null) {
 826             if (description.getValue().isEmpty() || description.getValue().equals(advertisedDesc)) {
 827                 updateProperties.remove(Description.propertyName);
 828                 switchConfig = new SwitchConfig(nodeId, updateProperties);
 829             } else {
 830                 // check if description is configured or was published by any other node
 831                 for (Map.Entry<Node, Map<String, Property>> entry : nodeProps.entrySet()) {
 832                     Node n = entry.getKey();
 833                     Description desc = (Description) getNodeProp(n, Description.propertyName);
 834                     NodeDescription nDesc = (this.statisticsManager == null) ? null : this.statisticsManager
 835                             .getNodeDescription(n);
 836                     String advDesc = (nDesc == null) ? "" : nDesc.getDescription();
 837                     if ((description.equals(desc) || description.getValue().equals(advDesc)) && !node.equals(n)) {
 838                         return new Status(StatusCode.CONFLICT, "Node name already in use");
 839                     }
 840                 }
 841             }
 842         }
 843
 844         boolean modeChange = false;
 845         SwitchConfig sc = nodeConfigList.get(nodeId);
 846         Map<String, Property> prevNodeProperties = new HashMap<String, Property>();
 847         if (sc == null) {
 848             if ((mode != null) && mode.isProactive()) {
 849                 modeChange = true;
 850             }
 851             if (!updateProperties.isEmpty()) {
 852                 if (nodeConfigList.putIfAbsent(nodeId, switchConfig) != null) {
 853                     return new Status(StatusCode.CONFLICT, "Cluster conflict: Unable to update node configuration");
 854                 }
 855             }
 856         } else {
 857             prevNodeProperties = new HashMap<String, Property>(sc.getNodeProperties());
 858             ForwardingMode prevMode = (ForwardingMode) sc.getProperty(ForwardingMode.name);
 859             if (mode == null) {
 860                 if ((prevMode != null) && (prevMode.isProactive())) {
 861                     modeChange = true;
 862                 }
 863             } else {
 864                 if (((prevMode != null) && (prevMode.getValue() != mode.getValue()))
 865                         || (prevMode == null && mode.isProactive())) {
 866                     modeChange = true;
 867                 }
 868             }
 869             if (updateProperties.isEmpty()) {
 870                 nodeConfigList.remove(nodeId);
 871             } else {
 872                 if (!nodeConfigList.replace(nodeId, sc, switchConfig)) {
 873                     return new Status(StatusCode.CONFLICT, "Cluster conflict: Unable to update node configuration");
 874                 }
 875             }
 876         }
 877         Map<String, Property> propMapCurr = nodeProps.get(node);
 878         if (propMapCurr == null) {
 879             return new Status(StatusCode.SUCCESS);
 880         }
 881         Map<String, Property> propMap = new HashMap<String, Property>(propMapCurr);
 882         for (Map.Entry<String, Property> entry : prevNodeProperties.entrySet()) {
 883             String prop = entry.getKey();
 884             if (!updateProperties.containsKey(prop)) {
 885                 if (prop.equals(Description.propertyName)) {
 886                     if (!advertisedDesc.isEmpty()) {
 887                         Property desc = new Description(advertisedDesc);
 888                         propMap.put(Description.propertyName, desc);
 889                     }
 890                     continue;
 891                 } else if (prop.equals(ForwardingMode.name)) {
 892                     Property defaultMode = new ForwardingMode(ForwardingMode.REACTIVE_FORWARDING);
 893                     propMap.put(ForwardingMode.name, defaultMode);
 894                     continue;
 895                 }
 896                 propMap.remove(prop);
 897             }
 898         }
 899         propMap.putAll(updateProperties);
 900         if (!nodeProps.replace(node, propMapCurr, propMap)) {
 901             // TODO rollback using Transactionality
 902             return new Status(StatusCode.CONFLICT, "Cluster conflict: Unable to update node configuration");
 903         }
 904         if (modeChange) {
 905             notifyModeChange(node, (mode == null) ? false : mode.isProactive());
 906         }
 907         return new Status(StatusCode.SUCCESS);
 908     }
 909
 910     @Override
 911     public Status removeNodeConfig(String nodeId) {
 912         if ((nodeId == null) || (nodeId.isEmpty())) {
 913             return new Status(StatusCode.BADREQUEST, "nodeId cannot be empty.");
 914         }
 915         Map<String, Property> nodeProperties = getSwitchConfig(nodeId).getNodeProperties();
 916         Node node = Node.fromString(nodeId);
 917         Map<String, Property> propMapCurr = nodeProps.get(node);
 918         if ((propMapCurr != null) && (nodeProperties != null) && (!nodeProperties.isEmpty())) {
 919             Map<String, Property> propMap = new HashMap<String, Property>(propMapCurr);
 920             for (Map.Entry<String, Property> entry : nodeProperties.entrySet()) {
 921                 String prop = entry.getKey();
 922                 if (prop.equals(Description.propertyName)) {
 923                     Map<Node, Map<String, Property>> nodeProp = this.inventoryService.getNodeProps();
 924                     if (nodeProp.get(node) != null) {
 925                         propMap.put(Description.propertyName, nodeProp.get(node).get(Description.propertyName));
 926                         continue;
 927                     }
 928                 }
 929                 propMap.remove(prop);
 930             }
 931             if (!nodeProps.replace(node, propMapCurr, propMap)) {
 932                 return new Status(StatusCode.CONFLICT, "Cluster conflict: Unable to update node configuration.");
 933             }
 934         }
 935         if (nodeConfigList != null) {
 936             nodeConfigList.remove(nodeId);
 937         }
 938         return new Status(StatusCode.SUCCESS);
 939     }
 940
 941     @Override
 942     public Status saveSwitchConfig() {
 943         return saveSwitchConfigInternal();
 944     }
 945
 946     public Status saveSwitchConfigInternal() {
 947         Status retS = null, retP = null;
 948         ObjectWriter objWriter = new ObjectWriter();
 949
 950         retS = objWriter.write(new ConcurrentHashMap<String, SubnetConfig>(
 951                 subnetsConfigList), subnetFileName);
 952         retP = objWriter.write(new ConcurrentHashMap<SpanConfig, SpanConfig>(
 953                 spanConfigList), spanFileName);
 954         retS = objWriter.write(new ConcurrentHashMap<String, SwitchConfig>(
 955                 nodeConfigList), switchConfigFileName);
 956         if (retS.equals(retP)) {
 957             if (retS.isSuccess()) {
 958                 return retS;
 959             } else {
 960                 return new Status(StatusCode.INTERNALERROR, "Save failed");
 961             }
 962         } else {
 963             return new Status(StatusCode.INTERNALERROR, "Partial save failure");
 964         }
 965     }
 966
 967     @Override
 968     public List<SpanConfig> getSpanConfigList() {
 969         return new ArrayList<SpanConfig>(spanConfigList.values());
 970     }
 971
 972     @Override
 973     public Status addSpanConfig(SpanConfig conf) {
 974         // Valid config check
 975         if (!conf.isValidConfig()) {
 976             String msg = "Invalid Span configuration";
 977             log.warn(msg);
 978             return new Status(StatusCode.BADREQUEST, msg);
 979         }
 980
 981         // Presence check
 982         if (spanConfigList.containsKey(conf)) {
 983             return new Status(StatusCode.CONFLICT, "Same span config exists");
 984         }
 985
 986         // Update configuration
 987         if (spanConfigList.putIfAbsent(conf, conf) == null) {
 988             // Update database and notify clients
 989             addSpanPorts(conf.getNode(), conf.getPortArrayList());
 990         }
 991
 992         return new Status(StatusCode.SUCCESS);
 993     }
 994
 995     @Override
 996     public Status removeSpanConfig(SpanConfig conf) {
 997         removeSpanPorts(conf.getNode(), conf.getPortArrayList());
 998
 999         // Update configuration
1000         spanConfigList.remove(conf);
1001
1002         return new Status(StatusCode.SUCCESS);
1003     }
1004
1005     @Override
1006     public List<NodeConnector> getSpanPorts(Node node) {
1007         List<NodeConnector> ncList = new ArrayList<NodeConnector>();
1008
1009         for (NodeConnector nodeConnector : spanNodeConnectors) {
1010             if (nodeConnector.getNode().equals(node)) {
1011                 ncList.add(nodeConnector);
1012             }
1013         }
1014         return ncList;
1015     }
1016
1017     private void addNode(Node node, Set<Property> props) {
1018         log.trace("{} added, props: {}", node, props);
1019         if (nodeProps == null) {
1020             return;
1021         }
1022
1023         Map<String, Property> propMapCurr = nodeProps.get(node);
1024         Map<String, Property> propMap = (propMapCurr == null) ? new HashMap<String, Property>()
1025                 : new HashMap<String, Property>(propMapCurr);
1026
1027         // copy node properties from plugin
1028         if (props != null) {
1029             for (Property prop : props) {
1030                 propMap.put(prop.getName(), prop);
1031             }
1032         }
1033
1034         boolean proactiveForwarding = false;
1035         // copy node properties from config
1036         if (nodeConfigList != null) {
1037             String nodeId = node.toString();
1038             SwitchConfig conf = nodeConfigList.get(nodeId);
1039             if (conf != null && (conf.getNodeProperties() != null)) {
1040                 Map<String, Property> nodeProperties = conf.getNodeProperties();
1041                 propMap.putAll(nodeProperties);
1042                 if (nodeProperties.get(ForwardingMode.name) != null) {
1043                     ForwardingMode mode = (ForwardingMode) nodeProperties.get(ForwardingMode.name);
1044                     proactiveForwarding = mode.isProactive();
1045                 }
1046             }
1047         }
1048
1049         if (!propMap.containsKey(ForwardingMode.name)) {
1050             Property defaultMode = new ForwardingMode(ForwardingMode.REACTIVE_FORWARDING);
1051             propMap.put(ForwardingMode.name, defaultMode);
1052         }
1053         boolean result = false;
1054         if (propMapCurr == null) {
1055             if (nodeProps.putIfAbsent(node, propMap) == null) {
1056                 result = true;
1057             }
1058         } else {
1059             result = nodeProps.replace(node, propMapCurr, propMap);
1060         }
1061         if (!result) {
1062             log.debug("Cluster conflict: Conflict while adding the node properties. Node: {}  Properties: {}",
1063                     node.getID(), props);
1064             addNodeProps(node, propMap);
1065         }
1066
1067         // check if span ports are configed
1068         addSpanPorts(node);
1069
1070         // notify node listeners
1071         notifyNode(node, UpdateType.ADDED, propMap);
1072
1073         // notify proactive mode forwarding
1074         if (proactiveForwarding) {
1075             notifyModeChange(node, true);
1076         }
1077     }
1078
1079     private void removeNode(Node node) {
1080         log.trace("{} removed", node);
1081         if (nodeProps == null) {
1082             return;
1083         }
1084         nodeProps.remove(node);
1085         nodeConnectorNames.remove(node);
1086         Set<NodeConnector> removeNodeConnectorSet = new HashSet<NodeConnector>();
1087         for (Map.Entry<NodeConnector, Map<String, Property>> entry : nodeConnectorProps.entrySet()) {
1088             NodeConnector nodeConnector = entry.getKey();
1089             if (nodeConnector.getNode().equals(node)) {
1090                 removeNodeConnectorSet.add(nodeConnector);
1091             }
1092         }
1093         for (NodeConnector nc : removeNodeConnectorSet) {
1094             nodeConnectorProps.remove(nc);
1095         }
1096
1097         // check if span ports need to be cleaned up
1098         removeSpanPorts(node);
1099
1100         /* notify node listeners */
1101         notifyNode(node, UpdateType.REMOVED, null);
1102     }
1103
1104     private void updateNode(Node node, Set<Property> props) {
1105         log.trace("{} updated, props: {}", node, props);
1106         if (nodeProps == null || props == null) {
1107             return;
1108         }
1109
1110         Map<String, Property> propMapCurr = nodeProps.get(node);
1111         Map<String, Property> propMap = (propMapCurr == null) ? new HashMap<String, Property>()
1112                 : new HashMap<String, Property>(propMapCurr);
1113
1114         // copy node properties from plugin
1115         String nodeId = node.toString();
1116         for (Property prop : props) {
1117             if (nodeConfigList != null) {
1118                 SwitchConfig conf = nodeConfigList.get(nodeId);
1119                 if (conf != null && (conf.getNodeProperties() != null)
1120                         && conf.getNodeProperties().containsKey(prop.getName())) {
1121                     continue;
1122                 }
1123             }
1124             propMap.put(prop.getName(), prop);
1125         }
1126
1127         if (propMapCurr == null) {
1128             if (nodeProps.putIfAbsent(node, propMap) != null) {
1129                 log.debug("Cluster conflict: Conflict while updating the node. Node: {}  Properties: {}",
1130                         node.getID(), props);
1131                 addNodeProps(node, propMap);
1132             }
1133         } else {
1134             if (!nodeProps.replace(node, propMapCurr, propMap)) {
1135                 log.debug("Cluster conflict: Conflict while updating the node. Node: {}  Properties: {}",
1136                         node.getID(), props);
1137                 addNodeProps(node, propMap);
1138             }
1139         }
1140
1141         /* notify node listeners */
1142         notifyNode(node, UpdateType.CHANGED, propMap);
1143     }
1144
1145     @Override
1146     public void updateNode(Node node, UpdateType type, Set<Property> props) {
1147         log.debug("updateNode: {} type {} props {} for container {}",
1148                 new Object[] { node, type, props, containerName });
1149         switch (type) {
1150         case ADDED:
1151             addNode(node, props);
1152             break;
1153         case CHANGED:
1154             updateNode(node, props);
1155             break;
1156         case REMOVED:
1157             removeNode(node);
1158             break;
1159         default:
1160             break;
1161         }
1162     }
1163
1164     @Override
1165     public void updateNodeConnector(NodeConnector nodeConnector,
1166             UpdateType type, Set<Property> props) {
1167         Map<String, Property> propMap = new HashMap<String, Property>();
1168         boolean update = true;
1169
1170         log.debug("updateNodeConnector: {} type {} props {} for container {}",
1171                 new Object[] { nodeConnector, type, props, containerName });
1172
1173         if (nodeConnectorProps == null) {
1174             return;
1175         }
1176
1177         switch (type) {
1178         case ADDED:
1179             if (props != null) {
1180                 for (Property prop : props) {
1181                     addNodeConnectorProp(nodeConnector, prop);
1182                     propMap.put(prop.getName(), prop);
1183                 }
1184             } else {
1185                 addNodeConnectorProp(nodeConnector, null);
1186             }
1187
1188             addSpanPort(nodeConnector);
1189             break;
1190         case CHANGED:
1191             if (!nodeConnectorProps.containsKey(nodeConnector) || (props == null)) {
1192                 update = false;
1193             } else {
1194                 for (Property prop : props) {
1195                     addNodeConnectorProp(nodeConnector, prop);
1196                     propMap.put(prop.getName(), prop);
1197                 }
1198             }
1199             break;
1200         case REMOVED:
1201             if (!nodeConnectorProps.containsKey(nodeConnector)) {
1202                 update = false;
1203             }
1204             removeNodeConnectorAllProps(nodeConnector);
1205
1206             // clean up span config
1207             removeSpanPort(nodeConnector);
1208             break;
1209         default:
1210             update = false;
1211             break;
1212         }
1213
1214         if (update) {
1215             notifyNodeConnector(nodeConnector, type, propMap);
1216         }
1217     }
1218
1219     @Override
1220     public Set<Node> getNodes() {
1221         return (nodeProps != null) ? new HashSet<Node>(nodeProps.keySet()) : new HashSet<Node>();
1222     }
1223
1224     @Override
1225     public Map<String, Property> getControllerProperties() {
1226         return new HashMap<String, Property>(this.controllerProps);
1227     }
1228
1229     @Override
1230     public Property getControllerProperty(String propertyName) {
1231         if (propertyName != null) {
1232             HashMap<String, Property> propertyMap =  new HashMap<String, Property>(this.controllerProps);
1233             return propertyMap.get(propertyName);
1234         }
1235         return null;
1236     }
1237
1238     @Override
1239     public Status setControllerProperty(Property property) {
1240         if (property != null) {
1241             this.controllerProps.put(property.getName(), property);
1242             return new Status(StatusCode.SUCCESS);
1243         }
1244         return new Status(StatusCode.BADREQUEST, "Invalid property provided when setting property");
1245     }
1246
1247     @Override
1248     public Status removeControllerProperty(String propertyName) {
1249         if (propertyName != null) {
1250             if (this.controllerProps.containsKey(propertyName)) {
1251                 this.controllerProps.remove(propertyName);
1252                 if (!this.controllerProps.containsKey(propertyName)) {
1253                     return new Status(StatusCode.SUCCESS);
1254                 }
1255             }
1256             String msg = "Unable to remove property " + propertyName + " from Controller";
1257             return new Status(StatusCode.BADREQUEST, msg);
1258         }
1259         String msg = "Invalid property provided when removing property from Controller";
1260         return new Status(StatusCode.BADREQUEST, msg);
1261     }
1262
1263     /*
1264      * Returns a copy of a list of properties for a given node
1265      *
1266      * (non-Javadoc)
1267      *
1268      * @see
1269      * org.opendaylight.controller.switchmanager.ISwitchManager#getNodeProps
1270      * (org.opendaylight.controller.sal.core.Node)
1271      */
1272     @Override
1273     public Map<String, Property> getNodeProps(Node node) {
1274         Map<String, Property> rv = new HashMap<String, Property>();
1275         if (this.nodeProps != null) {
1276             rv = this.nodeProps.get(node);
1277             if (rv != null) {
1278                 /* make a copy of it */
1279                 rv = new HashMap<String, Property>(rv);
1280             }
1281         }
1282         return rv;
1283     }
1284
1285     @Override
1286     public Property getNodeProp(Node node, String propName) {
1287         Map<String, Property> propMap = getNodeProps(node);
1288         return (propMap != null) ? propMap.get(propName) : null;
1289     }
1290
1291     @Override
1292     public void setNodeProp(Node node, Property prop) {
1293
1294         for (int i = 0; i <= REPLACE_RETRY; i++) {
1295             /* Get a copy of the property map */
1296             Map<String, Property> propMapCurr = getNodeProps(node);
1297             if (propMapCurr == null) {
1298                 return;
1299             }
1300
1301             Map<String, Property> propMap = new HashMap<String, Property>(propMapCurr);
1302             propMap.put(prop.getName(), prop);
1303
1304             if (nodeProps.replace(node, propMapCurr, propMap)) {
1305                 return;
1306             }
1307         }
1308         log.warn("Cluster conflict: Unable to add property {} to node {}.", prop.getName(), node.getID());
1309     }
1310
1311     @Override
1312     public Status removeNodeProp(Node node, String propName) {
1313         for (int i = 0; i <= REPLACE_RETRY; i++) {
1314             Map<String, Property> propMapCurr = getNodeProps(node);
1315             if (propMapCurr != null) {
1316                 if (!propMapCurr.containsKey(propName)) {
1317                     return new Status(StatusCode.SUCCESS);
1318                 }
1319                 Map<String, Property> propMap = new HashMap<String, Property>(propMapCurr);
1320                 propMap.remove(propName);
1321                 if (nodeProps.replace(node, propMapCurr, propMap)) {
1322                     return new Status(StatusCode.SUCCESS);
1323                 }
1324             } else {
1325                 return new Status(StatusCode.SUCCESS);
1326             }
1327         }
1328         String msg = "Cluster conflict: Unable to remove property " + propName + " for node " + node.getID();
1329         return new Status(StatusCode.CONFLICT, msg);
1330     }
1331
1332     @Override
1333     public Status removeNodeAllProps(Node node) {
1334         this.nodeProps.remove(node);
1335         return new Status(StatusCode.SUCCESS);
1336     }
1337
1338     @Override
1339     public Set<NodeConnector> getUpNodeConnectors(Node node) {
1340         if (nodeConnectorProps == null) {
1341             return null;
1342         }
1343
1344         Set<NodeConnector> nodeConnectorSet = new HashSet<NodeConnector>();
1345         for (Map.Entry<NodeConnector, Map<String, Property>> entry : nodeConnectorProps.entrySet()) {
1346             NodeConnector nodeConnector = entry.getKey();
1347             if (!nodeConnector.getNode().equals(node)) {
1348                 continue;
1349             }
1350             if (isNodeConnectorEnabled(nodeConnector)) {
1351                 nodeConnectorSet.add(nodeConnector);
1352             }
1353         }
1354
1355         return nodeConnectorSet;
1356     }
1357
1358     @Override
1359     public Set<NodeConnector> getNodeConnectors(Node node) {
1360         if (nodeConnectorProps == null) {
1361             return null;
1362         }
1363
1364         Set<NodeConnector> nodeConnectorSet = new HashSet<NodeConnector>();
1365         for (Map.Entry<NodeConnector, Map<String, Property>> entry : nodeConnectorProps.entrySet()) {
1366             NodeConnector nodeConnector = entry.getKey();
1367             if (!nodeConnector.getNode().equals(node)) {
1368                 continue;
1369             }
1370             nodeConnectorSet.add(nodeConnector);
1371         }
1372
1373         return nodeConnectorSet;
1374     }
1375
1376     @Override
1377     public Set<NodeConnector> getPhysicalNodeConnectors(Node node) {
1378         if (nodeConnectorProps == null) {
1379             return null;
1380         }
1381
1382         Set<NodeConnector> nodeConnectorSet = new HashSet<NodeConnector>();
1383         for (Map.Entry<NodeConnector, Map<String, Property>> entry : nodeConnectorProps.entrySet()) {
1384             NodeConnector nodeConnector = entry.getKey();
1385             if (!nodeConnector.getNode().equals(node)
1386                     || isSpecial(nodeConnector)) {
1387                 continue;
1388             }
1389             nodeConnectorSet.add(nodeConnector);
1390         }
1391
1392         return nodeConnectorSet;
1393     }
1394
1395     @Override
1396     public Map<String, Property> getNodeConnectorProps(NodeConnector nodeConnector) {
1397         Map<String, Property> rv = new HashMap<String, Property>();
1398         if (this.nodeConnectorProps != null) {
1399             rv = this.nodeConnectorProps.get(nodeConnector);
1400             if (rv != null) {
1401                 rv = new HashMap<String, Property>(rv);
1402             }
1403         }
1404         return rv;
1405     }
1406
1407     @Override
1408     public Property getNodeConnectorProp(NodeConnector nodeConnector,
1409             String propName) {
1410         Map<String, Property> propMap = getNodeConnectorProps(nodeConnector);
1411         return (propMap != null) ? propMap.get(propName) : null;
1412     }
1413
1414     private byte[] getHardwareMAC() {
1415         Enumeration<NetworkInterface> nis;
1416         byte[] macAddress = null;
1417
1418         try {
1419             nis = NetworkInterface.getNetworkInterfaces();
1420         } catch (SocketException e) {
1421             log.error("Failed to acquire controller MAC: ", e);
1422             return macAddress;
1423         }
1424
1425         while (nis.hasMoreElements()) {
1426             NetworkInterface ni = nis.nextElement();
1427             try {
1428                 macAddress = ni.getHardwareAddress();
1429             } catch (SocketException e) {
1430                 log.error("Failed to acquire controller MAC: ", e);
1431             }
1432             if (macAddress != null) {
1433                 break;
1434             }
1435         }
1436         if (macAddress == null) {
1437             log.warn("Failed to acquire controller MAC: No physical interface found");
1438             // This happens when running controller on windows VM, for example
1439             // TODO: Try parsing the OS command output
1440             // For now provide a quick fix for the release
1441             macAddress = new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x0c, (byte) 0x60, (byte) 0x0D, (byte) 0x10 };
1442             log.debug("Assigning custom MAC address to controller");
1443         }
1444         return macAddress;
1445     }
1446
1447     @Override
1448     public byte[] getControllerMAC() {
1449         MacAddress macProperty = (MacAddress)controllerProps.get(MacAddress.name);
1450         return (macProperty == null) ? null : macProperty.getMacAddress();
1451     }
1452
1453     @Override
1454     public NodeConnector getNodeConnector(Node node, String nodeConnectorName) {
1455         if (nodeConnectorNames == null) {
1456             return null;
1457         }
1458
1459         Map<String, NodeConnector> map = nodeConnectorNames.get(node);
1460         if (map == null) {
1461             return null;
1462         }
1463
1464         return map.get(nodeConnectorName);
1465     }
1466
1467     /**
1468      * Adds a node connector and its property if any
1469      *
1470      * @param nodeConnector
1471      *            {@link org.opendaylight.controller.sal.core.NodeConnector}
1472      * @param propName
1473      *            name of {@link org.opendaylight.controller.sal.core.Property}
1474      * @return success or failed reason
1475      */
1476     @Override
1477     public Status addNodeConnectorProp(NodeConnector nodeConnector,
1478             Property prop) {
1479         Map<String, Property> propMapCurr = getNodeConnectorProps(nodeConnector);
1480         Map<String, Property> propMap = (propMapCurr == null) ? new HashMap<String, Property>()
1481                 : new HashMap<String, Property>(propMapCurr);
1482
1483         String msg = "Cluster conflict: Unable to add NodeConnector Property.";
1484         // Just add the nodeConnector if prop is not available (in a non-default
1485         // container)
1486         if (prop == null) {
1487             if (propMapCurr == null) {
1488                 if (nodeConnectorProps.putIfAbsent(nodeConnector, propMap) != null) {
1489                     return new Status(StatusCode.CONFLICT, msg);
1490                 }
1491             } else {
1492                 if (!nodeConnectorProps.replace(nodeConnector, propMapCurr, propMap)) {
1493                     return new Status(StatusCode.CONFLICT, msg);
1494                 }
1495             }
1496             return new Status(StatusCode.SUCCESS);
1497         }
1498
1499         propMap.put(prop.getName(), prop);
1500         if (propMapCurr == null) {
1501             if (nodeConnectorProps.putIfAbsent(nodeConnector, propMap) != null) {
1502                 return new Status(StatusCode.CONFLICT, msg);
1503             }
1504         } else {
1505             if (!nodeConnectorProps.replace(nodeConnector, propMapCurr, propMap)) {
1506                 return new Status(StatusCode.CONFLICT, msg);
1507             }
1508         }
1509
1510         if (prop.getName().equals(Name.NamePropName)) {
1511             if (nodeConnectorNames != null) {
1512                 Node node = nodeConnector.getNode();
1513                 Map<String, NodeConnector> mapCurr = nodeConnectorNames.get(node);
1514                 Map<String, NodeConnector> map = new HashMap<String, NodeConnector>();
1515                 if (mapCurr != null) {
1516                     for (Map.Entry<String, NodeConnector> entry : mapCurr.entrySet()) {
1517                         String s = entry.getKey();
1518                         try {
1519                             map.put(s, new NodeConnector(entry.getValue()));
1520                         } catch (ConstructionException e) {
1521                             log.error("An error occured",e);
1522                         }
1523                     }
1524                 }
1525
1526                 map.put(((Name) prop).getValue(), nodeConnector);
1527                 if (mapCurr == null) {
1528                     if (nodeConnectorNames.putIfAbsent(node, map) != null) {
1529                         // TODO: recovery using Transactionality
1530                         return new Status(StatusCode.CONFLICT, msg);
1531                     }
1532                 } else {
1533                     if (!nodeConnectorNames.replace(node, mapCurr, map)) {
1534                         // TODO: recovery using Transactionality
1535                         return new Status(StatusCode.CONFLICT, msg);
1536                     }
1537                 }
1538             }
1539         }
1540
1541         return new Status(StatusCode.SUCCESS);
1542     }
1543
1544     /**
1545      * Removes one property of a node connector
1546      *
1547      * @param nodeConnector
1548      *            {@link org.opendaylight.controller.sal.core.NodeConnector}
1549      * @param propName
1550      *            name of {@link org.opendaylight.controller.sal.core.Property}
1551      * @return success or failed reason
1552      */
1553     @Override
1554     public Status removeNodeConnectorProp(NodeConnector nodeConnector, String propName) {
1555         Map<String, Property> propMapCurr = getNodeConnectorProps(nodeConnector);
1556
1557         if (propMapCurr == null) {
1558             /* Nothing to remove */
1559             return new Status(StatusCode.SUCCESS);
1560         }
1561
1562         Map<String, Property> propMap = new HashMap<String, Property>(propMapCurr);
1563         propMap.remove(propName);
1564         boolean result = nodeConnectorProps.replace(nodeConnector, propMapCurr, propMap);
1565         String msg = "Cluster conflict: Unable to remove NodeConnector property.";
1566         if (!result) {
1567             return new Status(StatusCode.CONFLICT, msg);
1568         }
1569
1570         if (propName.equals(Name.NamePropName)) {
1571             if (nodeConnectorNames != null) {
1572                 Name name = ((Name) getNodeConnectorProp(nodeConnector, Name.NamePropName));
1573                 if (name != null) {
1574                     Node node = nodeConnector.getNode();
1575                     Map<String, NodeConnector> mapCurr = nodeConnectorNames.get(node);
1576                     if (mapCurr != null) {
1577                         Map<String, NodeConnector> map = new HashMap<String, NodeConnector>();
1578                         for (Map.Entry<String, NodeConnector> entry : mapCurr.entrySet()) {
1579                             String s = entry.getKey();
1580                             try {
1581                                 map.put(s, new NodeConnector(entry.getValue()));
1582                             } catch (ConstructionException e) {
1583                                 log.error("An error occured",e);
1584                             }
1585                         }
1586                         map.remove(name.getValue());
1587                         if (!nodeConnectorNames.replace(node, mapCurr, map)) {
1588                             // TODO: recovery using Transactionality
1589                             return new Status(StatusCode.CONFLICT, msg);
1590                         }
1591                     }
1592                 }
1593             }
1594         }
1595
1596         return new Status(StatusCode.SUCCESS);
1597     }
1598
1599     /**
1600      * Removes all the properties of a node connector
1601      *
1602      * @param nodeConnector
1603      *            {@link org.opendaylight.controller.sal.core.NodeConnector}
1604      * @return success or failed reason
1605      */
1606     @Override
1607     public Status removeNodeConnectorAllProps(NodeConnector nodeConnector) {
1608         if (nodeConnectorNames != null) {
1609             Name name = ((Name) getNodeConnectorProp(nodeConnector, Name.NamePropName));
1610             if (name != null) {
1611                 Node node = nodeConnector.getNode();
1612                 Map<String, NodeConnector> mapCurr = nodeConnectorNames.get(node);
1613                 if (mapCurr != null) {
1614                     Map<String, NodeConnector> map = new HashMap<String, NodeConnector>();
1615                     for (Map.Entry<String, NodeConnector> entry : mapCurr.entrySet()) {
1616                         String s = entry.getKey();
1617                         try {
1618                             map.put(s, new NodeConnector(entry.getValue()));
1619                         } catch (ConstructionException e) {
1620                             log.error("An error occured",e);
1621                         }
1622                     }
1623                     map.remove(name.getValue());
1624                     if (map.isEmpty()) {
1625                         nodeConnectorNames.remove(node);
1626                     } else {
1627                         if (!nodeConnectorNames.replace(node, mapCurr, map)) {
1628                             log.warn("Cluster conflict: Unable remove Name property of nodeconnector {}, skip.",
1629                                     nodeConnector.getID());
1630                         }
1631                     }
1632                 }
1633
1634             }
1635         }
1636         nodeConnectorProps.remove(nodeConnector);
1637
1638         return new Status(StatusCode.SUCCESS);
1639     }
1640
1641     /**
1642      * Function called by the dependency manager when all the required
1643      * dependencies are satisfied
1644      *
1645      */
1646     void init(Component c) {
1647         Dictionary<?, ?> props = c.getServiceProperties();
1648         if (props != null) {
1649             this.containerName = (String) props.get("containerName");
1650             log.trace("Running containerName: {}", this.containerName);
1651         } else {
1652             // In the Global instance case the containerName is empty
1653             this.containerName = "";
1654         }
1655         isDefaultContainer = containerName.equals(GlobalConstants.DEFAULT
1656                 .toString());
1657
1658         startUp();
1659     }
1660
1661     /**
1662      * Function called by the dependency manager when at least one dependency
1663      * become unsatisfied or when the component is shutting down because for
1664      * example bundle is being stopped.
1665      *
1666      */
1667     void destroy() {
1668         shutDown();
1669     }
1670
1671     /**
1672      * Function called by dependency manager after "init ()" is called and after
1673      * the services provided by the class are registered in the service registry
1674      *
1675      */
1676     void start() {
1677         // OSGI console
1678         registerWithOSGIConsole();
1679     }
1680
1681     /**
1682      * Function called after registered the service in OSGi service registry.
1683      */
1684     void started() {
1685         // solicit for existing inventories
1686         getInventories();
1687     }
1688
1689     /**
1690      * Function called by the dependency manager before the services exported by
1691      * the component are unregistered, this will be followed by a "destroy ()"
1692      * calls
1693      *
1694      */
1695     void stop() {
1696     }
1697
1698     public void setInventoryService(IInventoryService service) {
1699         log.trace("Got inventory service set request {}", service);
1700         this.inventoryService = service;
1701
1702         // solicit for existing inventories
1703         getInventories();
1704     }
1705
1706     public void unsetInventoryService(IInventoryService service) {
1707         log.trace("Got a service UNset request");
1708         this.inventoryService = null;
1709
1710         // clear existing inventories
1711         clearInventories();
1712     }
1713
1714     public void setStatisticsManager(IStatisticsManager statisticsManager) {
1715         log.trace("Got statistics manager set request {}", statisticsManager);
1716         this.statisticsManager = statisticsManager;
1717     }
1718
1719     public void unsetStatisticsManager(IStatisticsManager statisticsManager) {
1720         log.trace("Got statistics manager UNset request");
1721         this.statisticsManager = null;
1722     }
1723
1724     public void setSwitchManagerAware(ISwitchManagerAware service) {
1725         log.trace("Got inventory service set request {}", service);
1726         if (this.switchManagerAware != null) {
1727             this.switchManagerAware.add(service);
1728         }
1729
1730         // bulk update for newly joined
1731         switchManagerAwareNotify(service);
1732     }
1733
1734     public void unsetSwitchManagerAware(ISwitchManagerAware service) {
1735         log.trace("Got a service UNset request");
1736         if (this.switchManagerAware != null) {
1737             this.switchManagerAware.remove(service);
1738         }
1739     }
1740
1741     public void setInventoryListener(IInventoryListener service) {
1742         log.trace("Got inventory listener set request {}", service);
1743         if (this.inventoryListeners != null) {
1744             this.inventoryListeners.add(service);
1745         }
1746
1747         // bulk update for newly joined
1748         bulkUpdateService(service);
1749     }
1750
1751     public void unsetInventoryListener(IInventoryListener service) {
1752         log.trace("Got a service UNset request");
1753         if (this.inventoryListeners != null) {
1754             this.inventoryListeners.remove(service);
1755         }
1756     }
1757
1758     public void setSpanAware(ISpanAware service) {
1759         log.trace("Got SpanAware set request {}", service);
1760         if (this.spanAware != null) {
1761             this.spanAware.add(service);
1762         }
1763
1764         // bulk update for newly joined
1765         spanAwareNotify(service);
1766     }
1767
1768     public void unsetSpanAware(ISpanAware service) {
1769         log.trace("Got a service UNset request");
1770         if (this.spanAware != null) {
1771             this.spanAware.remove(service);
1772         }
1773     }
1774
1775     void setClusterContainerService(IClusterContainerServices s) {
1776         log.trace("Cluster Service set");
1777         this.clusterContainerService = s;
1778     }
1779
1780     void unsetClusterContainerService(IClusterContainerServices s) {
1781         if (this.clusterContainerService == s) {
1782             log.trace("Cluster Service removed!");
1783             this.clusterContainerService = null;
1784         }
1785     }
1786
1787     private void getInventories() {
1788         if (inventoryService == null) {
1789             log.trace("inventory service not avaiable");
1790             return;
1791         }
1792
1793         Map<Node, Map<String, Property>> nodeProp = this.inventoryService.getNodeProps();
1794         for (Map.Entry<Node, Map<String, Property>> entry : nodeProp.entrySet()) {
1795             Node node = entry.getKey();
1796             log.debug("getInventories: {} added for container {}", new Object[] { node, containerName });
1797             Map<String, Property> propMap = entry.getValue();
1798             Set<Property> props = new HashSet<Property>();
1799             for (Property property : propMap.values()) {
1800                 props.add(property);
1801             }
1802             addNode(node, props);
1803         }
1804
1805         Map<NodeConnector, Map<String, Property>> nodeConnectorProp = this.inventoryService.getNodeConnectorProps();
1806         for (Map.Entry<NodeConnector, Map<String, Property>> entry : nodeConnectorProp.entrySet()) {
1807             Map<String, Property> propMap = entry.getValue();
1808             for (Property property : propMap.values()) {
1809                 addNodeConnectorProp(entry.getKey(), property);
1810             }
1811         }
1812     }
1813
1814     private void clearInventories() {
1815         nodeProps.clear();
1816         nodeConnectorProps.clear();
1817         nodeConnectorNames.clear();
1818         spanNodeConnectors.clear();
1819     }
1820
1821     private void notifyNode(Node node, UpdateType type,
1822             Map<String, Property> propMap) {
1823         synchronized (inventoryListeners) {
1824             for (IInventoryListener service : inventoryListeners) {
1825                 service.notifyNode(node, type, propMap);
1826             }
1827         }
1828     }
1829
1830     private void notifyNodeConnector(NodeConnector nodeConnector,
1831             UpdateType type, Map<String, Property> propMap) {
1832         synchronized (inventoryListeners) {
1833             for (IInventoryListener service : inventoryListeners) {
1834                 service.notifyNodeConnector(nodeConnector, type, propMap);
1835             }
1836         }
1837     }
1838
1839     /*
1840      * For those joined late, bring them up-to-date.
1841      */
1842     private void switchManagerAwareNotify(ISwitchManagerAware service) {
1843         for (Subnet sub : subnets.values()) {
1844             service.subnetNotify(sub, true);
1845         }
1846
1847         for (Node node : getNodes()) {
1848             SwitchConfig sc = getSwitchConfig(node.toString());
1849             if ((sc != null) && isDefaultContainer) {
1850                 ForwardingMode mode = (ForwardingMode) sc.getProperty(ForwardingMode.name);
1851                 service.modeChangeNotify(node, (mode == null) ? false : mode.isProactive());
1852             }
1853         }
1854     }
1855
1856     private void bulkUpdateService(IInventoryListener service) {
1857         Map<String, Property> propMap;
1858         UpdateType type = UpdateType.ADDED;
1859
1860         for (Node node : getNodes()) {
1861             propMap = nodeProps.get(node);
1862             service.notifyNode(node, type, propMap);
1863         }
1864
1865         for (Map.Entry<NodeConnector, Map<String, Property>> entry : nodeConnectorProps.entrySet()) {
1866             NodeConnector nodeConnector = entry.getKey();
1867             propMap = nodeConnectorProps.get(nodeConnector);
1868             service.notifyNodeConnector(nodeConnector, type, propMap);
1869         }
1870     }
1871
1872     private void spanAwareNotify(ISpanAware service) {
1873         for (Node node : getNodes()) {
1874             for (SpanConfig conf : getSpanConfigList(node)) {
1875                 service.spanUpdate(node, conf.getPortArrayList(), true);
1876             }
1877         }
1878     }
1879
1880     private void registerWithOSGIConsole() {
1881         BundleContext bundleContext = FrameworkUtil.getBundle(this.getClass())
1882                 .getBundleContext();
1883         bundleContext.registerService(CommandProvider.class.getName(), this,
1884                 null);
1885     }
1886
1887     @Override
1888     public Boolean isNodeConnectorEnabled(NodeConnector nodeConnector) {
1889         if (nodeConnector == null) {
1890             return false;
1891         }
1892
1893         Config config = (Config) getNodeConnectorProp(nodeConnector,
1894                 Config.ConfigPropName);
1895         State state = (State) getNodeConnectorProp(nodeConnector,
1896                 State.StatePropName);
1897         return ((config != null) && (config.getValue() == Config.ADMIN_UP)
1898                 && (state != null) && (state.getValue() == State.EDGE_UP));
1899     }
1900
1901     @Override
1902     public boolean doesNodeConnectorExist(NodeConnector nc) {
1903         return (nc != null && nodeConnectorProps != null
1904                 && nodeConnectorProps.containsKey(nc));
1905     }
1906
1907     @Override
1908     public String getHelp() {
1909         StringBuffer help = new StringBuffer();
1910         help.append("---Switch Manager---\n");
1911         help.append("\t pencs <node id>        - Print enabled node connectors for a given node\n");
1912         help.append("\t pdm <node id>          - Print switch ports in device map\n");
1913         return help.toString();
1914     }
1915
1916     public void _pencs(CommandInterpreter ci) {
1917         String st = ci.nextArgument();
1918         if (st == null) {
1919             ci.println("Please enter node id");
1920             return;
1921         }
1922
1923         Node node = Node.fromString(st);
1924         if (node == null) {
1925             ci.println("Please enter node id");
1926             return;
1927         }
1928
1929         Set<NodeConnector> nodeConnectorSet = getUpNodeConnectors(node);
1930         if (nodeConnectorSet == null) {
1931             return;
1932         }
1933         for (NodeConnector nodeConnector : nodeConnectorSet) {
1934             if (nodeConnector == null) {
1935                 continue;
1936             }
1937             ci.println(nodeConnector);
1938         }
1939         ci.println("Total number of NodeConnectors: " + nodeConnectorSet.size());
1940     }
1941
1942     public void _pdm(CommandInterpreter ci) {
1943         String st = ci.nextArgument();
1944         if (st == null) {
1945             ci.println("Please enter node id");
1946             return;
1947         }
1948
1949         Node node = Node.fromString(st);
1950         if (node == null) {
1951             ci.println("Please enter node id");
1952             return;
1953         }
1954
1955         Switch sw = getSwitchByNode(node);
1956
1957         ci.println("          NodeConnector                        Name");
1958
1959         Set<NodeConnector> nodeConnectorSet = sw.getNodeConnectors();
1960         String nodeConnectorName;
1961         if (nodeConnectorSet != null && nodeConnectorSet.size() > 0) {
1962             for (NodeConnector nodeConnector : nodeConnectorSet) {
1963                 Map<String, Property> propMap = getNodeConnectorProps(nodeConnector);
1964                 nodeConnectorName = (propMap == null) ? null : ((Name) propMap
1965                         .get(Name.NamePropName)).getValue();
1966                 if (nodeConnectorName != null) {
1967                     Node nd = nodeConnector.getNode();
1968                     if (!nd.equals(node)) {
1969                         log.debug("node not match {} {}", nd, node);
1970                     }
1971                     Map<String, NodeConnector> map = nodeConnectorNames
1972                             .get(node);
1973                     if (map != null) {
1974                         NodeConnector nc = map.get(nodeConnectorName);
1975                         if (nc == null) {
1976                             log.debug("no nodeConnector named {}",
1977                                     nodeConnectorName);
1978                         } else if (!nc.equals(nodeConnector)) {
1979                             log.debug("nodeConnector not match {} {}", nc,
1980                                     nodeConnector);
1981                         }
1982                     }
1983                 }
1984
1985                 ci.println(nodeConnector
1986                         + "            "
1987                         + ((nodeConnectorName == null) ? "" : nodeConnectorName)
1988                         + "(" + nodeConnector.getID() + ")");
1989             }
1990             ci.println("Total number of NodeConnectors: "
1991                     + nodeConnectorSet.size());
1992         }
1993     }
1994
1995     @Override
1996     public byte[] getNodeMAC(Node node) {
1997         MacAddress mac = (MacAddress) this.getNodeProp(node,
1998                 MacAddress.name);
1999         return (mac != null) ? mac.getMacAddress() : null;
2000     }
2001
2002     @Override
2003     public boolean isSpecial(NodeConnector p) {
2004         if (p.getType().equals(NodeConnectorIDType.CONTROLLER)
2005                 || p.getType().equals(NodeConnectorIDType.ALL)
2006                 || p.getType().equals(NodeConnectorIDType.SWSTACK)
2007                 || p.getType().equals(NodeConnectorIDType.HWPATH)) {
2008             return true;
2009         }
2010         return false;
2011     }
2012
2013     /*
2014      * Add span configuration to local cache and notify clients
2015      */
2016     private void addSpanPorts(Node node, List<NodeConnector> nodeConnectors) {
2017         List<NodeConnector> ncLists = new ArrayList<NodeConnector>();
2018
2019         for (NodeConnector nodeConnector : nodeConnectors) {
2020             if (!spanNodeConnectors.contains(nodeConnector)) {
2021                 ncLists.add(nodeConnector);
2022             }
2023         }
2024
2025         if (ncLists.size() > 0) {
2026             spanNodeConnectors.addAll(ncLists);
2027             notifySpanPortChange(node, ncLists, true);
2028         }
2029     }
2030
2031     private void addSpanPorts(Node node) {
2032         for (SpanConfig conf : getSpanConfigList(node)) {
2033             addSpanPorts(node, conf.getPortArrayList());
2034         }
2035     }
2036
2037     private void addSpanPort(NodeConnector nodeConnector) {
2038         // only add if span is configured on this nodeConnector
2039         for (SpanConfig conf : getSpanConfigList(nodeConnector.getNode())) {
2040             if (conf.getPortArrayList().contains(nodeConnector)) {
2041                 List<NodeConnector> ncLists = new ArrayList<NodeConnector>();
2042                 ncLists.add(nodeConnector);
2043                 addSpanPorts(nodeConnector.getNode(), ncLists);
2044                 return;
2045             }
2046         }
2047     }
2048
2049     /*
2050      * Remove span configuration to local cache and notify clients
2051      */
2052     private void removeSpanPorts(Node node, List<NodeConnector> nodeConnectors) {
2053         List<NodeConnector> ncLists = new ArrayList<NodeConnector>();
2054
2055         for (NodeConnector nodeConnector : nodeConnectors) {
2056             if (spanNodeConnectors.contains(nodeConnector)) {
2057                 ncLists.add(nodeConnector);
2058             }
2059         }
2060
2061         if (ncLists.size() > 0) {
2062             spanNodeConnectors.removeAll(ncLists);
2063             notifySpanPortChange(node, ncLists, false);
2064         }
2065     }
2066
2067     private void removeSpanPorts(Node node) {
2068         for (SpanConfig conf : getSpanConfigList(node)) {
2069             addSpanPorts(node, conf.getPortArrayList());
2070         }
2071     }
2072
2073     private void removeSpanPort(NodeConnector nodeConnector) {
2074         if (spanNodeConnectors.contains(nodeConnector)) {
2075             List<NodeConnector> ncLists = new ArrayList<NodeConnector>();
2076             ncLists.add(nodeConnector);
2077             removeSpanPorts(nodeConnector.getNode(), ncLists);
2078         }
2079     }
2080
2081     private void addNodeProps(Node node, Map<String, Property> propMap) {
2082         if (propMap == null) {
2083             propMap = new HashMap<String, Property>();
2084         }
2085         nodeProps.put(node, propMap);
2086     }
2087
2088     @Override
2089     public Status saveConfiguration() {
2090         return saveSwitchConfig();
2091     }
2092
2093     /**
2094      * Creates a Name/Tier/Bandwidth/MacAddress(controller property) Property
2095      * object based on given property name and value. Other property types are
2096      * not supported yet.
2097      *
2098      * @param propName
2099      *            Name of the Property
2100      * @param propValue
2101      *            Value of the Property
2102      * @return {@link org.opendaylight.controller.sal.core.Property}
2103      */
2104     @Override
2105     public Property createProperty(String propName, String propValue) {
2106         if (propName == null) {
2107             log.debug("propName is null");
2108             return null;
2109         }
2110         if (propValue == null) {
2111             log.debug("propValue is null");
2112             return null;
2113         }
2114
2115         try {
2116             if (propName.equalsIgnoreCase(Description.propertyName)) {
2117                 return new Description(propValue);
2118             } else if (propName.equalsIgnoreCase(Tier.TierPropName)) {
2119                 int tier = Integer.parseInt(propValue);
2120                 return new Tier(tier);
2121             } else if (propName.equalsIgnoreCase(Bandwidth.BandwidthPropName)) {
2122                 long bw = Long.parseLong(propValue);
2123                 return new Bandwidth(bw);
2124             } else if (propName.equalsIgnoreCase(ForwardingMode.name)) {
2125                 int mode = Integer.parseInt(propValue);
2126                 return new ForwardingMode(mode);
2127             } else if (propName.equalsIgnoreCase(MacAddress.name)){
2128                 return new MacAddress(propValue);
2129             }
2130             else {
2131                 log.debug("Not able to create {} property", propName);
2132             }
2133         } catch (Exception e) {
2134             log.debug("createProperty caught exception {}", e.getMessage());
2135         }
2136
2137         return null;
2138     }
2139
2140
2141     @SuppressWarnings("deprecation")
2142     @Override
2143     public String getNodeDescription(Node node) {
2144         // Check first if user configured a name
2145         SwitchConfig config = getSwitchConfig(node.toString());
2146         if (config != null) {
2147             String configuredDesc = config.getNodeDescription();
2148             if (configuredDesc != null && !configuredDesc.isEmpty()) {
2149                 return configuredDesc;
2150             }
2151         }
2152
2153         // No name configured by user, get the node advertised name
2154         Description desc = (Description) getNodeProp(node,
2155                 Description.propertyName);
2156         return (desc == null /* || desc.getValue().equalsIgnoreCase("none") */) ? ""
2157                 : desc.getValue();
2158     }
2159
2160     @Override
2161     public Set<Switch> getConfiguredNotConnectedSwitches() {
2162         Set<Switch> configuredNotConnectedSwitches = new HashSet<Switch>();
2163         if (this.inventoryService == null) {
2164             log.trace("inventory service not avaiable");
2165             return configuredNotConnectedSwitches;
2166         }
2167
2168         Set<Node> configuredNotConnectedNodes = this.inventoryService.getConfiguredNotConnectedNodes();
2169         if (configuredNotConnectedNodes != null) {
2170             for (Node node : configuredNotConnectedNodes) {
2171                 Switch sw = getSwitchByNode(node);
2172                 if (sw != null) {
2173                     configuredNotConnectedSwitches.add(sw);
2174                 }
2175             }
2176         }
2177         return configuredNotConnectedSwitches;
2178     }
2179
2180 }