opendaylight/northbound/integrationtest/src/test/java/org/opendaylight/controller/northbound/integrationtest/NorthboundIT.java

   1 package org.opendaylight.controller.northbound.integrationtest;
   2
   3 import static org.junit.Assert.assertFalse;
   4 import static org.junit.Assert.assertNotNull;
   5 import static org.ops4j.pax.exam.CoreOptions.junitBundles;
   6 import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
   7 import static org.ops4j.pax.exam.CoreOptions.options;
   8 import static org.ops4j.pax.exam.CoreOptions.systemPackages;
   9 import static org.ops4j.pax.exam.CoreOptions.systemProperty;
  10
  11 import java.io.BufferedReader;
  12 import java.io.InputStream;
  13 import java.io.InputStreamReader;
  14 import java.io.OutputStreamWriter;
  15 import java.net.HttpURLConnection;
  16 import java.net.URL;
  17 import java.nio.charset.Charset;
  18 import java.util.ArrayList;
  19 import java.util.Arrays;
  20 import java.util.HashSet;
  21 import java.util.List;
  22 import java.util.Set;
  23
  24 import javax.inject.Inject;
  25
  26 import org.apache.commons.codec.binary.Base64;
  27 import org.codehaus.jettison.json.JSONArray;
  28 import org.codehaus.jettison.json.JSONException;
  29 import org.codehaus.jettison.json.JSONObject;
  30 import org.codehaus.jettison.json.JSONTokener;
  31 import org.junit.Assert;
  32 import org.junit.Before;
  33 import org.junit.Test;
  34 import org.junit.runner.RunWith;
  35 import org.opendaylight.controller.hosttracker.IfIptoHost;
  36 import org.opendaylight.controller.sal.core.Bandwidth;
  37 import org.opendaylight.controller.sal.core.ConstructionException;
  38 import org.opendaylight.controller.sal.core.Edge;
  39 import org.opendaylight.controller.sal.core.Latency;
  40 import org.opendaylight.controller.sal.core.Node;
  41 import org.opendaylight.controller.sal.core.NodeConnector;
  42 import org.opendaylight.controller.sal.core.Property;
  43 import org.opendaylight.controller.sal.core.State;
  44 import org.opendaylight.controller.sal.core.UpdateType;
  45 import org.opendaylight.controller.sal.topology.IListenTopoUpdates;
  46 import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
  47 import org.opendaylight.controller.switchmanager.IInventoryListener;
  48 import org.opendaylight.controller.usermanager.IUserManager;
  49 import org.ops4j.pax.exam.Option;
  50 import org.ops4j.pax.exam.junit.Configuration;
  51 import org.ops4j.pax.exam.junit.PaxExam;
  52 import org.ops4j.pax.exam.util.PathUtils;
  53 import org.osgi.framework.Bundle;
  54 import org.osgi.framework.BundleContext;
  55 import org.osgi.framework.ServiceReference;
  56 import org.slf4j.Logger;
  57 import org.slf4j.LoggerFactory;
  58
  59 @RunWith(PaxExam.class)
  60 public class NorthboundIT {
  61     private final Logger log = LoggerFactory.getLogger(NorthboundIT.class);
  62     // get the OSGI bundle context
  63     @Inject
  64     private BundleContext bc;
  65     private IUserManager userManager = null;
  66     private IInventoryListener invtoryListener = null;
  67     private IListenTopoUpdates topoUpdates = null;
  68
  69     private final Boolean debugMsg = false;
  70
  71     private String stateToString(int state) {
  72         switch (state) {
  73         case Bundle.ACTIVE:
  74             return "ACTIVE";
  75         case Bundle.INSTALLED:
  76             return "INSTALLED";
  77         case Bundle.RESOLVED:
  78             return "RESOLVED";
  79         case Bundle.UNINSTALLED:
  80             return "UNINSTALLED";
  81         default:
  82             return "Not CONVERTED";
  83         }
  84     }
  85
  86     @Before
  87     public void areWeReady() {
  88         assertNotNull(bc);
  89         boolean debugit = false;
  90         Bundle b[] = bc.getBundles();
  91         for (int i = 0; i < b.length; i++) {
  92             int state = b[i].getState();
  93             if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
  94                 log.debug("Bundle:" + b[i].getSymbolicName() + " state:" + stateToString(state));
  95                 debugit = true;
  96             }
  97         }
  98         if (debugit) {
  99             log.debug("Do some debugging because some bundle is " + "unresolved");
 100         }
 101         // Assert if true, if false we are good to go!
 102         assertFalse(debugit);
 103
 104         ServiceReference r = bc.getServiceReference(IUserManager.class.getName());
 105         if (r != null) {
 106             this.userManager = (IUserManager) bc.getService(r);
 107         }
 108         // If UserManager is null, cannot login to run tests.
 109         assertNotNull(this.userManager);
 110
 111         r = bc.getServiceReference(IfIptoHost.class.getName());
 112         if (r != null) {
 113             this.invtoryListener = (IInventoryListener) bc.getService(r);
 114         }
 115
 116         // If inventoryListener is null, cannot run hosttracker tests.
 117         assertNotNull(this.invtoryListener);
 118
 119         r = bc.getServiceReference(IListenTopoUpdates.class.getName());
 120         if (r != null) {
 121             this.topoUpdates = (IListenTopoUpdates) bc.getService(r);
 122         }
 123
 124         // If topologyManager is null, cannot run topology North tests.
 125         assertNotNull(this.topoUpdates);
 126
 127     }
 128
 129     // static variable to pass response code from getJsonResult()
 130     private static Integer httpResponseCode = null;
 131
 132     private String getJsonResult(String restUrl) {
 133         return getJsonResult(restUrl, "GET", null);
 134     }
 135
 136     private String getJsonResult(String restUrl, String method) {
 137         return getJsonResult(restUrl, method, null);
 138     }
 139
 140     private String getJsonResult(String restUrl, String method, String body) {
 141         // initialize response code to indicate error
 142         httpResponseCode = 400;
 143
 144         if (debugMsg) {
 145             System.out.println("HTTP method: " + method + " url: " + restUrl.toString());
 146             if (body != null)
 147                 System.out.println("body: " + body);
 148         }
 149
 150         try {
 151             URL url = new URL(restUrl);
 152             this.userManager.getAuthorizationList();
 153             this.userManager.authenticate("admin", "admin");
 154             String authString = "admin:admin";
 155             byte[] authEncBytes = Base64.encodeBase64(authString.getBytes());
 156             String authStringEnc = new String(authEncBytes);
 157
 158             HttpURLConnection connection = (HttpURLConnection) url.openConnection();
 159             connection.setRequestMethod(method);
 160             connection.setRequestProperty("Authorization", "Basic " + authStringEnc);
 161             connection.setRequestProperty("Content-Type", "application/json");
 162             connection.setRequestProperty("Accept", "application/json");
 163
 164             if (body != null) {
 165                 connection.setDoOutput(true);
 166                 OutputStreamWriter wr = new OutputStreamWriter(connection.getOutputStream());
 167                 wr.write(body);
 168                 wr.flush();
 169             }
 170             connection.connect();
 171             connection.getContentType();
 172
 173             // Response code for success should be 2xx
 174             httpResponseCode = connection.getResponseCode();
 175             if (httpResponseCode > 299)
 176                 return httpResponseCode.toString();
 177
 178             if (debugMsg) {
 179                 System.out.println("HTTP response code: " + connection.getResponseCode());
 180                 System.out.println("HTTP response message: " + connection.getResponseMessage());
 181             }
 182
 183             InputStream is = connection.getInputStream();
 184             BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
 185             StringBuilder sb = new StringBuilder();
 186             int cp;
 187             while ((cp = rd.read()) != -1) {
 188                 sb.append((char) cp);
 189             }
 190             is.close();
 191             connection.disconnect();
 192             return sb.toString();
 193         } catch (Exception e) {
 194             return null;
 195         }
 196     }
 197
 198     private void testNodeProperties(JSONObject node, Integer nodeId, String nodeType, Integer timestamp,
 199             String timestampName, Integer actionsValue, Integer capabilitiesValue, Integer tablesValue,
 200             Integer buffersValue) throws JSONException {
 201
 202         JSONObject nodeInfo = node.getJSONObject("node");
 203         Assert.assertEquals(nodeId, (Integer) nodeInfo.getInt("id"));
 204         Assert.assertEquals(nodeType, nodeInfo.getString("type"));
 205
 206         JSONObject properties = node.getJSONObject("properties");
 207
 208         if (timestamp == null || timestampName == null) {
 209             Assert.assertFalse(properties.has("timeStamp"));
 210         } else {
 211             Assert.assertEquals(timestamp, (Integer) properties.getJSONObject("timeStamp").getInt("value"));
 212             Assert.assertEquals(timestampName, properties.getJSONObject("timeStamp").getString("name"));
 213         }
 214         if (actionsValue == null) {
 215             Assert.assertFalse(properties.has("actions"));
 216         } else {
 217             Assert.assertEquals(actionsValue, (Integer) properties.getJSONObject("actions").getInt("value"));
 218         }
 219         if (capabilitiesValue == null) {
 220             Assert.assertFalse(properties.has("capabilities"));
 221         } else {
 222             Assert.assertEquals(capabilitiesValue,
 223                     (Integer) properties.getJSONObject("capabilities").getInt("value"));
 224         }
 225         if (tablesValue == null) {
 226             Assert.assertFalse(properties.has("tables"));
 227         } else {
 228             Assert.assertEquals(tablesValue, (Integer) properties.getJSONObject("tables").getInt("value"));
 229         }
 230         if (buffersValue == null) {
 231             Assert.assertFalse(properties.has("buffers"));
 232         } else {
 233             Assert.assertEquals(buffersValue, (Integer) properties.getJSONObject("buffers").getInt("value"));
 234         }
 235     }
 236
 237     private void testNodeConnectorProperties(JSONObject nodeConnectorProperties, Integer ncId, String ncType,
 238             Integer nodeId, String nodeType, Integer state, Integer capabilities, Integer bandwidth)
 239             throws JSONException {
 240
 241         JSONObject nodeConnector = nodeConnectorProperties.getJSONObject("nodeconnector");
 242         JSONObject node = nodeConnector.getJSONObject("node");
 243         JSONObject properties = nodeConnectorProperties.getJSONObject("properties");
 244
 245         Assert.assertEquals(ncId, (Integer) nodeConnector.getInt("id"));
 246         Assert.assertEquals(ncType, nodeConnector.getString("type"));
 247         Assert.assertEquals(nodeId, (Integer) node.getInt("id"));
 248         Assert.assertEquals(nodeType, node.getString("type"));
 249         if (state == null) {
 250             Assert.assertFalse(properties.has("state"));
 251         } else {
 252             Assert.assertEquals(state, (Integer) properties.getJSONObject("state").getInt("value"));
 253         }
 254         if (capabilities == null) {
 255             Assert.assertFalse(properties.has("capabilities"));
 256         } else {
 257             Assert.assertEquals(capabilities,
 258                     (Integer) properties.getJSONObject("capabilities").getInt("value"));
 259         }
 260         if (bandwidth == null) {
 261             Assert.assertFalse(properties.has("bandwidth"));
 262         } else {
 263             Assert.assertEquals(bandwidth, (Integer) properties.getJSONObject("bandwidth").getInt("value"));
 264         }
 265
 266     }
 267
 268     @Test
 269     public void testSubnetsNorthbound() throws JSONException {
 270         System.out.println("Starting Subnets JAXB client.");
 271         String baseURL = "http://127.0.0.1:8080/controller/nb/v2/subnet/";
 272
 273         String name1 = "testSubnet1";
 274         String subnet1 = "1.1.1.1/24";
 275
 276         String name2 = "testSubnet2";
 277         String subnet2 = "2.2.2.2/24";
 278         String[] nodePorts2 = {"2/1", "2/2", "2/3", "2/4"};
 279         StringBuilder nodePortsJson2 = new StringBuilder();
 280         nodePortsJson2.append(nodePorts2[0] + "," + nodePorts2[1]  + "," + nodePorts2[2] + "," + nodePorts2[3]);
 281
 282         String name3 = "testSubnet3";
 283         String subnet3 = "3.3.3.3/24";
 284         String[] nodePorts3 = {"3/1", "3/2", "3/3"};
 285         StringBuilder nodePortsJson3 = new StringBuilder();
 286         nodePortsJson3.append(nodePorts3[0] + "," + nodePorts3[1]  + "," + nodePorts3[2]);
 287         StringBuilder nodePortsJson3_1 = new StringBuilder();
 288         nodePortsJson3_1.append(nodePortsJson3).append(",").append(nodePortsJson2);
 289
 290         // Test GET subnets in default container
 291         String result = getJsonResult(baseURL + "default/subnet/all");
 292         JSONTokener jt = new JSONTokener(result);
 293         JSONObject json = new JSONObject(jt);
 294         Assert.assertEquals("{}", result);
 295
 296         // Test GET subnet1 expecting 404
 297         result = getJsonResult(baseURL + "default/subnet/" + name1);
 298         Assert.assertEquals(404, httpResponseCode.intValue());
 299
 300         // Test POST subnet1
 301         JSONObject jo = new JSONObject().append("name", name1).append("subnet", subnet1);
 302         // execute HTTP request and verify response code
 303         result = getJsonResult(baseURL + "default/subnet/" + name1, "POST", jo.toString());
 304         Assert.assertTrue(httpResponseCode == 201);
 305
 306         // Test GET subnet1
 307         result = getJsonResult(baseURL + "default/subnet/" + name1);
 308         jt = new JSONTokener(result);
 309         json = new JSONObject(jt);
 310         Assert.assertEquals(200, httpResponseCode.intValue());
 311         Assert.assertEquals(name1, json.getString("name"));
 312         Assert.assertEquals(subnet1, json.getString("subnet"));
 313
 314         // Test POST subnet2
 315         JSONObject jo2 = new JSONObject().append("name", name2).append("subnet", subnet2);
 316         // execute HTTP request and verify response code
 317         result = getJsonResult(baseURL + "default/subnet/" + name2, "POST", jo2.toString());
 318         Assert.assertEquals(201, httpResponseCode.intValue());
 319         // Test POST nodePorts
 320         jo2.append("nodePorts", nodePortsJson2);
 321         // execute HTTP request and verify response code
 322         result = getJsonResult(baseURL + "default/subnet/" + name2 + "/node-ports", "POST", jo2.toString());
 323         Assert.assertEquals(200, httpResponseCode.intValue());
 324         // Test POST subnet3
 325         JSONObject jo3 = new JSONObject().append("name", name3).append("subnet", subnet3);
 326         // execute HTTP request and verify response code
 327         result = getJsonResult(baseURL + "default/subnet/" + name3, "POST", jo3.toString());
 328         Assert.assertEquals(201, httpResponseCode.intValue());
 329         // Test POST nodePorts
 330         jo3.append("nodePorts", nodePortsJson3);
 331         // execute HTTP request and verify response code
 332         result = getJsonResult(baseURL + "default/subnet/" + name3 + "/node-ports", "POST", jo3.toString());
 333         Assert.assertEquals(200, httpResponseCode.intValue());
 334         // Test PUT nodePorts
 335         jo3.remove("nodePorts");
 336         jo3.append("nodePorts", nodePortsJson3_1);
 337         result = getJsonResult(baseURL + "default/subnet/" + name3 + "/node-ports", "PUT", jo3.toString());
 338         Assert.assertEquals(200, httpResponseCode.intValue());
 339
 340         // Test GET all subnets in default container
 341         result = getJsonResult(baseURL + "default/subnet/all");
 342         jt = new JSONTokener(result);
 343         json = new JSONObject(jt);
 344         JSONArray subnetConfigArray = json.getJSONArray("subnetConfig");
 345         JSONObject subnetConfig;
 346         Assert.assertEquals(3, subnetConfigArray.length());
 347         for (int i = 0; i < subnetConfigArray.length(); i++) {
 348             subnetConfig = subnetConfigArray.getJSONObject(i);
 349             if (subnetConfig.getString("name").equals(name1)) {
 350                 Assert.assertEquals(subnet1, subnetConfig.getString("subnet"));
 351             } else if (subnetConfig.getString("name").equals(name2)) {
 352                 Assert.assertEquals(subnet2, subnetConfig.getString("subnet"));
 353                 String[] nodePortsGet2 = subnetConfig.getString("nodePorts").split(",");
 354                 Assert.assertEquals(nodePorts2[0], nodePortsGet2[0]);
 355                 Assert.assertEquals(nodePorts2[1], nodePortsGet2[1]);
 356                 Assert.assertEquals(nodePorts2[2], nodePortsGet2[2]);
 357                 Assert.assertEquals(nodePorts2[3], nodePortsGet2[3]);
 358             } else if (subnetConfig.getString("name").equals(name3)) {
 359                 Assert.assertEquals(subnet3, subnetConfig.getString("subnet"));
 360                 String[] nodePortsGet = subnetConfig.getString("nodePorts").split(",");
 361                 Assert.assertEquals(nodePorts3[0], nodePortsGet[0]);
 362                 Assert.assertEquals(nodePorts3[1], nodePortsGet[1]);
 363                 Assert.assertEquals(nodePorts3[2], nodePortsGet[2]);
 364                 Assert.assertEquals(nodePorts2[0], nodePortsGet[3]);
 365                 Assert.assertEquals(nodePorts2[1], nodePortsGet[4]);
 366                 Assert.assertEquals(nodePorts2[2], nodePortsGet[5]);
 367                 Assert.assertEquals(nodePorts2[3], nodePortsGet[6]);
 368             } else {
 369                 // Unexpected config name
 370                 Assert.assertTrue(false);
 371             }
 372         }
 373
 374         // Test DELETE subnet1
 375         result = getJsonResult(baseURL + "default/subnet/" + name1, "DELETE");
 376         Assert.assertEquals(204, httpResponseCode.intValue());
 377
 378         // Test GET deleted subnet1
 379         result = getJsonResult(baseURL + "default/subnet/" + name1);
 380         Assert.assertEquals(404, httpResponseCode.intValue());
 381   }
 382
 383     @Test
 384     public void testStaticRoutingNorthbound() throws JSONException {
 385         System.out.println("Starting StaticRouting JAXB client.");
 386         String baseURL = "http://127.0.0.1:8080/controller/nb/v2/staticroute/";
 387
 388         String name1 = "testRoute1";
 389         String prefix1 = "192.168.1.1/24";
 390         String nextHop1 = "0.0.0.0";
 391         String name2 = "testRoute2";
 392         String prefix2 = "192.168.1.1/16";
 393         String nextHop2 = "1.1.1.1";
 394
 395         // Test GET static routes in default container, expecting no results
 396         String result = getJsonResult(baseURL + "default");
 397         JSONTokener jt = new JSONTokener(result);
 398         JSONObject json = new JSONObject(jt);
 399         Assert.assertEquals("{}", result);
 400
 401         // Test insert static route
 402         String requestBody = "{\"name\":\"" + name1 + "\", \"prefix\":\"" + prefix1 + "\", \"nextHop\":\"" + nextHop1
 403                 + "\"}";
 404         result = getJsonResult(baseURL + "default/route/" + name1, "POST", requestBody);
 405         Assert.assertEquals(201, httpResponseCode.intValue());
 406
 407         requestBody = "{\"name\":\"" + name2 + "\", \"prefix\":\"" + prefix2 + "\", \"nextHop\":\"" + nextHop2 + "\"}";
 408         result = getJsonResult(baseURL + "default/route/" + name2, "POST", requestBody);
 409         Assert.assertEquals(201, httpResponseCode.intValue());
 410
 411         // Test Get all static routes
 412         result = getJsonResult(baseURL + "default");
 413         jt = new JSONTokener(result);
 414         json = new JSONObject(jt);
 415         JSONArray staticRoutes = json.getJSONArray("staticRoute");
 416         Assert.assertEquals(2, staticRoutes.length());
 417         JSONObject route;
 418         for (int i = 0; i < staticRoutes.length(); i++) {
 419             route = staticRoutes.getJSONObject(i);
 420             if (route.getString("name").equals(name1)) {
 421                 Assert.assertEquals(prefix1, route.getString("prefix"));
 422                 Assert.assertEquals(nextHop1, route.getString("nextHop"));
 423             } else if (route.getString("name").equals(name2)) {
 424                 Assert.assertEquals(prefix2, route.getString("prefix"));
 425                 Assert.assertEquals(nextHop2, route.getString("nextHop"));
 426             } else {
 427                 // static route has unknown name
 428                 Assert.assertTrue(false);
 429             }
 430         }
 431
 432         // Test get specific static route
 433         result = getJsonResult(baseURL + "default/route/" + name1);
 434         jt = new JSONTokener(result);
 435         json = new JSONObject(jt);
 436
 437         Assert.assertEquals(name1, json.getString("name"));
 438         Assert.assertEquals(prefix1, json.getString("prefix"));
 439         Assert.assertEquals(nextHop1, json.getString("nextHop"));
 440
 441         result = getJsonResult(baseURL + "default/route/" + name2);
 442         jt = new JSONTokener(result);
 443         json = new JSONObject(jt);
 444
 445         Assert.assertEquals(name2, json.getString("name"));
 446         Assert.assertEquals(prefix2, json.getString("prefix"));
 447         Assert.assertEquals(nextHop2, json.getString("nextHop"));
 448
 449         // Test delete static route
 450         result = getJsonResult(baseURL + "default/route/" + name1, "DELETE");
 451         Assert.assertEquals(200, httpResponseCode.intValue());
 452
 453         result = getJsonResult(baseURL + "default");
 454         jt = new JSONTokener(result);
 455         json = new JSONObject(jt);
 456         JSONObject singleStaticRoute = json.getJSONObject("staticRoute");
 457         Assert.assertEquals(name2, singleStaticRoute.getString("name"));
 458
 459     }
 460
 461     @Test
 462     public void testSwitchManager() throws JSONException {
 463         System.out.println("Starting SwitchManager JAXB client.");
 464         String baseURL = "http://127.0.0.1:8080/controller/nb/v2/switch/default/";
 465
 466         // define Node/NodeConnector attributes for test
 467         int nodeId_1 = 51966;
 468         int nodeId_2 = 3366;
 469         int nodeId_3 = 4477;
 470         int nodeConnectorId_1 = 51966;
 471         int nodeConnectorId_2 = 12;
 472         int nodeConnectorId_3 = 34;
 473         String nodeType = "STUB";
 474         String ncType = "STUB";
 475         int timestamp_1 = 100000;
 476         String timestampName_1 = "connectedSince";
 477         int actionsValue_1 = 2;
 478         int capabilitiesValue_1 = 3;
 479         int tablesValue_1 = 1;
 480         int buffersValue_1 = 1;
 481         int ncState = 1;
 482         int ncCapabilities = 1;
 483         int ncBandwidth = 1000000000;
 484
 485         // Test GET all nodes
 486
 487         String result = getJsonResult(baseURL + "nodes");
 488         JSONTokener jt = new JSONTokener(result);
 489         JSONObject json = new JSONObject(jt);
 490
 491         // Test for first node
 492         JSONObject node = getJsonInstance(json, "nodeProperties", nodeId_1);
 493         Assert.assertNotNull(node);
 494         testNodeProperties(node, nodeId_1, nodeType, timestamp_1, timestampName_1, actionsValue_1, capabilitiesValue_1,
 495                 tablesValue_1, buffersValue_1);
 496
 497         // Test 2nd node, properties of 2nd node same as first node
 498         node = getJsonInstance(json, "nodeProperties", nodeId_2);
 499         Assert.assertNotNull(node);
 500         testNodeProperties(node, nodeId_2, nodeType, timestamp_1, timestampName_1, actionsValue_1, capabilitiesValue_1,
 501                 tablesValue_1, buffersValue_1);
 502
 503         // Test 3rd node, properties of 3rd node same as first node
 504         node = getJsonInstance(json, "nodeProperties", nodeId_3);
 505         Assert.assertNotNull(node);
 506         testNodeProperties(node, nodeId_3, nodeType, timestamp_1, timestampName_1, actionsValue_1, capabilitiesValue_1,
 507                 tablesValue_1, buffersValue_1);
 508
 509         // Test GET nodeConnectors of a node
 510         // Test first node
 511         result = getJsonResult(baseURL + "node/STUB/" + nodeId_1);
 512         jt = new JSONTokener(result);
 513         json = new JSONObject(jt);
 514         JSONObject nodeConnectorProperties = json.getJSONObject("nodeConnectorProperties");
 515
 516         testNodeConnectorProperties(nodeConnectorProperties, nodeConnectorId_1, ncType, nodeId_1, nodeType, ncState,
 517                 ncCapabilities, ncBandwidth);
 518
 519         // Test second node
 520         result = getJsonResult(baseURL + "node/STUB/" + nodeId_2);
 521         jt = new JSONTokener(result);
 522         json = new JSONObject(jt);
 523         nodeConnectorProperties = json.getJSONObject("nodeConnectorProperties");
 524
 525         testNodeConnectorProperties(nodeConnectorProperties, nodeConnectorId_2, ncType, nodeId_2, nodeType, ncState,
 526                 ncCapabilities, ncBandwidth);
 527
 528         // Test third node
 529         result = getJsonResult(baseURL + "node/STUB/" + nodeId_3);
 530         jt = new JSONTokener(result);
 531         json = new JSONObject(jt);
 532
 533         nodeConnectorProperties = json.getJSONObject("nodeConnectorProperties");
 534         testNodeConnectorProperties(nodeConnectorProperties, nodeConnectorId_3, ncType, nodeId_3, nodeType, ncState,
 535                 ncCapabilities, ncBandwidth);
 536
 537         // Test add property to node
 538         // Add Tier and Description property to node1
 539         result = getJsonResult(baseURL + "node/STUB/" + nodeId_1 + "/property/tier/1001", "PUT");
 540         Assert.assertEquals(201, httpResponseCode.intValue());
 541         result = getJsonResult(baseURL + "node/STUB/" + nodeId_1 + "/property/description/node1", "PUT");
 542         Assert.assertEquals(201, httpResponseCode.intValue());
 543
 544         // Test for first node
 545         result = getJsonResult(baseURL + "nodes");
 546         jt = new JSONTokener(result);
 547         json = new JSONObject(jt);
 548         node = getJsonInstance(json, "nodeProperties", nodeId_1);
 549         Assert.assertNotNull(node);
 550         Assert.assertEquals(1001, node.getJSONObject("properties").getJSONObject("tier").getInt("value"));
 551         Assert.assertEquals("node1", node.getJSONObject("properties").getJSONObject("description").getString("value"));
 552
 553         // Test delete nodeConnector property
 554         // Delete state property of nodeconnector1
 555         result = getJsonResult(baseURL + "nodeconnector/STUB/" + nodeId_1 + "/STUB/" + nodeConnectorId_1
 556                 + "/property/state", "DELETE");
 557         Assert.assertEquals(200, httpResponseCode.intValue());
 558
 559         result = getJsonResult(baseURL + "node/STUB/" + nodeId_1);
 560         jt = new JSONTokener(result);
 561         json = new JSONObject(jt);
 562         nodeConnectorProperties = json.getJSONObject("nodeConnectorProperties");
 563
 564         testNodeConnectorProperties(nodeConnectorProperties, nodeConnectorId_1, ncType, nodeId_1, nodeType, null,
 565                 ncCapabilities, ncBandwidth);
 566
 567         // Delete capabilities property of nodeconnector2
 568         result = getJsonResult(baseURL + "nodeconnector/STUB/" + nodeId_2 + "/STUB/" + nodeConnectorId_2
 569                 + "/property/capabilities", "DELETE");
 570         Assert.assertEquals(200, httpResponseCode.intValue());
 571
 572         result = getJsonResult(baseURL + "node/STUB/" + nodeId_2);
 573         jt = new JSONTokener(result);
 574         json = new JSONObject(jt);
 575         nodeConnectorProperties = json.getJSONObject("nodeConnectorProperties");
 576
 577         testNodeConnectorProperties(nodeConnectorProperties, nodeConnectorId_2, ncType, nodeId_2, nodeType, ncState,
 578                 null, ncBandwidth);
 579
 580         // Test PUT nodeConnector property
 581         int newBandwidth = 1001;
 582
 583         // Add Name/Bandwidth property to nodeConnector1
 584         result = getJsonResult(baseURL + "nodeconnector/STUB/" + nodeId_1 + "/STUB/" + nodeConnectorId_1
 585                 + "/property/bandwidth/" + newBandwidth, "PUT");
 586         Assert.assertEquals(201, httpResponseCode.intValue());
 587
 588         result = getJsonResult(baseURL + "node/STUB/" + nodeId_1);
 589         jt = new JSONTokener(result);
 590         json = new JSONObject(jt);
 591         nodeConnectorProperties = json.getJSONObject("nodeConnectorProperties");
 592
 593         // Check for new bandwidth value, state value removed from previous
 594         // test
 595         testNodeConnectorProperties(nodeConnectorProperties, nodeConnectorId_1, ncType, nodeId_1, nodeType, null,
 596                 ncCapabilities, newBandwidth);
 597
 598     }
 599
 600     @Test
 601     public void testStatistics() throws JSONException {
 602         final String actionTypes[] = { "drop", "loopback", "flood", "floodAll", "controller", "swPath", "hwPath", "output",
 603                 "setDlSrc", "setDlDst", "setDlType", "setVlanId", "setVlanPcp", "setVlanCfi", "popVlan", "pushVlan",
 604                 "setNwSrc", "setNwDst", "setNwTos", "setTpSrc", "setTpDst" };
 605         System.out.println("Starting Statistics JAXB client.");
 606
 607         String baseURL = "http://127.0.0.1:8080/controller/nb/v2/statistics/default/";
 608
 609         String result = getJsonResult(baseURL + "flow");
 610         JSONTokener jt = new JSONTokener(result);
 611         JSONObject json = new JSONObject(jt);
 612         JSONObject flowStatistics = getJsonInstance(json, "flowStatistics", 0xCAFE);
 613         JSONObject node = flowStatistics.getJSONObject("node");
 614         // test that node was returned properly
 615         Assert.assertTrue(node.getInt("id") == 0xCAFE);
 616         Assert.assertEquals(node.getString("type"), "STUB");
 617
 618         // test that flow statistics results are correct
 619         JSONArray flowStats = flowStatistics.getJSONArray("flowStatistic");
 620         for (int i = 0; i < flowStats.length(); i++) {
 621
 622             JSONObject flowStat = flowStats.getJSONObject(i);
 623             testFlowStat(flowStat, actionTypes[i], i);
 624
 625         }
 626
 627         // for /controller/nb/v2/statistics/default/port
 628         result = getJsonResult(baseURL + "port");
 629         jt = new JSONTokener(result);
 630         json = new JSONObject(jt);
 631         JSONObject portStatistics = getJsonInstance(json, "portStatistics", 0xCAFE);
 632         JSONObject node2 = portStatistics.getJSONObject("node");
 633         // test that node was returned properly
 634         Assert.assertTrue(node2.getInt("id") == 0xCAFE);
 635         Assert.assertEquals(node2.getString("type"), "STUB");
 636
 637         // test that port statistic results are correct
 638         JSONObject portStat = portStatistics.getJSONObject("portStatistic");
 639         Assert.assertTrue(portStat.getInt("receivePackets") == 250);
 640         Assert.assertTrue(portStat.getInt("transmitPackets") == 500);
 641         Assert.assertTrue(portStat.getInt("receiveBytes") == 1000);
 642         Assert.assertTrue(portStat.getInt("transmitBytes") == 5000);
 643         Assert.assertTrue(portStat.getInt("receiveDrops") == 2);
 644         Assert.assertTrue(portStat.getInt("transmitDrops") == 50);
 645         Assert.assertTrue(portStat.getInt("receiveErrors") == 3);
 646         Assert.assertTrue(portStat.getInt("transmitErrors") == 10);
 647         Assert.assertTrue(portStat.getInt("receiveFrameError") == 5);
 648         Assert.assertTrue(portStat.getInt("receiveOverRunError") == 6);
 649         Assert.assertTrue(portStat.getInt("receiveCrcError") == 1);
 650         Assert.assertTrue(portStat.getInt("collisionCount") == 4);
 651
 652         // test for getting one specific node's stats
 653         result = getJsonResult(baseURL + "flow/node/STUB/51966");
 654         jt = new JSONTokener(result);
 655         json = new JSONObject(jt);
 656         node = json.getJSONObject("node");
 657         // test that node was returned properly
 658         Assert.assertTrue(node.getInt("id") == 0xCAFE);
 659         Assert.assertEquals(node.getString("type"), "STUB");
 660
 661         // test that flow statistics results are correct
 662         flowStats = json.getJSONArray("flowStatistic");
 663         for (int i = 0; i < flowStats.length(); i++) {
 664             JSONObject flowStat = flowStats.getJSONObject(i);
 665             testFlowStat(flowStat, actionTypes[i], i);
 666         }
 667
 668         result = getJsonResult(baseURL + "port/node/STUB/51966");
 669         jt = new JSONTokener(result);
 670         json = new JSONObject(jt);
 671         node2 = json.getJSONObject("node");
 672         // test that node was returned properly
 673         Assert.assertTrue(node2.getInt("id") == 0xCAFE);
 674         Assert.assertEquals(node2.getString("type"), "STUB");
 675
 676         // test that port statistic results are correct
 677         portStat = json.getJSONObject("portStatistic");
 678         Assert.assertTrue(portStat.getInt("receivePackets") == 250);
 679         Assert.assertTrue(portStat.getInt("transmitPackets") == 500);
 680         Assert.assertTrue(portStat.getInt("receiveBytes") == 1000);
 681         Assert.assertTrue(portStat.getInt("transmitBytes") == 5000);
 682         Assert.assertTrue(portStat.getInt("receiveDrops") == 2);
 683         Assert.assertTrue(portStat.getInt("transmitDrops") == 50);
 684         Assert.assertTrue(portStat.getInt("receiveErrors") == 3);
 685         Assert.assertTrue(portStat.getInt("transmitErrors") == 10);
 686         Assert.assertTrue(portStat.getInt("receiveFrameError") == 5);
 687         Assert.assertTrue(portStat.getInt("receiveOverRunError") == 6);
 688         Assert.assertTrue(portStat.getInt("receiveCrcError") == 1);
 689         Assert.assertTrue(portStat.getInt("collisionCount") == 4);
 690     }
 691
 692     private void testFlowStat(JSONObject flowStat, String actionType, int actIndex) throws JSONException {
 693         Assert.assertTrue(flowStat.getInt("tableId") == 1);
 694         Assert.assertTrue(flowStat.getInt("durationSeconds") == 40);
 695         Assert.assertTrue(flowStat.getInt("durationNanoseconds") == 400);
 696         Assert.assertTrue(flowStat.getInt("packetCount") == 200);
 697         Assert.assertTrue(flowStat.getInt("byteCount") == 100);
 698
 699         // test that flow information is correct
 700         JSONObject flow = flowStat.getJSONObject("flow");
 701         Assert.assertTrue(flow.getInt("priority") == (3500 + actIndex));
 702         Assert.assertTrue(flow.getInt("idleTimeout") == 1000);
 703         Assert.assertTrue(flow.getInt("hardTimeout") == 2000);
 704         Assert.assertTrue(flow.getInt("id") == 12345);
 705
 706         JSONObject match = (flow.getJSONObject("match").getJSONObject("matchField"));
 707         Assert.assertTrue(match.getString("type").equals("NW_DST"));
 708         Assert.assertTrue(match.getString("value").equals("1.1.1.1"));
 709
 710         JSONObject act = flow.getJSONObject("actions");
 711         Assert.assertTrue(act.getString("@type").equals(actionType));
 712
 713         if (act.getString("@type").equals("output")) {
 714             JSONObject port = act.getJSONObject("port");
 715             JSONObject port_node = port.getJSONObject("node");
 716             Assert.assertTrue(port.getInt("id") == 51966);
 717             Assert.assertTrue(port.getString("type").equals("STUB"));
 718             Assert.assertTrue(port_node.getInt("id") == 51966);
 719             Assert.assertTrue(port_node.getString("type").equals("STUB"));
 720         }
 721
 722         if (act.getString("@type").equals("setDlSrc")) {
 723             byte srcMatch[] = { (byte) 5, (byte) 4, (byte) 3, (byte) 2, (byte) 1 };
 724             String src = act.getString("address");
 725             byte srcBytes[] = new byte[5];
 726             srcBytes[0] = Byte.parseByte(src.substring(0, 2));
 727             srcBytes[1] = Byte.parseByte(src.substring(2, 4));
 728             srcBytes[2] = Byte.parseByte(src.substring(4, 6));
 729             srcBytes[3] = Byte.parseByte(src.substring(6, 8));
 730             srcBytes[4] = Byte.parseByte(src.substring(8, 10));
 731             Assert.assertTrue(Arrays.equals(srcBytes, srcMatch));
 732         }
 733
 734         if (act.getString("@type").equals("setDlDst")) {
 735             byte dstMatch[] = { (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5 };
 736             String dst = act.getString("address");
 737             byte dstBytes[] = new byte[5];
 738             dstBytes[0] = Byte.parseByte(dst.substring(0, 2));
 739             dstBytes[1] = Byte.parseByte(dst.substring(2, 4));
 740             dstBytes[2] = Byte.parseByte(dst.substring(4, 6));
 741             dstBytes[3] = Byte.parseByte(dst.substring(6, 8));
 742             dstBytes[4] = Byte.parseByte(dst.substring(8, 10));
 743             Assert.assertTrue(Arrays.equals(dstBytes, dstMatch));
 744         }
 745         if (act.getString("@type").equals("setDlType"))
 746             Assert.assertTrue(act.getInt("dlType") == 10);
 747         if (act.getString("@type").equals("setVlanId"))
 748             Assert.assertTrue(act.getInt("vlanId") == 2);
 749         if (act.getString("@type").equals("setVlanPcp"))
 750             Assert.assertTrue(act.getInt("pcp") == 3);
 751         if (act.getString("@type").equals("setVlanCfi"))
 752             Assert.assertTrue(act.getInt("cfi") == 1);
 753
 754         if (act.getString("@type").equals("setNwSrc"))
 755             Assert.assertTrue(act.getString("address").equals("2.2.2.2"));
 756         if (act.getString("@type").equals("setNwDst"))
 757             Assert.assertTrue(act.getString("address").equals("1.1.1.1"));
 758
 759         if (act.getString("@type").equals("pushVlan")) {
 760             int head = act.getInt("VlanHeader");
 761             // parsing vlan header
 762             int id = head & 0xfff;
 763             int cfi = (head >> 12) & 0x1;
 764             int pcp = (head >> 13) & 0x7;
 765             int tag = (head >> 16) & 0xffff;
 766             Assert.assertTrue(id == 1234);
 767             Assert.assertTrue(cfi == 1);
 768             Assert.assertTrue(pcp == 1);
 769             Assert.assertTrue(tag == 0x8100);
 770         }
 771         if (act.getString("@type").equals("setNwTos"))
 772             Assert.assertTrue(act.getInt("tos") == 16);
 773         if (act.getString("@type").equals("setTpSrc"))
 774             Assert.assertTrue(act.getInt("port") == 4201);
 775         if (act.getString("@type").equals("setTpDst"))
 776             Assert.assertTrue(act.getInt("port") == 8080);
 777     }
 778
 779     @Test
 780     public void testFlowProgrammer() throws JSONException {
 781         System.out.println("Starting FlowProgrammer JAXB client.");
 782         String baseURL = "http://127.0.0.1:8080/controller/nb/v2/flow/default/";
 783         // Attempt to get a flow that doesn't exit. Should return 404
 784         // status.
 785         String result = getJsonResult(baseURL + "node/STUB/51966/static-flow/test1", "GET");
 786         Assert.assertTrue(result.equals("404"));
 787
 788         // test add flow1
 789         String fc = "{\"dynamic\":\"false\", \"name\":\"test1\", \"node\":{\"id\":\"51966\",\"type\":\"STUB\"}, \"actions\":[\"DROP\"]}";
 790         result = getJsonResult(baseURL + "node/STUB/51966/static-flow/test1", "PUT", fc);
 791         Assert.assertTrue(httpResponseCode == 201);
 792
 793         // test get returns flow that was added.
 794         result = getJsonResult(baseURL + "node/STUB/51966/static-flow/test1", "GET");
 795         // check that result came out fine.
 796         Assert.assertTrue(httpResponseCode == 200);
 797         JSONTokener jt = new JSONTokener(result);
 798         JSONObject json = new JSONObject(jt);
 799         Assert.assertEquals(json.getString("name"), "test1");
 800         Assert.assertEquals(json.getString("actions"), "DROP");
 801         Assert.assertEquals(json.getString("installInHw"), "true");
 802         JSONObject node = json.getJSONObject("node");
 803         Assert.assertEquals(node.getString("type"), "STUB");
 804         Assert.assertEquals(node.getString("id"), "51966");
 805         // test adding same flow again fails due to repeat name..return 409
 806         // code
 807         result = getJsonResult(baseURL + "node/STUB/51966/static-flow/test1", "PUT", fc);
 808         Assert.assertTrue(result.equals("409"));
 809
 810         fc = "{\"dynamic\":\"false\", \"name\":\"test2\", \"node\":{\"id\":\"51966\",\"type\":\"STUB\"}, \"actions\":[\"DROP\"]}";
 811         result = getJsonResult(baseURL + "node/STUB/51966/static-flow/test2", "PUT", fc);
 812         // test should return 409 for error due to same flow being added.
 813         Assert.assertTrue(result.equals("409"));
 814
 815         // add second flow that's different
 816         fc = "{\"dynamic\":\"false\", \"name\":\"test2\", \"nwSrc\":\"1.1.1.1\", \"node\":{\"id\":\"51966\",\"type\":\"STUB\"}, \"actions\":[\"DROP\"]}";
 817         result = getJsonResult(baseURL + "node/STUB/51966/static-flow/test2", "PUT", fc);
 818         Assert.assertTrue(httpResponseCode == 201);
 819
 820         // check that request returns both flows given node.
 821         result = getJsonResult(baseURL + "node/STUB/51966/", "GET");
 822         jt = new JSONTokener(result);
 823         json = new JSONObject(jt);
 824         Assert.assertTrue(json.get("flowConfig") instanceof JSONArray);
 825         JSONArray ja = json.getJSONArray("flowConfig");
 826         Integer count = ja.length();
 827         Assert.assertTrue(count == 2);
 828
 829         // check that request returns both flows given just container.
 830         result = getJsonResult(baseURL);
 831         jt = new JSONTokener(result);
 832         json = new JSONObject(jt);
 833         Assert.assertTrue(json.get("flowConfig") instanceof JSONArray);
 834         ja = json.getJSONArray("flowConfig");
 835         count = ja.length();
 836         Assert.assertTrue(count == 2);
 837
 838         // delete a flow, check that it's no longer in list.
 839         result = getJsonResult(baseURL + "node/STUB/51966/static-flow/test2", "DELETE");
 840         Assert.assertTrue(httpResponseCode == 200);
 841
 842         result = getJsonResult(baseURL + "node/STUB/51966/static-flow/test2", "GET");
 843         Assert.assertTrue(result.equals("404"));
 844     }
 845
 846     // method to extract a JSONObject with specified node ID from a JSONObject
 847     // that may contain an array of JSONObjects
 848     // This is specifically written for statistics manager northbound REST
 849     // interface
 850     // array_name should be either "flowStatistics" or "portStatistics"
 851     private JSONObject getJsonInstance(JSONObject json, String array_name, Integer nodeId) throws JSONException {
 852         JSONObject result = null;
 853         if (json.get(array_name) instanceof JSONArray) {
 854             JSONArray json_array = json.getJSONArray(array_name);
 855             for (int i = 0; i < json_array.length(); i++) {
 856                 result = json_array.getJSONObject(i);
 857                 Integer nid = result.getJSONObject("node").getInt("id");
 858                 if (nid.equals(nodeId))
 859                     break;
 860             }
 861         } else {
 862             result = json.getJSONObject(array_name);
 863             Integer nid = result.getJSONObject("node").getInt("id");
 864             if (!nid.equals(nodeId))
 865                 result = null;
 866         }
 867         return result;
 868     }
 869
 870     // a class to construct query parameter for HTTP request
 871     private class QueryParameter {
 872         StringBuilder queryString = null;
 873
 874         // constructor
 875         QueryParameter(String key, String value) {
 876             queryString = new StringBuilder();
 877             queryString.append("?").append(key).append("=").append(value);
 878         }
 879
 880         // method to add more query parameter
 881         QueryParameter add(String key, String value) {
 882             this.queryString.append("&").append(key).append("=").append(value);
 883             return this;
 884         }
 885
 886         // method to get the query parameter string
 887         String getString() {
 888             return this.queryString.toString();
 889         }
 890
 891     }
 892
 893     @Test
 894     public void testHostTracker() throws JSONException {
 895
 896         System.out.println("Starting HostTracker JAXB client.");
 897
 898         // setup 2 host models for @POST method
 899         // 1st host
 900         String networkAddress_1 = "192.168.0.8";
 901         String dataLayerAddress_1 = "11:22:33:44:55:66";
 902         String nodeType_1 = "STUB";
 903         Integer nodeId_1 = 3366;
 904         String nodeConnectorType_1 = "STUB";
 905         Integer nodeConnectorId_1 = 12;
 906         String vlan_1 = "4";
 907
 908         // 2nd host
 909         String networkAddress_2 = "10.1.1.1";
 910         String dataLayerAddress_2 = "1A:2B:3C:4D:5E:6F";
 911         String nodeType_2 = "STUB";
 912         Integer nodeId_2 = 4477;
 913         String nodeConnectorType_2 = "STUB";
 914         Integer nodeConnectorId_2 = 34;
 915         String vlan_2 = "0";
 916
 917         String baseURL = "http://127.0.0.1:8080/controller/nb/v2/host/default";
 918
 919         // test PUT method: addHost()
 920         JSONObject fc_json = new JSONObject();
 921         fc_json.put("dataLayerAddress", dataLayerAddress_1);
 922         fc_json.put("nodeType", nodeType_1);
 923         fc_json.put("nodeId", nodeId_1);
 924         fc_json.put("nodeConnectorType", nodeType_1);
 925         fc_json.put("nodeConnectorId", nodeConnectorId_1.toString());
 926         fc_json.put("vlan", vlan_1);
 927         fc_json.put("staticHost", "true");
 928         fc_json.put("networkAddress", networkAddress_1);
 929
 930         String result = getJsonResult(baseURL + "/" + networkAddress_1, "PUT", fc_json.toString());
 931         Assert.assertTrue(httpResponseCode == 201);
 932
 933         fc_json = new JSONObject();
 934         fc_json.put("dataLayerAddress", dataLayerAddress_2);
 935         fc_json.put("nodeType", nodeType_2);
 936         fc_json.put("nodeId", nodeId_2);
 937         fc_json.put("nodeConnectorType", nodeType_2);
 938         fc_json.put("nodeConnectorId", nodeConnectorId_2.toString());
 939         fc_json.put("vlan", vlan_2);
 940         fc_json.put("staticHost", "true");
 941         fc_json.put("networkAddress", networkAddress_2);
 942
 943         result = getJsonResult(baseURL + "/" + networkAddress_2 , "PUT", fc_json.toString());
 944         Assert.assertTrue(httpResponseCode == 201);
 945
 946         // define variables for decoding returned strings
 947         String networkAddress;
 948         JSONObject host_jo, dl_jo, nc_jo, node_jo;
 949
 950         // the two hosts should be in inactive host DB
 951         // test GET method: getInactiveHosts()
 952         result = getJsonResult(baseURL + "/inactive", "GET");
 953         Assert.assertTrue(httpResponseCode == 200);
 954
 955         JSONTokener jt = new JSONTokener(result);
 956         JSONObject json = new JSONObject(jt);
 957         // there should be at least two hosts in the DB
 958         Assert.assertTrue(json.get("hostConfig") instanceof JSONArray);
 959         JSONArray ja = json.getJSONArray("hostConfig");
 960         Integer count = ja.length();
 961         Assert.assertTrue(count == 2);
 962
 963         for (int i = 0; i < count; i++) {
 964             host_jo = ja.getJSONObject(i);
 965             networkAddress = host_jo.getString("networkAddress");
 966             if (networkAddress.equalsIgnoreCase(networkAddress_1)) {
 967                 Assert.assertTrue(host_jo.getString("dataLayerAddress").equalsIgnoreCase(dataLayerAddress_1));
 968                 Assert.assertTrue(host_jo.getString("nodeConnectorType").equalsIgnoreCase(nodeConnectorType_1));
 969                 Assert.assertTrue(host_jo.getInt("nodeConnectorId") == nodeConnectorId_1);
 970                 Assert.assertTrue(host_jo.getString("nodeType").equalsIgnoreCase(nodeType_1));
 971                 Assert.assertTrue(host_jo.getInt("nodeId") == nodeId_1);
 972                 Assert.assertTrue(host_jo.getString("vlan").equalsIgnoreCase(vlan_1));
 973                 Assert.assertTrue(host_jo.getBoolean("staticHost"));
 974             } else if (networkAddress.equalsIgnoreCase(networkAddress_2)) {
 975                 Assert.assertTrue(host_jo.getString("dataLayerAddress").equalsIgnoreCase(dataLayerAddress_2));
 976                 Assert.assertTrue(host_jo.getString("nodeConnectorType").equalsIgnoreCase(nodeConnectorType_2));
 977                 Assert.assertTrue(host_jo.getInt("nodeConnectorId") == nodeConnectorId_2);
 978                 Assert.assertTrue(host_jo.getString("nodeType").equalsIgnoreCase(nodeType_2));
 979                 Assert.assertTrue(host_jo.getInt("nodeId") == nodeId_2);
 980                 Assert.assertTrue(host_jo.getString("vlan").equalsIgnoreCase(vlan_2));
 981                 Assert.assertTrue(host_jo.getBoolean("staticHost"));
 982             } else {
 983                 Assert.assertTrue(false);
 984             }
 985         }
 986
 987         // test GET method: getActiveHosts() - no host expected
 988         result = getJsonResult(baseURL, "GET");
 989         Assert.assertTrue(httpResponseCode == 200);
 990
 991         jt = new JSONTokener(result);
 992         json = new JSONObject(jt);
 993         Assert.assertFalse(hostInJson(json, networkAddress_1));
 994         Assert.assertFalse(hostInJson(json, networkAddress_2));
 995
 996         // put the 1st host into active host DB
 997         Node nd;
 998         NodeConnector ndc;
 999         try {
1000             nd = new Node(nodeType_1, nodeId_1);
1001             ndc = new NodeConnector(nodeConnectorType_1, nodeConnectorId_1, nd);
1002             this.invtoryListener.notifyNodeConnector(ndc, UpdateType.ADDED, null);
1003         } catch (ConstructionException e) {
1004             ndc = null;
1005             nd = null;
1006         }
1007
1008         // verify the host shows up in active host DB
1009
1010         result = getJsonResult(baseURL, "GET");
1011         Assert.assertTrue(httpResponseCode == 200);
1012
1013         jt = new JSONTokener(result);
1014         json = new JSONObject(jt);
1015
1016         Assert.assertTrue(hostInJson(json, networkAddress_1));
1017
1018         // test GET method for getHostDetails()
1019
1020         result = getJsonResult(baseURL + "/" + networkAddress_1, "GET");
1021         Assert.assertTrue(httpResponseCode == 200);
1022
1023         jt = new JSONTokener(result);
1024         json = new JSONObject(jt);
1025
1026         Assert.assertFalse(json.length() == 0);
1027
1028         Assert.assertTrue(json.getString("dataLayerAddress").equalsIgnoreCase(dataLayerAddress_1));
1029         Assert.assertTrue(json.getString("nodeConnectorType").equalsIgnoreCase(nodeConnectorType_1));
1030         Assert.assertTrue(json.getInt("nodeConnectorId") == nodeConnectorId_1);
1031         Assert.assertTrue(json.getString("nodeType").equalsIgnoreCase(nodeType_1));
1032         Assert.assertTrue(json.getInt("nodeId") == nodeId_1);
1033         Assert.assertTrue(json.getString("vlan").equalsIgnoreCase(vlan_1));
1034         Assert.assertTrue(json.getBoolean("staticHost"));
1035
1036         // test DELETE method for deleteFlow()
1037
1038         result = getJsonResult(baseURL + "/" + networkAddress_1, "DELETE");
1039         Assert.assertTrue(httpResponseCode == 200);
1040
1041         // verify host_1 removed from active host DB
1042         // test GET method: getActiveHosts() - no host expected
1043
1044         result = getJsonResult(baseURL, "GET");
1045         Assert.assertTrue(httpResponseCode == 200);
1046
1047         jt = new JSONTokener(result);
1048         json = new JSONObject(jt);
1049
1050         Assert.assertFalse(hostInJson(json, networkAddress_1));
1051
1052     }
1053
1054     private Boolean hostInJson(JSONObject json, String hostIp) throws JSONException {
1055         // input JSONObject may be empty
1056         if (json.length() == 0) {
1057             return false;
1058         }
1059         if (json.get("hostConfig") instanceof JSONArray) {
1060             JSONArray ja = json.getJSONArray("hostConfig");
1061             for (int i = 0; i < ja.length(); i++) {
1062                 String na = ja.getJSONObject(i).getString("networkAddress");
1063                 if (na.equalsIgnoreCase(hostIp))
1064                     return true;
1065             }
1066             return false;
1067         } else {
1068             JSONObject ja = json.getJSONObject("hostConfig");
1069             String na = ja.getString("networkAddress");
1070             return (na.equalsIgnoreCase(hostIp)) ? true : false;
1071         }
1072     }
1073
1074     @Test
1075     public void testTopology() throws JSONException, ConstructionException {
1076         System.out.println("Starting Topology JAXB client.");
1077         String baseURL = "http://127.0.0.1:8080/controller/nb/v2/topology/default";
1078
1079         // === test GET method for getTopology()
1080         short state_1 = State.EDGE_UP, state_2 = State.EDGE_DOWN;
1081         long bw_1 = Bandwidth.BW10Gbps, bw_2 = Bandwidth.BW100Mbps;
1082         long lat_1 = Latency.LATENCY100ns, lat_2 = Latency.LATENCY1ms;
1083         String nodeType = "STUB";
1084         String nodeConnType = "STUB";
1085         int headNC1_nodeId = 1, headNC1_nodeConnId = 11;
1086         int tailNC1_nodeId = 2, tailNC1_nodeConnId = 22;
1087         int headNC2_nodeId = 2, headNC2_nodeConnId = 21;
1088         int tailNC2_nodeId = 1, tailNC2_nodeConnId = 12;
1089
1090         List<TopoEdgeUpdate> topoedgeupdateList = new ArrayList<TopoEdgeUpdate>();
1091         NodeConnector headnc1 = new NodeConnector(nodeConnType, headNC1_nodeConnId, new Node(nodeType, headNC1_nodeId));
1092         NodeConnector tailnc1 = new NodeConnector(nodeConnType, tailNC1_nodeConnId, new Node(nodeType, tailNC1_nodeId));
1093         Edge e1 = new Edge(tailnc1, headnc1);
1094         Set<Property> props_1 = new HashSet<Property>();
1095         props_1.add(new State(state_1));
1096         props_1.add(new Bandwidth(bw_1));
1097         props_1.add(new Latency(lat_1));
1098         TopoEdgeUpdate teu1 = new TopoEdgeUpdate(e1, props_1, UpdateType.ADDED);
1099         topoedgeupdateList.add(teu1);
1100
1101         NodeConnector headnc2 = new NodeConnector(nodeConnType, headNC2_nodeConnId, new Node(nodeType, headNC2_nodeId));
1102         NodeConnector tailnc2 = new NodeConnector(nodeConnType, tailNC2_nodeConnId, new Node(nodeType, tailNC2_nodeId));
1103         Edge e2 = new Edge(tailnc2, headnc2);
1104         Set<Property> props_2 = new HashSet<Property>();
1105         props_2.add(new State(state_2));
1106         props_2.add(new Bandwidth(bw_2));
1107         props_2.add(new Latency(lat_2));
1108
1109         TopoEdgeUpdate teu2 = new TopoEdgeUpdate(e2, props_2, UpdateType.ADDED);
1110         topoedgeupdateList.add(teu2);
1111
1112         topoUpdates.edgeUpdate(topoedgeupdateList);
1113
1114         // HTTP request
1115         String result = getJsonResult(baseURL, "GET");
1116         Assert.assertTrue(httpResponseCode == 200);
1117         if (debugMsg) {
1118             System.out.println("Get Topology: " + result);
1119         }
1120
1121         // returned data must be an array of edges
1122         JSONTokener jt = new JSONTokener(result);
1123         JSONObject json = new JSONObject(jt);
1124         Assert.assertTrue(json.get("edgeProperties") instanceof JSONArray);
1125         JSONArray ja = json.getJSONArray("edgeProperties");
1126
1127         for (int i = 0; i < ja.length(); i++) {
1128             JSONObject edgeProp = ja.getJSONObject(i);
1129             JSONObject edge = edgeProp.getJSONObject("edge");
1130             JSONObject tailNC = edge.getJSONObject("tailNodeConnector");
1131             JSONObject tailNode = tailNC.getJSONObject("node");
1132
1133             JSONObject headNC = edge.getJSONObject("headNodeConnector");
1134             JSONObject headNode = headNC.getJSONObject("node");
1135             JSONObject Props = edgeProp.getJSONObject("properties");
1136             JSONObject bandw = Props.getJSONObject("bandwidth");
1137             JSONObject stt = Props.getJSONObject("state");
1138             JSONObject ltc = Props.getJSONObject("latency");
1139
1140             if (headNC.getInt("id") == headNC1_nodeConnId) {
1141                 Assert.assertEquals(headNode.getString("type"), nodeType);
1142                 Assert.assertEquals(headNode.getLong("id"), headNC1_nodeId);
1143                 Assert.assertEquals(headNC.getString("type"), nodeConnType);
1144                 Assert.assertEquals(tailNode.getString("type"),nodeType);
1145                 Assert.assertEquals(tailNode.getString("type"), nodeConnType);
1146                 Assert.assertEquals(tailNC.getLong("id"), tailNC1_nodeConnId);
1147                 Assert.assertEquals(bandw.getLong("value"), bw_1);
1148                 Assert.assertTrue((short) stt.getInt("value") == state_1);
1149                 Assert.assertEquals(ltc.getLong("value"), lat_1);
1150             } else if (headNC.getInt("id") == headNC2_nodeConnId) {
1151                 Assert.assertEquals(headNode.getString("type"),nodeType);
1152                 Assert.assertEquals(headNode.getLong("id"), headNC2_nodeId);
1153                 Assert.assertEquals(headNC.getString("type"), nodeConnType);
1154                 Assert.assertEquals(tailNode.getString("type"), nodeType);
1155                 Assert.assertTrue(tailNode.getInt("id") == tailNC2_nodeId);
1156                 Assert.assertEquals(tailNC.getString("type"), nodeConnType);
1157                 Assert.assertEquals(tailNC.getLong("id"), tailNC2_nodeConnId);
1158                 Assert.assertEquals(bandw.getLong("value"), bw_2);
1159                 Assert.assertTrue((short) stt.getInt("value") == state_2);
1160                 Assert.assertEquals(ltc.getLong("value"), lat_2);
1161             }
1162         }
1163
1164         // === test POST method for addUserLink()
1165         // define 2 sample nodeConnectors for user link configuration tests
1166         String nodeType_1 = "STUB";
1167         Integer nodeId_1 = 3366;
1168         String nodeConnectorType_1 = "STUB";
1169         Integer nodeConnectorId_1 = 12;
1170
1171         String nodeType_2 = "STUB";
1172         Integer nodeId_2 = 4477;
1173         String nodeConnectorType_2 = "STUB";
1174         Integer nodeConnectorId_2 = 34;
1175
1176         JSONObject jo = new JSONObject()
1177                 .append("name", "userLink_1")
1178                 .append("srcNodeConnector",
1179                         nodeConnectorType_1 + "|" + nodeConnectorId_1 + "@" + nodeType_1 + "|" + nodeId_1)
1180                 .append("dstNodeConnector",
1181                         nodeConnectorType_2 + "|" + nodeConnectorId_2 + "@" + nodeType_2 + "|" + nodeId_2);
1182         // execute HTTP request and verify response code
1183         result = getJsonResult(baseURL + "/user-link", "PUT", jo.toString());
1184         Assert.assertTrue(httpResponseCode == 201);
1185
1186         // === test GET method for getUserLinks()
1187         result = getJsonResult(baseURL + "/user-link", "GET");
1188         Assert.assertTrue(httpResponseCode == 200);
1189         if (debugMsg) {
1190             System.out.println("result:" + result);
1191         }
1192
1193         jt = new JSONTokener(result);
1194         json = new JSONObject(jt);
1195
1196         // should have at least one object returned
1197         Assert.assertFalse(json.length() == 0);
1198         JSONObject userlink = new JSONObject();
1199
1200         if (json.get("userLinks") instanceof JSONArray) {
1201             ja = json.getJSONArray("userLinks");
1202             int i;
1203             for (i = 0; i < ja.length(); i++) {
1204                 userlink = ja.getJSONObject(i);
1205                 if (userlink.getString("name").equalsIgnoreCase("userLink_1"))
1206                     break;
1207             }
1208             Assert.assertFalse(i == ja.length());
1209         } else {
1210             userlink = json.getJSONObject("userLinks");
1211             Assert.assertTrue(userlink.getString("name").equalsIgnoreCase("userLink_1"));
1212         }
1213
1214         String[] level_1, level_2;
1215         level_1 = userlink.getString("srcNodeConnector").split("\\@");
1216         level_2 = level_1[0].split("\\|");
1217         Assert.assertTrue(level_2[0].equalsIgnoreCase(nodeConnectorType_1));
1218         Assert.assertTrue(Integer.parseInt(level_2[1]) == nodeConnectorId_1);
1219         level_2 = level_1[1].split("\\|");
1220         Assert.assertTrue(level_2[0].equalsIgnoreCase(nodeType_1));
1221         Assert.assertTrue(Integer.parseInt(level_2[1]) == nodeId_1);
1222         level_1 = userlink.getString("dstNodeConnector").split("\\@");
1223         level_2 = level_1[0].split("\\|");
1224         Assert.assertTrue(level_2[0].equalsIgnoreCase(nodeConnectorType_2));
1225         Assert.assertTrue(Integer.parseInt(level_2[1]) == nodeConnectorId_2);
1226         level_2 = level_1[1].split("\\|");
1227         Assert.assertTrue(level_2[0].equalsIgnoreCase(nodeType_2));
1228         Assert.assertTrue(Integer.parseInt(level_2[1]) == nodeId_2);
1229
1230         // === test DELETE method for deleteUserLink()
1231         String userName = "userLink_1";
1232         result = getJsonResult(baseURL + "/user-link/" + userName, "DELETE");
1233         Assert.assertTrue(httpResponseCode == 200);
1234
1235         // execute another getUserLinks() request to verify that userLink_1 is
1236         // removed
1237         result = getJsonResult(baseURL + "/user-link", "GET");
1238         Assert.assertTrue(httpResponseCode == 200);
1239         if (debugMsg) {
1240             System.out.println("result:" + result);
1241         }
1242         jt = new JSONTokener(result);
1243         json = new JSONObject(jt);
1244
1245         if (json.length() != 0) {
1246             if (json.get("userLinks") instanceof JSONArray) {
1247                 ja = json.getJSONArray("userLinks");
1248                 for (int i = 0; i < ja.length(); i++) {
1249                     userlink = ja.getJSONObject(i);
1250                     Assert.assertFalse(userlink.getString("name").equalsIgnoreCase("userLink_1"));
1251                 }
1252             } else {
1253                 userlink = json.getJSONObject("userLinks");
1254                 Assert.assertFalse(userlink.getString("name").equalsIgnoreCase("userLink_1"));
1255             }
1256         }
1257     }
1258
1259     // Configure the OSGi container
1260     @Configuration
1261     public Option[] config() {
1262         return options(
1263                 //
1264                 systemProperty("logback.configurationFile").value(
1265                         "file:" + PathUtils.getBaseDir() + "/src/test/resources/logback.xml"),
1266                 // To start OSGi console for inspection remotely
1267                 systemProperty("osgi.console").value("2401"),
1268                 systemProperty("org.eclipse.gemini.web.tomcat.config.path").value(
1269                         PathUtils.getBaseDir() + "/src/test/resources/tomcat-server.xml"),
1270
1271                 // setting default level. Jersey bundles will need to be started
1272                 // earlier.
1273                 systemProperty("osgi.bundles.defaultStartLevel").value("4"),
1274
1275                 // Set the systemPackages (used by clustering)
1276                 systemPackages("sun.reflect", "sun.reflect.misc", "sun.misc"),
1277                 mavenBundle("javax.servlet", "servlet-api", "2.5"),
1278
1279                 mavenBundle("org.slf4j", "jcl-over-slf4j", "1.7.2"),
1280                 mavenBundle("org.slf4j", "slf4j-api", "1.7.2"),
1281                 mavenBundle("org.slf4j", "log4j-over-slf4j", "1.7.2"),
1282                 mavenBundle("ch.qos.logback", "logback-core", "1.0.9"),
1283                 mavenBundle("ch.qos.logback", "logback-classic", "1.0.9"),
1284                 mavenBundle("org.apache.commons", "commons-lang3", "3.1"),
1285                 mavenBundle("org.apache.felix", "org.apache.felix.dependencymanager", "3.1.0"),
1286
1287                 // the plugin stub to get data for the tests
1288                 mavenBundle("org.opendaylight.controller", "protocol_plugins.stub", "0.4.0-SNAPSHOT"),
1289
1290                 // List all the opendaylight modules
1291                 mavenBundle("org.opendaylight.controller", "configuration", "0.4.0-SNAPSHOT"),
1292                 mavenBundle("org.opendaylight.controller", "configuration.implementation", "0.4.0-SNAPSHOT"),
1293                 mavenBundle("org.opendaylight.controller", "containermanager", "0.4.0-SNAPSHOT"),
1294                 mavenBundle("org.opendaylight.controller", "containermanager.implementation", "0.4.0-SNAPSHOT"),
1295                 mavenBundle("org.opendaylight.controller", "clustering.services", "0.4.0-SNAPSHOT"),
1296                 mavenBundle("org.opendaylight.controller", "clustering.services-implementation", "0.4.0-SNAPSHOT"),
1297                 mavenBundle("org.opendaylight.controller", "security", "0.4.0-SNAPSHOT").noStart(),
1298                 mavenBundle("org.opendaylight.controller", "sal", "0.5.0-SNAPSHOT"),
1299                 mavenBundle("org.opendaylight.controller", "sal.implementation", "0.4.0-SNAPSHOT"),
1300                 mavenBundle("org.opendaylight.controller", "sal.connection", "0.1.0-SNAPSHOT"),
1301                 mavenBundle("org.opendaylight.controller", "sal.connection.implementation", "0.1.0-SNAPSHOT"),
1302                 mavenBundle("org.opendaylight.controller", "switchmanager", "0.5.0-SNAPSHOT"),
1303                 mavenBundle("org.opendaylight.controller", "connectionmanager", "0.1.0-SNAPSHOT"),
1304                 mavenBundle("org.opendaylight.controller", "connectionmanager.implementation", "0.1.0-SNAPSHOT"),
1305                 mavenBundle("org.opendaylight.controller", "switchmanager.implementation", "0.4.0-SNAPSHOT"),
1306                 mavenBundle("org.opendaylight.controller", "forwardingrulesmanager", "0.4.0-SNAPSHOT"),
1307                 mavenBundle("org.opendaylight.controller", "forwardingrulesmanager.implementation", "0.4.0-SNAPSHOT"),
1308                 mavenBundle("org.opendaylight.controller", "statisticsmanager", "0.4.0-SNAPSHOT"),
1309                 mavenBundle("org.opendaylight.controller", "statisticsmanager.implementation", "0.4.0-SNAPSHOT"),
1310                 mavenBundle("org.opendaylight.controller", "arphandler", "0.4.0-SNAPSHOT"),
1311                 mavenBundle("org.opendaylight.controller", "hosttracker", "0.4.0-SNAPSHOT"),
1312                 mavenBundle("org.opendaylight.controller", "hosttracker.implementation", "0.4.0-SNAPSHOT"),
1313                 mavenBundle("org.opendaylight.controller", "arphandler", "0.4.0-SNAPSHOT"),
1314                 mavenBundle("org.opendaylight.controller", "routing.dijkstra_implementation", "0.4.0-SNAPSHOT"),
1315                 mavenBundle("org.opendaylight.controller", "topologymanager", "0.4.0-SNAPSHOT"),
1316                 mavenBundle("org.opendaylight.controller", "usermanager", "0.4.0-SNAPSHOT"),
1317                 mavenBundle("org.opendaylight.controller", "usermanager.implementation", "0.4.0-SNAPSHOT"),
1318                 mavenBundle("org.opendaylight.controller", "logging.bridge", "0.4.0-SNAPSHOT"),
1319                 mavenBundle("org.opendaylight.controller", "clustering.test", "0.4.0-SNAPSHOT"),
1320                 mavenBundle("org.opendaylight.controller", "forwarding.staticrouting", "0.4.0-SNAPSHOT"),
1321
1322                 // Northbound bundles
1323                 mavenBundle("org.opendaylight.controller", "commons.northbound", "0.4.0-SNAPSHOT"),
1324                 mavenBundle("org.opendaylight.controller", "forwarding.staticrouting.northbound", "0.4.0-SNAPSHOT"),
1325                 mavenBundle("org.opendaylight.controller", "statistics.northbound", "0.4.0-SNAPSHOT"),
1326                 mavenBundle("org.opendaylight.controller", "topology.northbound", "0.4.0-SNAPSHOT"),
1327                 mavenBundle("org.opendaylight.controller", "hosttracker.northbound", "0.4.0-SNAPSHOT"),
1328                 mavenBundle("org.opendaylight.controller", "switchmanager.northbound", "0.4.0-SNAPSHOT"),
1329                 mavenBundle("org.opendaylight.controller", "flowprogrammer.northbound", "0.4.0-SNAPSHOT"),
1330                 mavenBundle("org.opendaylight.controller", "subnets.northbound", "0.4.0-SNAPSHOT"),
1331
1332                 mavenBundle("org.codehaus.jackson", "jackson-mapper-asl", "1.9.8"),
1333                 mavenBundle("org.codehaus.jackson", "jackson-core-asl", "1.9.8"),
1334                 mavenBundle("org.codehaus.jackson", "jackson-jaxrs", "1.9.8"),
1335                 mavenBundle("org.codehaus.jettison", "jettison", "1.3.3"),
1336
1337                 mavenBundle("commons-io", "commons-io", "2.3"),
1338
1339                 mavenBundle("commons-fileupload", "commons-fileupload", "1.2.2"),
1340
1341                 mavenBundle("equinoxSDK381", "javax.servlet", "3.0.0.v201112011016"),
1342                 mavenBundle("equinoxSDK381", "javax.servlet.jsp", "2.2.0.v201112011158"),
1343                 mavenBundle("equinoxSDK381", "org.eclipse.equinox.ds", "1.4.0.v20120522-1841"),
1344                 mavenBundle("orbit", "javax.xml.rpc", "1.1.0.v201005080400"),
1345                 mavenBundle("equinoxSDK381", "org.eclipse.equinox.util", "1.0.400.v20120522-2049"),
1346                 mavenBundle("equinoxSDK381", "org.eclipse.osgi.services", "3.3.100.v20120522-1822"),
1347                 mavenBundle("equinoxSDK381", "org.apache.felix.gogo.command", "0.8.0.v201108120515"),
1348                 mavenBundle("equinoxSDK381", "org.apache.felix.gogo.runtime", "0.8.0.v201108120515"),
1349                 mavenBundle("equinoxSDK381", "org.apache.felix.gogo.shell", "0.8.0.v201110170705"),
1350                 mavenBundle("equinoxSDK381", "org.eclipse.equinox.cm", "1.0.400.v20120522-1841"),
1351                 mavenBundle("equinoxSDK381", "org.eclipse.equinox.console", "1.0.0.v20120522-1841"),
1352                 mavenBundle("equinoxSDK381", "org.eclipse.equinox.launcher", "1.3.0.v20120522-1813"),
1353
1354                 mavenBundle("geminiweb", "org.eclipse.gemini.web.core", "2.2.0.RELEASE"),
1355                 mavenBundle("geminiweb", "org.eclipse.gemini.web.extender", "2.2.0.RELEASE"),
1356                 mavenBundle("geminiweb", "org.eclipse.gemini.web.tomcat", "2.2.0.RELEASE"),
1357                 mavenBundle("geminiweb", "org.eclipse.virgo.kernel.equinox.extensions", "3.6.0.RELEASE").noStart(),
1358                 mavenBundle("geminiweb", "org.eclipse.virgo.util.common", "3.6.0.RELEASE"),
1359                 mavenBundle("geminiweb", "org.eclipse.virgo.util.io", "3.6.0.RELEASE"),
1360                 mavenBundle("geminiweb", "org.eclipse.virgo.util.math", "3.6.0.RELEASE"),
1361                 mavenBundle("geminiweb", "org.eclipse.virgo.util.osgi", "3.6.0.RELEASE"),
1362                 mavenBundle("geminiweb", "org.eclipse.virgo.util.osgi.manifest", "3.6.0.RELEASE"),
1363                 mavenBundle("geminiweb", "org.eclipse.virgo.util.parser.manifest", "3.6.0.RELEASE"),
1364
1365                 mavenBundle("org.apache.felix", "org.apache.felix.dependencymanager", "3.1.0"),
1366                 mavenBundle("org.apache.felix", "org.apache.felix.dependencymanager.shell", "3.0.1"),
1367
1368                 mavenBundle("com.google.code.gson", "gson", "2.1"),
1369                 mavenBundle("org.jboss.spec.javax.transaction", "jboss-transaction-api_1.1_spec", "1.0.1.Final"),
1370                 mavenBundle("org.apache.felix", "org.apache.felix.fileinstall", "3.1.6"),
1371                 mavenBundle("org.apache.commons", "commons-lang3", "3.1"),
1372                 mavenBundle("commons-codec", "commons-codec"),
1373                 mavenBundle("virgomirror", "org.eclipse.jdt.core.compiler.batch", "3.8.0.I20120518-2145"),
1374                 mavenBundle("eclipselink", "javax.persistence", "2.0.4.v201112161009"),
1375                 mavenBundle("eclipselink", "javax.resource", "1.5.0.v200906010428"),
1376
1377                 mavenBundle("orbit", "javax.activation", "1.1.0.v201211130549"),
1378                 mavenBundle("orbit", "javax.annotation", "1.1.0.v201209060031"),
1379                 mavenBundle("orbit", "javax.ejb", "3.1.1.v201204261316"),
1380                 mavenBundle("orbit", "javax.el", "2.2.0.v201108011116"),
1381                 mavenBundle("orbit", "javax.mail.glassfish", "1.4.1.v201108011116"),
1382                 mavenBundle("orbit", "javax.xml.rpc", "1.1.0.v201005080400"),
1383                 mavenBundle("orbit", "org.apache.catalina", "7.0.32.v201211201336"),
1384                 // these are bundle fragments that can't be started on its own
1385                 mavenBundle("orbit", "org.apache.catalina.ha", "7.0.32.v201211201952").noStart(),
1386                 mavenBundle("orbit", "org.apache.catalina.tribes", "7.0.32.v201211201952").noStart(),
1387                 mavenBundle("orbit", "org.apache.coyote", "7.0.32.v201211201952").noStart(),
1388                 mavenBundle("orbit", "org.apache.jasper", "7.0.32.v201211201952").noStart(),
1389
1390                 mavenBundle("orbit", "org.apache.el", "7.0.32.v201211081135"),
1391                 mavenBundle("orbit", "org.apache.juli.extras", "7.0.32.v201211081135"),
1392                 mavenBundle("orbit", "org.apache.tomcat.api", "7.0.32.v201211081135"),
1393                 mavenBundle("orbit", "org.apache.tomcat.util", "7.0.32.v201211201952").noStart(),
1394                 mavenBundle("orbit", "javax.servlet.jsp.jstl", "1.2.0.v201105211821"),
1395                 mavenBundle("orbit", "javax.servlet.jsp.jstl.impl", "1.2.0.v201210211230"),
1396
1397                 mavenBundle("org.ops4j.pax.exam", "pax-exam-container-native"),
1398                 mavenBundle("org.ops4j.pax.exam", "pax-exam-junit4"),
1399                 mavenBundle("org.ops4j.pax.exam", "pax-exam-link-mvn"),
1400                 mavenBundle("org.ops4j.pax.url", "pax-url-aether"),
1401
1402                 mavenBundle("org.springframework", "org.springframework.asm", "3.1.3.RELEASE"),
1403                 mavenBundle("org.springframework", "org.springframework.aop", "3.1.3.RELEASE"),
1404                 mavenBundle("org.springframework", "org.springframework.context", "3.1.3.RELEASE"),
1405                 mavenBundle("org.springframework", "org.springframework.context.support", "3.1.3.RELEASE"),
1406                 mavenBundle("org.springframework", "org.springframework.core", "3.1.3.RELEASE"),
1407                 mavenBundle("org.springframework", "org.springframework.beans", "3.1.3.RELEASE"),
1408                 mavenBundle("org.springframework", "org.springframework.expression", "3.1.3.RELEASE"),
1409                 mavenBundle("org.springframework", "org.springframework.web", "3.1.3.RELEASE"),
1410
1411                 mavenBundle("org.aopalliance", "com.springsource.org.aopalliance", "1.0.0"),
1412                 mavenBundle("org.springframework", "org.springframework.web.servlet", "3.1.3.RELEASE"),
1413                 mavenBundle("org.springframework.security", "spring-security-config", "3.1.3.RELEASE"),
1414                 mavenBundle("org.springframework.security", "spring-security-core", "3.1.3.RELEASE"),
1415                 mavenBundle("org.springframework.security", "spring-security-web", "3.1.3.RELEASE"),
1416                 mavenBundle("org.springframework.security", "spring-security-taglibs", "3.1.3.RELEASE"),
1417                 mavenBundle("org.springframework", "org.springframework.transaction", "3.1.3.RELEASE"),
1418
1419                 mavenBundle("org.ow2.chameleon.management", "chameleon-mbeans", "1.0.0"),
1420                 mavenBundle("org.opendaylight.controller.thirdparty", "net.sf.jung2", "2.0.1-SNAPSHOT"),
1421                 mavenBundle("org.opendaylight.controller.thirdparty", "com.sun.jersey.jersey-servlet", "1.17-SNAPSHOT"),
1422                 mavenBundle("org.opendaylight.controller.thirdparty", "org.apache.catalina.filters.CorsFilter",
1423                             "7.0.42-SNAPSHOT").noStart(),
1424
1425                 // Jersey needs to be started before the northbound application
1426                 // bundles, using a lower start level
1427                 mavenBundle("com.sun.jersey", "jersey-client", "1.17"),
1428                 mavenBundle("com.sun.jersey", "jersey-server", "1.17").startLevel(2),
1429                 mavenBundle("com.sun.jersey", "jersey-core", "1.17").startLevel(2),
1430                 mavenBundle("com.sun.jersey", "jersey-json", "1.17").startLevel(2), junitBundles());
1431     }
1432
1433 }