opendaylight/web/devices/src/main/java/org/opendaylight/controller/devices/web/Devices.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.devices.web;
  10
  11 import java.util.ArrayList;
  12 import java.util.HashMap;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.Map.Entry;
  16 import java.util.Set;
  17 import java.util.TreeMap;
  18 import java.util.concurrent.ConcurrentMap;
  19 import javax.servlet.http.HttpServletRequest;
  20 import javax.servlet.http.HttpServletResponse;
  21
  22 import org.codehaus.jackson.map.ObjectMapper;
  23 import org.opendaylight.controller.usermanager.IUserManager;
  24 import org.opendaylight.controller.web.DaylightWebUtil;
  25 import org.opendaylight.controller.web.IDaylightWeb;
  26 import org.springframework.stereotype.Controller;
  27 import org.springframework.web.bind.annotation.RequestMapping;
  28 import org.springframework.web.bind.annotation.RequestMethod;
  29 import org.springframework.web.bind.annotation.RequestParam;
  30 import org.springframework.web.bind.annotation.ResponseBody;
  31 import org.opendaylight.controller.forwarding.staticrouting.IForwardingStaticRouting;
  32 import org.opendaylight.controller.forwarding.staticrouting.StaticRouteConfig;
  33 import org.opendaylight.controller.sal.authorization.UserLevel;
  34 import org.opendaylight.controller.sal.core.Config;
  35 import org.opendaylight.controller.sal.core.Name;
  36 import org.opendaylight.controller.sal.core.Node;
  37 import org.opendaylight.controller.sal.core.NodeConnector;
  38 import org.opendaylight.controller.sal.core.Tier;
  39 import org.opendaylight.controller.sal.utils.GlobalConstants;
  40 import org.opendaylight.controller.sal.utils.HexEncode;
  41 import org.opendaylight.controller.sal.utils.ServiceHelper;
  42 import org.opendaylight.controller.sal.utils.Status;
  43 import org.opendaylight.controller.sal.utils.TierHelper;
  44 import org.opendaylight.controller.switchmanager.ISwitchManager;
  45 import org.opendaylight.controller.switchmanager.SpanConfig;
  46 import org.opendaylight.controller.switchmanager.SubnetConfig;
  47 import org.opendaylight.controller.switchmanager.Switch;
  48 import org.opendaylight.controller.switchmanager.SwitchConfig;
  49
  50 import com.google.gson.Gson;
  51
  52 @Controller
  53 @RequestMapping("/")
  54 public class Devices implements IDaylightWeb {
  55     private static final UserLevel AUTH_LEVEL = UserLevel.CONTAINERUSER;
  56     private final String WEB_NAME = "Devices";
  57     private final String WEB_ID = "devices";
  58     private final short WEB_ORDER = 1;
  59
  60     public Devices() {
  61         ServiceHelper.registerGlobalService(IDaylightWeb.class, this, null);
  62     }
  63
  64     @Override
  65     public String getWebName() {
  66         return WEB_NAME;
  67     }
  68
  69     @Override
  70     public String getWebId() {
  71         return WEB_ID;
  72     }
  73
  74     @Override
  75     public short getWebOrder() {
  76         return WEB_ORDER;
  77     }
  78
  79     @Override
  80     public boolean isAuthorized(UserLevel userLevel) {
  81         return userLevel.ordinal() <= AUTH_LEVEL.ordinal();
  82     }
  83
  84     @RequestMapping(value = "/nodesLearnt", method = RequestMethod.GET)
  85     @ResponseBody
  86     public DevicesJsonBean getNodesLearnt(HttpServletRequest request, @RequestParam(required = false) String container) {
  87         Gson gson = new Gson();
  88         String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
  89         ISwitchManager switchManager = (ISwitchManager) ServiceHelper
  90                 .getInstance(ISwitchManager.class, containerName, this);
  91         List<Map<String, String>> nodeData = new ArrayList<Map<String, String>>();
  92         for (Switch device : switchManager.getNetworkDevices()) {
  93             HashMap<String, String> nodeDatum = new HashMap<String, String>();
  94             Node node = device.getNode();
  95             Tier tier = (Tier) switchManager.getNodeProp(node,
  96                     Tier.TierPropName);
  97
  98             nodeDatum.put("containerName", containerName);
  99             nodeDatum.put("nodeName", switchManager.getNodeDescription(node));
 100             nodeDatum.put("nodeId", node.toString());
 101             int tierNumber = (tier == null) ? TierHelper.unknownTierNumber
 102                     : tier.getValue();
 103             nodeDatum.put("tierName", TierHelper.getTierName(tierNumber)
 104                     + " (Tier-" + tierNumber + ")");
 105             nodeDatum.put("tier", tierNumber + "");
 106             SwitchConfig sc = switchManager.getSwitchConfig(device.getNode()
 107                     .toString());
 108             String modeStr = (sc != null) ? sc.getMode() : "0";
 109             nodeDatum.put("mode", modeStr);
 110
 111             nodeDatum.put("json", gson.toJson(nodeDatum));
 112             nodeDatum.put("mac",
 113                     HexEncode.bytesToHexString(device.getDataLayerAddress()));
 114             StringBuffer sb1 = new StringBuffer();
 115             Set<NodeConnector> nodeConnectorSet = device.getNodeConnectors();
 116             if (nodeConnectorSet != null && nodeConnectorSet.size() > 0) {
 117                 Map<Short, String> portList = new HashMap<Short, String>();
 118                 for (NodeConnector nodeConnector : nodeConnectorSet) {
 119                     String nodeConnectorNumberToStr = nodeConnector.getID().toString();
 120                     Name ncName = ((Name) switchManager.getNodeConnectorProp(
 121                             nodeConnector, Name.NamePropName));
 122                     Config portStatus = ((Config) switchManager
 123                             .getNodeConnectorProp(nodeConnector,
 124                                     Config.ConfigPropName));
 125
 126                     String nodeConnectorName = (ncName != null) ? ncName.getValue()
 127                             : "";
 128                     nodeConnectorName += " ("+nodeConnector.getID()+")";
 129
 130                     if (portStatus != null) {
 131                         if (portStatus.getValue() == Config.ADMIN_UP) {
 132                             nodeConnectorName = "<span style='color:green;'>"+nodeConnectorName+"</span>";
 133                         } else if (portStatus.getValue() == Config.ADMIN_DOWN) {
 134                             nodeConnectorName = "<span style='color:red;'>"+nodeConnectorName+"</span>";
 135                         }
 136                     }
 137
 138                     portList.put(Short.parseShort(nodeConnectorNumberToStr),
 139                             nodeConnectorName);
 140                 }
 141
 142                 Map<Short, String> sortedPortList = new TreeMap<Short, String>(portList);
 143
 144                 for (Entry<Short, String> e : sortedPortList.entrySet()) {
 145                     sb1.append(e.getValue());
 146                     sb1.append("<br>");
 147                 }
 148             }
 149             nodeDatum.put("ports", sb1.toString());
 150             nodeData.add(nodeDatum);
 151         }
 152         DevicesJsonBean result = new DevicesJsonBean();
 153         result.setNodeData(nodeData);
 154         List<String> columnNames = new ArrayList<String>();
 155         columnNames.add("Node ID");
 156         columnNames.add("Node Name");
 157         columnNames.add("Tier");
 158         columnNames.add("Mac Address");
 159         columnNames.add("Ports");
 160         columnNames.add("Port Status");
 161
 162         result.setColumnNames(columnNames);
 163         return result;
 164     }
 165
 166     @RequestMapping(value = "/tiers", method = RequestMethod.GET)
 167     @ResponseBody
 168     public List<String> getTiers() {
 169         return TierHelper.getTiers();
 170     }
 171
 172     @RequestMapping(value = "/nodesLearnt/update", method = RequestMethod.GET)
 173     @ResponseBody
 174     public StatusJsonBean updateLearntNode(
 175             @RequestParam("nodeName") String nodeName,
 176             @RequestParam("nodeId") String nodeId,
 177             @RequestParam("tier") String tier,
 178             @RequestParam("operationMode") String operationMode,
 179             HttpServletRequest request, @RequestParam(required = false) String container) {
 180         if (!authorize(UserLevel.NETWORKADMIN, request)) {
 181             return unauthorizedMessage();
 182         }
 183
 184         StatusJsonBean resultBean = new StatusJsonBean();
 185         String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
 186         try {
 187             ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 188                     .getInstance(ISwitchManager.class, containerName, this);
 189             SwitchConfig cfg = new SwitchConfig(nodeId, nodeName, tier,
 190                     operationMode);
 191             switchManager.updateSwitchConfig(cfg);
 192             resultBean.setStatus(true);
 193             resultBean.setMessage("Updated node information successfully");
 194         } catch (Exception e) {
 195             resultBean.setStatus(false);
 196             resultBean.setMessage("Error updating node information. "
 197                     + e.getMessage());
 198         }
 199         return resultBean;
 200     }
 201
 202     @RequestMapping(value = "/staticRoutes", method = RequestMethod.GET)
 203     @ResponseBody
 204     public DevicesJsonBean getStaticRoutes(HttpServletRequest request, @RequestParam(required = false) String container) {
 205         Gson gson = new Gson();
 206         String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
 207         IForwardingStaticRouting staticRouting = (IForwardingStaticRouting) ServiceHelper
 208                 .getInstance(IForwardingStaticRouting.class, containerName,
 209                         this);
 210         List<Map<String, String>> staticRoutes = new ArrayList<Map<String, String>>();
 211         ConcurrentMap<String, StaticRouteConfig> routeConfigs = staticRouting
 212                 .getStaticRouteConfigs();
 213         if (routeConfigs == null) {
 214             return null;
 215         }
 216         for (StaticRouteConfig conf : routeConfigs.values()) {
 217             Map<String, String> staticRoute = new HashMap<String, String>();
 218             staticRoute.put("name", conf.getName());
 219             staticRoute.put("staticRoute", conf.getStaticRoute());
 220             staticRoute.put("nextHopType", conf.getNextHopType());
 221             staticRoute.put("nextHop", conf.getNextHop());
 222             staticRoute.put("json", gson.toJson(conf));
 223             staticRoutes.add(staticRoute);
 224         }
 225         DevicesJsonBean result = new DevicesJsonBean();
 226         result.setColumnNames(StaticRouteConfig.getGuiFieldsNames());
 227         result.setNodeData(staticRoutes);
 228         return result;
 229     }
 230
 231     @RequestMapping(value = "/staticRoute/add", method = RequestMethod.GET)
 232     @ResponseBody
 233     public StatusJsonBean addStaticRoute(
 234             @RequestParam("routeName") String routeName,
 235             @RequestParam("staticRoute") String staticRoute,
 236             @RequestParam("nextHop") String nextHop,
 237             HttpServletRequest request, @RequestParam(required = false) String container) {
 238         if (!authorize(UserLevel.NETWORKADMIN, request)) {
 239             return unauthorizedMessage();
 240         }
 241
 242         StatusJsonBean result = new StatusJsonBean();
 243         String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
 244         try {
 245             IForwardingStaticRouting staticRouting = (IForwardingStaticRouting) ServiceHelper
 246                     .getInstance(IForwardingStaticRouting.class, containerName,
 247                             this);
 248             StaticRouteConfig config = new StaticRouteConfig();
 249             config.setName(routeName);
 250             config.setStaticRoute(staticRoute);
 251             config.setNextHop(nextHop);
 252             Status addStaticRouteResult = staticRouting.addStaticRoute(config);
 253             if (addStaticRouteResult.isSuccess()) {
 254                 result.setStatus(true);
 255                 result.setMessage("Static Route saved successfully");
 256             } else {
 257                 result.setStatus(false);
 258                 result.setMessage(addStaticRouteResult.getDescription());
 259             }
 260         } catch (Exception e) {
 261             result.setStatus(false);
 262             result.setMessage("Error - " + e.getMessage());
 263         }
 264         return result;
 265     }
 266
 267     @RequestMapping(value = "/staticRoute/delete", method = RequestMethod.GET)
 268     @ResponseBody
 269     public StatusJsonBean deleteStaticRoute(
 270             @RequestParam("routesToDelete") String routesToDelete,
 271             HttpServletRequest request, @RequestParam(required = false) String container) {
 272         if (!authorize(UserLevel.NETWORKADMIN, request)) {
 273             return unauthorizedMessage();
 274         }
 275
 276         StatusJsonBean resultBean = new StatusJsonBean();
 277         String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
 278         try {
 279             IForwardingStaticRouting staticRouting = (IForwardingStaticRouting) ServiceHelper
 280                     .getInstance(IForwardingStaticRouting.class, containerName,
 281                             this);
 282             String[] routes = routesToDelete.split(",");
 283             Status result;
 284             resultBean.setStatus(true);
 285             resultBean
 286                     .setMessage("Successfully deleted selected static routes");
 287             for (String route : routes) {
 288                 result = staticRouting.removeStaticRoute(route);
 289                 if (!result.isSuccess()) {
 290                     resultBean.setStatus(false);
 291                     resultBean.setMessage(result.getDescription());
 292                     break;
 293                 }
 294             }
 295         } catch (Exception e) {
 296             resultBean.setStatus(false);
 297             resultBean
 298                     .setMessage("Error occurred while deleting static routes. "
 299                             + e.getMessage());
 300         }
 301         return resultBean;
 302     }
 303
 304     @RequestMapping(value = "/subnets", method = RequestMethod.GET)
 305     @ResponseBody
 306     public DevicesJsonBean getSubnetGateways(HttpServletRequest request, @RequestParam(required = false) String container) {
 307         Gson gson = new Gson();
 308         List<Map<String, String>> subnets = new ArrayList<Map<String, String>>();
 309         String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
 310         ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 311                 .getInstance(ISwitchManager.class, containerName, this);
 312         for (SubnetConfig conf : switchManager.getSubnetsConfigList()) {
 313             Map<String, String> subnet = new HashMap<String, String>();
 314             subnet.put("name", conf.getName());
 315             subnet.put("subnet", conf.getSubnet());
 316             subnet.put("json", gson.toJson(conf));
 317             subnets.add(subnet);
 318         }
 319         DevicesJsonBean result = new DevicesJsonBean();
 320         result.setColumnNames(SubnetConfig.getGuiFieldsNames());
 321         result.setNodeData(subnets);
 322         return result;
 323     }
 324
 325     @RequestMapping(value = "/subnetGateway/add", method = RequestMethod.GET)
 326     @ResponseBody
 327     public StatusJsonBean addSubnetGateways(
 328             @RequestParam("gatewayName") String gatewayName,
 329             @RequestParam("gatewayIPAddress") String gatewayIPAddress,
 330             HttpServletRequest request, @RequestParam(required = false) String container) {
 331         if (!authorize(UserLevel.NETWORKADMIN, request)) {
 332             return unauthorizedMessage();
 333         }
 334
 335         StatusJsonBean resultBean = new StatusJsonBean();
 336         String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
 337         try {
 338             ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 339                     .getInstance(ISwitchManager.class, containerName, this);
 340             SubnetConfig cfgObject = new SubnetConfig(gatewayName,
 341                     gatewayIPAddress, new ArrayList<String>());
 342             Status result = switchManager.addSubnet(cfgObject);
 343             if (result.isSuccess()) {
 344                 resultBean.setStatus(true);
 345                 resultBean.setMessage("Added gateway address successfully");
 346             } else {
 347                 resultBean.setStatus(false);
 348                 resultBean.setMessage(result.getDescription());
 349             }
 350         } catch (Exception e) {
 351             resultBean.setStatus(false);
 352             resultBean.setMessage(e.getMessage());
 353         }
 354         return resultBean;
 355     }
 356
 357     @RequestMapping(value = "/subnetGateway/delete", method = RequestMethod.GET)
 358     @ResponseBody
 359     public StatusJsonBean deleteSubnetGateways(
 360             @RequestParam("gatewaysToDelete") String gatewaysToDelete,
 361             HttpServletRequest request, @RequestParam(required = false) String container) {
 362         if (!authorize(UserLevel.NETWORKADMIN, request)) {
 363             return unauthorizedMessage();
 364         }
 365
 366         StatusJsonBean resultBean = new StatusJsonBean();
 367         String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
 368         try {
 369             ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 370                     .getInstance(ISwitchManager.class, containerName, this);
 371             String[] subnets = gatewaysToDelete.split(",");
 372             resultBean.setStatus(true);
 373             resultBean.setMessage("Added gateway address successfully");
 374             for (String subnet : subnets) {
 375                 Status result = switchManager.removeSubnet(subnet);
 376                 if (!result.isSuccess()) {
 377                     resultBean.setStatus(false);
 378                     resultBean.setMessage(result.getDescription());
 379                     break;
 380                 }
 381             }
 382         } catch (Exception e) {
 383             resultBean.setStatus(false);
 384             resultBean.setMessage(e.getMessage());
 385         }
 386         return resultBean;
 387     }
 388
 389     @RequestMapping(value = "/subnetGateway/ports/add", method = RequestMethod.GET)
 390     @ResponseBody
 391     public StatusJsonBean addSubnetGatewayPort(
 392             @RequestParam("portsName") String portsName,
 393             @RequestParam("ports") String ports,
 394             @RequestParam("nodeId") String nodeId,
 395             HttpServletRequest request, @RequestParam(required = false) String container) {
 396         if (!authorize(UserLevel.NETWORKADMIN, request)) {
 397             return unauthorizedMessage();
 398         }
 399
 400         StatusJsonBean resultBean = new StatusJsonBean();
 401         String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
 402         try {
 403             ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 404                     .getInstance(ISwitchManager.class, containerName, this);
 405             Status result = switchManager.addPortsToSubnet(portsName, nodeId
 406                     + "/" + ports);
 407
 408             if (result.isSuccess()) {
 409                 resultBean.setStatus(true);
 410                 resultBean
 411                         .setMessage("Added ports to subnet gateway address successfully");
 412             } else {
 413                 resultBean.setStatus(false);
 414                 resultBean.setMessage(result.getDescription());
 415             }
 416         } catch (Exception e) {
 417             resultBean.setStatus(false);
 418             resultBean.setMessage(e.getMessage());
 419         }
 420         return resultBean;
 421     }
 422
 423     @RequestMapping(value = "/subnetGateway/ports/delete", method = RequestMethod.GET)
 424     @ResponseBody
 425     public StatusJsonBean deleteSubnetGatewayPort(
 426             @RequestParam("gatewayName") String gatewayName,
 427             @RequestParam("nodePort") String nodePort,
 428             HttpServletRequest request, @RequestParam(required = false) String container) {
 429         if (!authorize(UserLevel.NETWORKADMIN, request)) {
 430             return unauthorizedMessage();
 431         }
 432
 433         StatusJsonBean resultBean = new StatusJsonBean();
 434         String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
 435         try {
 436             ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 437                     .getInstance(ISwitchManager.class, containerName, this);
 438             Status result = switchManager.removePortsFromSubnet(gatewayName,
 439                     nodePort);
 440
 441             if (result.isSuccess()) {
 442                 resultBean.setStatus(true);
 443                 resultBean
 444                         .setMessage("Deleted port from subnet gateway address successfully");
 445             } else {
 446                 resultBean.setStatus(false);
 447                 resultBean.setMessage(result.getDescription());
 448             }
 449         } catch (Exception e) {
 450             resultBean.setStatus(false);
 451             resultBean.setMessage(e.getMessage());
 452         }
 453         return resultBean;
 454     }
 455
 456     @RequestMapping(value = "/spanPorts", method = RequestMethod.GET)
 457     @ResponseBody
 458     public DevicesJsonBean getSpanPorts(HttpServletRequest request, @RequestParam(required = false) String container) {
 459         Gson gson = new Gson();
 460         List<String> spanConfigs_json = new ArrayList<String>();
 461         String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
 462         ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 463                 .getInstance(ISwitchManager.class, containerName, this);
 464         for (SpanConfig conf : switchManager.getSpanConfigList()) {
 465             spanConfigs_json.add(gson.toJson(conf));
 466         }
 467         ObjectMapper mapper = new ObjectMapper();
 468         List<Map<String, String>> spanConfigs = new ArrayList<Map<String, String>>();
 469         for (String config_json : spanConfigs_json) {
 470             try {
 471                 @SuppressWarnings("unchecked")
 472                 Map<String, String> config_data = mapper.readValue(config_json,
 473                         HashMap.class);
 474                 Map<String, String> config = new HashMap<String, String>();
 475                 for (String name : config_data.keySet()) {
 476                     config.put(name, config_data.get(name));
 477                     // Add switch name value (non-configuration field)
 478                     config.put("nodeName",
 479                             getNodeDesc(config_data.get("nodeId"), containerName));
 480                 }
 481                 config.put("json", config_json);
 482                 spanConfigs.add(config);
 483             } catch (Exception e) {
 484                 // TODO: Handle the exception.
 485             }
 486         }
 487         DevicesJsonBean result = new DevicesJsonBean();
 488         result.setColumnNames(SpanConfig.getGuiFieldsNames());
 489         result.setNodeData(spanConfigs);
 490         return result;
 491     }
 492
 493     @RequestMapping(value = "/nodeports")
 494     @ResponseBody
 495     public Map<String, Object> getNodePorts(HttpServletRequest request, @RequestParam(required = false) String container) {
 496         String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
 497         ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 498                 .getInstance(ISwitchManager.class, containerName, this);
 499         if (switchManager == null)
 500             return null;
 501
 502         Map<String, Object> nodes = new HashMap<String, Object>();
 503         Map<Short, String> port;
 504
 505         for (Switch node : switchManager.getNetworkDevices()) {
 506             port = new HashMap<Short, String>(); // new port
 507             Set<NodeConnector> nodeConnectorSet = node.getNodeConnectors();
 508
 509             if (nodeConnectorSet != null)
 510                 for (NodeConnector nodeConnector : nodeConnectorSet) {
 511                     String nodeConnectorName = ((Name) switchManager
 512                             .getNodeConnectorProp(nodeConnector,
 513                                     Name.NamePropName)).getValue();
 514                     port.put((Short) nodeConnector.getID(), nodeConnectorName
 515                             + "(" + nodeConnector.getID() + ")");
 516                 }
 517
 518             nodes.put(node.getNode().toString(), port);
 519         }
 520
 521         return nodes;
 522     }
 523
 524     @RequestMapping(value = "/spanPorts/add", method = RequestMethod.GET)
 525     @ResponseBody
 526     public StatusJsonBean addSpanPort(
 527             @RequestParam("jsonData") String jsonData,
 528             HttpServletRequest request, @RequestParam(required = false) String container) {
 529         if (!authorize(UserLevel.NETWORKADMIN, request)) {
 530             return unauthorizedMessage();
 531         }
 532
 533         StatusJsonBean resultBean = new StatusJsonBean();
 534         try {
 535             Gson gson = new Gson();
 536             String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
 537             ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 538                     .getInstance(ISwitchManager.class, containerName, this);
 539             SpanConfig cfgObject = gson.fromJson(jsonData, SpanConfig.class);
 540             Status result = switchManager.addSpanConfig(cfgObject);
 541             if (result.isSuccess()) {
 542                 resultBean.setStatus(true);
 543                 resultBean.setMessage("SPAN Port added successfully");
 544             } else {
 545                 resultBean.setStatus(false);
 546                 resultBean.setMessage(result.getDescription());
 547             }
 548         } catch (Exception e) {
 549             resultBean.setStatus(false);
 550             resultBean.setMessage("Error occurred while adding span port. "
 551                     + e.getMessage());
 552         }
 553         return resultBean;
 554     }
 555
 556     @RequestMapping(value = "/spanPorts/delete", method = RequestMethod.GET)
 557     @ResponseBody
 558     public StatusJsonBean deleteSpanPorts(
 559             @RequestParam("spanPortsToDelete") String spanPortsToDelete,
 560             HttpServletRequest request, @RequestParam(required = false) String container) {
 561         if (!authorize(UserLevel.NETWORKADMIN, request)) {
 562             return unauthorizedMessage();
 563         }
 564
 565         StatusJsonBean resultBean = new StatusJsonBean();
 566         try {
 567             Gson gson = new Gson();
 568             String containerName = DaylightWebUtil.getAuthorizedContainer(request, container, this);
 569             ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 570                     .getInstance(ISwitchManager.class, containerName, this);
 571             String[] spans = spanPortsToDelete.split("###");
 572             resultBean.setStatus(true);
 573             resultBean.setMessage("SPAN Port(s) deleted successfully");
 574             for (String span : spans) {
 575                 if (!span.isEmpty()) {
 576                     SpanConfig cfgObject = gson
 577                             .fromJson(span, SpanConfig.class);
 578                     Status result = switchManager.removeSpanConfig(cfgObject);
 579                     if (!result.isSuccess()) {
 580                         resultBean.setStatus(false);
 581                         resultBean.setMessage(result.getDescription());
 582                         break;
 583                     }
 584                 }
 585             }
 586         } catch (Exception e) {
 587             resultBean.setStatus(false);
 588             resultBean.setMessage("Error occurred while deleting span port. "
 589                     + e.getMessage());
 590         }
 591         return resultBean;
 592     }
 593
 594     private String getNodeDesc(String nodeId, String containerName) {
 595         ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 596                 .getInstance(ISwitchManager.class, containerName, this);
 597         String description = "";
 598         if (switchManager != null) {
 599             description = switchManager.getNodeDescription(Node
 600                     .fromString(nodeId));
 601         }
 602         return (description.isEmpty() || description.equalsIgnoreCase("none")) ? nodeId
 603                 : description;
 604     }
 605
 606     /**
 607      * Is the operation permitted for the given level
 608      *
 609      * @param level
 610      */
 611     private boolean authorize(UserLevel level, HttpServletRequest request) {
 612         IUserManager userManager = (IUserManager) ServiceHelper
 613                 .getGlobalInstance(IUserManager.class, this);
 614         if (userManager == null) {
 615             return false;
 616         }
 617
 618         String username = request.getUserPrincipal().getName();
 619         UserLevel userLevel = userManager.getUserLevel(username);
 620         if (userLevel.toNumber() <= level.toNumber()) {
 621             return true;
 622         }
 623         return false;
 624     }
 625
 626     private StatusJsonBean unauthorizedMessage() {
 627         StatusJsonBean message = new StatusJsonBean();
 628         message.setStatus(false);
 629         message.setMessage("Operation not authorized");
 630         return message;
 631     }
 632
 633     @RequestMapping(value = "login")
 634     public String login(final HttpServletRequest request,
 635             final HttpServletResponse response) {
 636         // response.setHeader("X-Page-Location", "/login");
 637         /*
 638          * IUserManager userManager = (IUserManager) ServiceHelper
 639          * .getGlobalInstance(IUserManager.class, this); if (userManager ==
 640          * null) { return "User Manager is not available"; }
 641          *
 642          * String username = request.getUserPrincipal().getName();
 643          *
 644          *
 645          * model.addAttribute("username", username); model.addAttribute("role",
 646          * userManager.getUserLevel(username).toNumber());
 647          */
 648         return "forward:" + "/";
 649     }
 650
 651 }