1 package org.opendaylight.controller.northbound.integrationtest;
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;
11 import java.util.ArrayList;
12 import java.util.Arrays;
13 import java.util.HashMap;
14 import java.util.HashSet;
15 import java.util.List;
19 import javax.inject.Inject;
21 import org.apache.commons.codec.binary.Base64;
22 import org.codehaus.jettison.json.JSONArray;
23 import org.codehaus.jettison.json.JSONException;
24 import org.codehaus.jettison.json.JSONObject;
25 import org.codehaus.jettison.json.JSONTokener;
26 import org.junit.Assert;
27 import org.junit.Before;
28 import org.junit.Test;
29 import org.junit.runner.RunWith;
30 import org.opendaylight.controller.commons.httpclient.HTTPClient;
31 import org.opendaylight.controller.commons.httpclient.HTTPRequest;
32 import org.opendaylight.controller.commons.httpclient.HTTPResponse;
33 import org.opendaylight.controller.hosttracker.IfIptoHost;
34 import org.opendaylight.controller.sal.core.Bandwidth;
35 import org.opendaylight.controller.sal.core.ConstructionException;
36 import org.opendaylight.controller.sal.core.Edge;
37 import org.opendaylight.controller.sal.core.Latency;
38 import org.opendaylight.controller.sal.core.Node;
39 import org.opendaylight.controller.sal.core.NodeConnector;
40 import org.opendaylight.controller.sal.core.Property;
41 import org.opendaylight.controller.sal.core.State;
42 import org.opendaylight.controller.sal.core.UpdateType;
43 import org.opendaylight.controller.sal.topology.IListenTopoUpdates;
44 import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
45 import org.opendaylight.controller.switchmanager.IInventoryListener;
46 import org.opendaylight.controller.usermanager.IUserManager;
47 import org.ops4j.pax.exam.Option;
48 import org.ops4j.pax.exam.Configuration;
49 import org.ops4j.pax.exam.junit.PaxExam;
50 import org.ops4j.pax.exam.util.PathUtils;
51 import org.osgi.framework.Bundle;
52 import org.osgi.framework.BundleContext;
53 import org.osgi.framework.ServiceReference;
54 import org.slf4j.Logger;
55 import org.slf4j.LoggerFactory;
57 @RunWith(PaxExam.class)
58 public class NorthboundIT {
59 private final Logger log = LoggerFactory.getLogger(NorthboundIT.class);
60 // get the OSGI bundle context
62 private BundleContext bc;
63 private IUserManager userManager = null;
64 private IInventoryListener invtoryListener = null;
65 private IListenTopoUpdates topoUpdates = null;
67 private final Boolean debugMsg = false;
69 private String stateToString(int state) {
73 case Bundle.INSTALLED:
77 case Bundle.UNINSTALLED:
80 return "Not CONVERTED";
85 public void areWeReady() {
87 boolean debugit = false;
88 Bundle b[] = bc.getBundles();
89 for (Bundle element : b) {
90 int state = element.getState();
91 if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
92 log.debug("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state));
97 log.debug("Do some debugging because some bundle is " + "unresolved");
99 // Assert if true, if false we are good to go!
100 assertFalse(debugit);
102 ServiceReference r = bc.getServiceReference(IUserManager.class.getName());
104 this.userManager = (IUserManager) bc.getService(r);
106 // If UserManager is null, cannot login to run tests.
107 assertNotNull(this.userManager);
109 r = bc.getServiceReference(IfIptoHost.class.getName());
111 this.invtoryListener = (IInventoryListener) bc.getService(r);
114 // If inventoryListener is null, cannot run hosttracker tests.
115 assertNotNull(this.invtoryListener);
117 r = bc.getServiceReference(IListenTopoUpdates.class.getName());
119 this.topoUpdates = (IListenTopoUpdates) bc.getService(r);
122 // If topologyManager is null, cannot run topology North tests.
123 assertNotNull(this.topoUpdates);
127 // static variable to pass response code from getJsonResult()
128 private static Integer httpResponseCode = null;
130 private String getJsonResult(String restUrl) {
131 return getJsonResult(restUrl, "GET", null);
134 private String getJsonResult(String restUrl, String method) {
135 return getJsonResult(restUrl, method, null);
138 private String getJsonResult(String restUrl, String method, String body) {
139 // initialize response code to indicate error
140 httpResponseCode = 400;
143 System.out.println("HTTP method: " + method + " url: " + restUrl.toString());
145 System.out.println("body: " + body);
150 this.userManager.getAuthorizationList();
151 this.userManager.authenticate("admin", "admin");
152 HTTPRequest request = new HTTPRequest();
154 request.setUri(restUrl);
155 request.setMethod(method);
156 request.setTimeout(0); // HostTracker doesn't respond
157 // within default timeout during
158 // IT so setting an indefinite
159 // timeout till the issue is
162 Map<String, List<String>> headers = new HashMap<String, List<String>>();
163 String authString = "admin:admin";
164 byte[] authEncBytes = Base64.encodeBase64(authString.getBytes());
165 String authStringEnc = new String(authEncBytes);
166 List<String> header = new ArrayList<String>();
167 header.add("Basic "+authStringEnc);
168 headers.put("Authorization", header);
169 header = new ArrayList<String>();
170 header.add("application/json");
171 headers.put("Accept", header);
172 request.setHeaders(headers);
173 request.setContentType("application/json");
175 request.setEntity(body);
178 HTTPResponse response = HTTPClient.sendRequest(request);
180 // Response code for success should be 2xx
181 httpResponseCode = response.getStatus();
182 if (httpResponseCode > 299) {
183 return httpResponseCode.toString();
187 System.out.println("HTTP response code: " + response.getStatus());
188 System.out.println("HTTP response message: " + response.getEntity());
191 return response.getEntity();
192 } catch (Exception e) {
200 private void testNodeProperties(JSONObject node, Integer nodeId, String nodeType, Integer timestamp,
201 String timestampName, Integer actionsValue, Integer capabilitiesValue, Integer tablesValue,
202 Integer buffersValue) throws JSONException {
204 JSONObject nodeInfo = node.getJSONObject("node");
205 Assert.assertEquals(nodeId, (Integer) nodeInfo.getInt("id"));
206 Assert.assertEquals(nodeType, nodeInfo.getString("type"));
208 JSONObject properties = node.getJSONObject("properties");
210 if (timestamp == null || timestampName == null) {
211 Assert.assertFalse(properties.has("timeStamp"));
213 Assert.assertEquals(timestamp, (Integer) properties.getJSONObject("timeStamp").getInt("value"));
214 Assert.assertEquals(timestampName, properties.getJSONObject("timeStamp").getString("name"));
216 if (actionsValue == null) {
217 Assert.assertFalse(properties.has("actions"));
219 Assert.assertEquals(actionsValue, (Integer) properties.getJSONObject("actions").getInt("value"));
221 if (capabilitiesValue == null) {
222 Assert.assertFalse(properties.has("capabilities"));
224 Assert.assertEquals(capabilitiesValue,
225 (Integer) properties.getJSONObject("capabilities").getInt("value"));
227 if (tablesValue == null) {
228 Assert.assertFalse(properties.has("tables"));
230 Assert.assertEquals(tablesValue, (Integer) properties.getJSONObject("tables").getInt("value"));
232 if (buffersValue == null) {
233 Assert.assertFalse(properties.has("buffers"));
235 Assert.assertEquals(buffersValue, (Integer) properties.getJSONObject("buffers").getInt("value"));
239 private void testNodeConnectorProperties(JSONObject nodeConnectorProperties, Integer ncId, String ncType,
240 Integer nodeId, String nodeType, Integer state, Integer capabilities, Integer bandwidth)
241 throws JSONException {
243 JSONObject nodeConnector = nodeConnectorProperties.getJSONObject("nodeconnector");
244 JSONObject node = nodeConnector.getJSONObject("node");
245 JSONObject properties = nodeConnectorProperties.getJSONObject("properties");
247 Assert.assertEquals(ncId, (Integer) nodeConnector.getInt("id"));
248 Assert.assertEquals(ncType, nodeConnector.getString("type"));
249 Assert.assertEquals(nodeId, (Integer) node.getInt("id"));
250 Assert.assertEquals(nodeType, node.getString("type"));
252 Assert.assertFalse(properties.has("state"));
254 Assert.assertEquals(state, (Integer) properties.getJSONObject("state").getInt("value"));
256 if (capabilities == null) {
257 Assert.assertFalse(properties.has("capabilities"));
259 Assert.assertEquals(capabilities,
260 (Integer) properties.getJSONObject("capabilities").getInt("value"));
262 if (bandwidth == null) {
263 Assert.assertFalse(properties.has("bandwidth"));
265 Assert.assertEquals(bandwidth, (Integer) properties.getJSONObject("bandwidth").getInt("value"));
270 public void testSubnetsNorthbound() throws JSONException, ConstructionException {
271 System.out.println("Starting Subnets JAXB client.");
272 String baseURL = "http://127.0.0.1:8080/controller/nb/v2/subnetservice/";
274 String name1 = "testSubnet1";
275 String subnet1 = "1.1.1.1/24";
277 String name2 = "testSubnet2";
278 String subnet2 = "2.2.2.2/24";
280 String name3 = "testSubnet3";
281 String subnet3 = "3.3.3.3/24";
284 * Create the node connector string list for the two subnets as:
285 * portList2 = {"OF|1@OF|00:00:00:00:00:00:00:02", "OF|2@OF|00:00:00:00:00:00:00:02", "OF|3@OF|00:00:00:00:00:00:00:02", "OF|4@OF|00:00:00:00:00:00:00:02"};
286 * portList3 = {"OF|1@OF|00:00:00:00:00:00:00:03", "OF|2@OF|00:00:00:00:00:00:00:03", "OF|3@OF|00:00:00:00:00:00:00:03"};
288 Node node2 = new Node(Node.NodeIDType.OPENFLOW, 2L);
289 List<String> portList2 = new ArrayList<String>();
290 NodeConnector nc21 = new NodeConnector(NodeConnector.NodeConnectorIDType.OPENFLOW, (short)1, node2);
291 NodeConnector nc22 = new NodeConnector(NodeConnector.NodeConnectorIDType.OPENFLOW, (short)2, node2);
292 NodeConnector nc23 = new NodeConnector(NodeConnector.NodeConnectorIDType.OPENFLOW, (short)3, node2);
293 NodeConnector nc24 = new NodeConnector(NodeConnector.NodeConnectorIDType.OPENFLOW, (short)3, node2);
294 portList2.add(nc21.toString());
295 portList2.add(nc22.toString());
296 portList2.add(nc23.toString());
297 portList2.add(nc24.toString());
299 List<String> portList3 = new ArrayList<String>();
300 Node node3 = new Node(Node.NodeIDType.OPENFLOW, 3L);
301 NodeConnector nc31 = new NodeConnector(NodeConnector.NodeConnectorIDType.OPENFLOW, (short)1, node3);
302 NodeConnector nc32 = new NodeConnector(NodeConnector.NodeConnectorIDType.OPENFLOW, (short)2, node3);
303 NodeConnector nc33 = new NodeConnector(NodeConnector.NodeConnectorIDType.OPENFLOW, (short)3, node3);
304 portList3.add(nc31.toString());
305 portList3.add(nc32.toString());
306 portList3.add(nc33.toString());
308 // Test GET subnets in default container
309 String result = getJsonResult(baseURL + "default/subnets");
310 JSONTokener jt = new JSONTokener(result);
311 JSONObject json = new JSONObject(jt);
312 JSONArray subnetConfigs = json.getJSONArray("subnetConfig");
313 Assert.assertEquals(subnetConfigs.length(), 0);
315 // Test GET subnet1 expecting 404
316 result = getJsonResult(baseURL + "default/subnet/" + name1);
317 Assert.assertEquals(404, httpResponseCode.intValue());
320 JSONObject jo = new JSONObject().put("name", name1).put("subnet", subnet1);
321 // execute HTTP request and verify response code
322 result = getJsonResult(baseURL + "default/subnet/" + name1, "PUT", jo.toString());
323 Assert.assertTrue(httpResponseCode == 201);
326 result = getJsonResult(baseURL + "default/subnet/" + name1);
327 jt = new JSONTokener(result);
328 json = new JSONObject(jt);
329 Assert.assertEquals(200, httpResponseCode.intValue());
330 Assert.assertEquals(name1, json.getString("name"));
331 Assert.assertEquals(subnet1, json.getString("subnet"));
334 JSONObject jo2 = new JSONObject().put("name", name2).put("subnet", subnet2).put("nodeConnectors", portList2);
335 // execute HTTP request and verify response code
336 result = getJsonResult(baseURL + "default/subnet/" + name2, "PUT", jo2.toString());
337 Assert.assertEquals(201, httpResponseCode.intValue());
339 JSONObject jo3 = new JSONObject().put("name", name3).put("subnet", subnet3);
340 // execute HTTP request and verify response code
341 result = getJsonResult(baseURL + "default/subnet/" + name3, "PUT", jo3.toString());
342 Assert.assertEquals(201, httpResponseCode.intValue());
343 // Test POST subnet3 (modify port list: add)
344 JSONObject jo3New = new JSONObject().put("name", name3).put("subnet", subnet3).put("nodeConnectors", portList3);
345 // execute HTTP request and verify response code
346 result = getJsonResult(baseURL + "default/subnet/" + name3, "POST", jo3New.toString());
347 Assert.assertEquals(200, httpResponseCode.intValue());
349 // Test GET all subnets in default container
350 result = getJsonResult(baseURL + "default/subnets");
351 jt = new JSONTokener(result);
352 json = new JSONObject(jt);
353 JSONArray subnetConfigArray = json.getJSONArray("subnetConfig");
354 JSONObject subnetConfig;
355 Assert.assertEquals(3, subnetConfigArray.length());
356 for (int i = 0; i < subnetConfigArray.length(); i++) {
357 subnetConfig = subnetConfigArray.getJSONObject(i);
358 if (subnetConfig.getString("name").equals(name1)) {
359 Assert.assertEquals(subnet1, subnetConfig.getString("subnet"));
360 } else if (subnetConfig.getString("name").equals(name2)) {
361 Assert.assertEquals(subnet2, subnetConfig.getString("subnet"));
362 JSONArray portListGet = subnetConfig.getJSONArray("nodeConnectors");
363 Assert.assertEquals(portList2.get(0), portListGet.get(0));
364 Assert.assertEquals(portList2.get(1), portListGet.get(1));
365 Assert.assertEquals(portList2.get(2), portListGet.get(2));
366 Assert.assertEquals(portList2.get(3), portListGet.get(3));
367 } else if (subnetConfig.getString("name").equals(name3)) {
368 Assert.assertEquals(subnet3, subnetConfig.getString("subnet"));
369 JSONArray portListGet = subnetConfig.getJSONArray("nodeConnectors");
370 Assert.assertEquals(portList3.get(0), portListGet.get(0));
371 Assert.assertEquals(portList3.get(1), portListGet.get(1));
372 Assert.assertEquals(portList3.get(2), portListGet.get(2));
374 // Unexpected config name
375 Assert.assertTrue(false);
379 // Test POST subnet2 (modify port list: remove one port only)
380 List<String> newPortList2 = new ArrayList<String>(portList2);
381 newPortList2.remove(3);
382 JSONObject jo2New = new JSONObject().put("name", name2).put("subnet", subnet2).put("nodeConnectors", newPortList2);
383 // execute HTTP request and verify response code
384 result = getJsonResult(baseURL + "default/subnet/" + name2, "POST", jo2New.toString());
385 Assert.assertEquals(200, httpResponseCode.intValue());
387 // Test GET subnet2: verify contains only the first three ports
388 result = getJsonResult(baseURL + "default/subnet/" + name2);
389 jt = new JSONTokener(result);
390 subnetConfig = new JSONObject(jt);
391 Assert.assertEquals(200, httpResponseCode.intValue());
392 JSONArray portListGet2 = subnetConfig.getJSONArray("nodeConnectors");
393 Assert.assertEquals(portList2.get(0), portListGet2.get(0));
394 Assert.assertEquals(portList2.get(1), portListGet2.get(1));
395 Assert.assertEquals(portList2.get(2), portListGet2.get(2));
396 Assert.assertTrue(portListGet2.length() == 3);
398 // Test DELETE subnet1
399 result = getJsonResult(baseURL + "default/subnet/" + name1, "DELETE");
400 Assert.assertEquals(204, httpResponseCode.intValue());
402 // Test GET deleted subnet1
403 result = getJsonResult(baseURL + "default/subnet/" + name1);
404 Assert.assertEquals(404, httpResponseCode.intValue());
406 // TEST PUT bad subnet, expect 400, validate JSON exception mapper
407 JSONObject joBad = new JSONObject().put("foo", "bar");
408 result = getJsonResult(baseURL + "default/subnet/foo", "PUT", joBad.toString());
409 Assert.assertEquals(400, httpResponseCode.intValue());
413 public void testStaticRoutingNorthbound() throws JSONException {
414 System.out.println("Starting StaticRouting JAXB client.");
415 String baseURL = "http://127.0.0.1:8080/controller/nb/v2/staticroute/";
417 String name1 = "testRoute1";
418 String prefix1 = "192.168.1.1/24";
419 String nextHop1 = "0.0.0.0";
420 String name2 = "testRoute2";
421 String prefix2 = "192.168.1.1/16";
422 String nextHop2 = "1.1.1.1";
424 // Test GET static routes in default container, expecting no results
425 String result = getJsonResult(baseURL + "default/routes");
426 JSONTokener jt = new JSONTokener(result);
427 JSONObject json = new JSONObject(jt);
428 JSONArray staticRoutes = json.getJSONArray("staticRoute");
429 Assert.assertEquals(staticRoutes.length(), 0);
431 // Test insert static route
432 String requestBody = "{\"name\":\"" + name1 + "\", \"prefix\":\"" + prefix1 + "\", \"nextHop\":\"" + nextHop1
434 result = getJsonResult(baseURL + "default/route/" + name1, "PUT", requestBody);
435 Assert.assertEquals(201, httpResponseCode.intValue());
437 requestBody = "{\"name\":\"" + name2 + "\", \"prefix\":\"" + prefix2 + "\", \"nextHop\":\"" + nextHop2 + "\"}";
438 result = getJsonResult(baseURL + "default/route/" + name2, "PUT", requestBody);
439 Assert.assertEquals(201, httpResponseCode.intValue());
441 // Test Get all static routes
442 result = getJsonResult(baseURL + "default/routes");
443 jt = new JSONTokener(result);
444 json = new JSONObject(jt);
445 JSONArray staticRouteArray = json.getJSONArray("staticRoute");
446 Assert.assertEquals(2, staticRouteArray.length());
448 for (int i = 0; i < staticRoutes.length(); i++) {
449 route = staticRoutes.getJSONObject(i);
450 if (route.getString("name").equals(name1)) {
451 Assert.assertEquals(prefix1, route.getString("prefix"));
452 Assert.assertEquals(nextHop1, route.getString("nextHop"));
453 } else if (route.getString("name").equals(name2)) {
454 Assert.assertEquals(prefix2, route.getString("prefix"));
455 Assert.assertEquals(nextHop2, route.getString("nextHop"));
457 // static route has unknown name
458 Assert.assertTrue(false);
462 // Test get specific static route
463 result = getJsonResult(baseURL + "default/route/" + name1);
464 jt = new JSONTokener(result);
465 json = new JSONObject(jt);
467 Assert.assertEquals(name1, json.getString("name"));
468 Assert.assertEquals(prefix1, json.getString("prefix"));
469 Assert.assertEquals(nextHop1, json.getString("nextHop"));
471 result = getJsonResult(baseURL + "default/route/" + name2);
472 jt = new JSONTokener(result);
473 json = new JSONObject(jt);
475 Assert.assertEquals(name2, json.getString("name"));
476 Assert.assertEquals(prefix2, json.getString("prefix"));
477 Assert.assertEquals(nextHop2, json.getString("nextHop"));
479 // Test delete static route
480 result = getJsonResult(baseURL + "default/route/" + name1, "DELETE");
481 Assert.assertEquals(204, httpResponseCode.intValue());
483 result = getJsonResult(baseURL + "default/routes");
484 jt = new JSONTokener(result);
485 json = new JSONObject(jt);
487 staticRouteArray = json.getJSONArray("staticRoute");
488 JSONObject singleStaticRoute = staticRouteArray.getJSONObject(0);
489 Assert.assertEquals(name2, singleStaticRoute.getString("name"));
494 public void testSwitchManager() throws JSONException {
495 System.out.println("Starting SwitchManager JAXB client.");
496 String baseURL = "http://127.0.0.1:8080/controller/nb/v2/switchmanager/default/";
498 // define Node/NodeConnector attributes for test
499 int nodeId_1 = 51966;
502 int nodeConnectorId_1 = 51966;
503 int nodeConnectorId_2 = 12;
504 int nodeConnectorId_3 = 34;
505 String nodeType = "STUB";
506 String ncType = "STUB";
507 int timestamp_1 = 100000;
508 String timestampName_1 = "connectedSince";
509 int actionsValue_1 = 2;
510 int capabilitiesValue_1 = 3;
511 int tablesValue_1 = 1;
512 int buffersValue_1 = 1;
514 int ncCapabilities = 1;
515 int ncBandwidth = 1000000000;
517 // Test GET all nodes
519 String result = getJsonResult(baseURL + "nodes");
520 JSONTokener jt = new JSONTokener(result);
521 JSONObject json = new JSONObject(jt);
523 // Test for first node
524 JSONObject node = getJsonInstance(json, "nodeProperties", nodeId_1);
525 Assert.assertNotNull(node);
526 testNodeProperties(node, nodeId_1, nodeType, timestamp_1, timestampName_1, actionsValue_1, capabilitiesValue_1,
527 tablesValue_1, buffersValue_1);
529 // Test 2nd node, properties of 2nd node same as first node
530 node = getJsonInstance(json, "nodeProperties", nodeId_2);
531 Assert.assertNotNull(node);
532 testNodeProperties(node, nodeId_2, nodeType, timestamp_1, timestampName_1, actionsValue_1, capabilitiesValue_1,
533 tablesValue_1, buffersValue_1);
535 // Test 3rd node, properties of 3rd node same as first node
536 node = getJsonInstance(json, "nodeProperties", nodeId_3);
537 Assert.assertNotNull(node);
538 testNodeProperties(node, nodeId_3, nodeType, timestamp_1, timestampName_1, actionsValue_1, capabilitiesValue_1,
539 tablesValue_1, buffersValue_1);
541 // Test GET nodeConnectors of a node
543 result = getJsonResult(baseURL + "node/STUB/" + nodeId_1);
544 jt = new JSONTokener(result);
545 json = new JSONObject(jt);
546 JSONArray nodeConnectorPropertiesArray = json.getJSONArray("nodeConnectorProperties");
547 JSONObject nodeConnectorProperties = nodeConnectorPropertiesArray.getJSONObject(0);
549 testNodeConnectorProperties(nodeConnectorProperties, nodeConnectorId_1, ncType, nodeId_1, nodeType, ncState,
550 ncCapabilities, ncBandwidth);
553 result = getJsonResult(baseURL + "node/STUB/" + nodeId_2);
554 jt = new JSONTokener(result);
555 json = new JSONObject(jt);
557 nodeConnectorPropertiesArray = json.getJSONArray("nodeConnectorProperties");
558 nodeConnectorProperties = nodeConnectorPropertiesArray.getJSONObject(0);
561 testNodeConnectorProperties(nodeConnectorProperties, nodeConnectorId_2, ncType, nodeId_2, nodeType, ncState,
562 ncCapabilities, ncBandwidth);
565 result = getJsonResult(baseURL + "node/STUB/" + nodeId_3);
566 jt = new JSONTokener(result);
567 json = new JSONObject(jt);
569 nodeConnectorPropertiesArray = json.getJSONArray("nodeConnectorProperties");
570 nodeConnectorProperties = nodeConnectorPropertiesArray.getJSONObject(0);
571 testNodeConnectorProperties(nodeConnectorProperties, nodeConnectorId_3, ncType, nodeId_3, nodeType, ncState,
572 ncCapabilities, ncBandwidth);
574 // Test add property to node
575 // Add Tier and Description property to node1
576 result = getJsonResult(baseURL + "node/STUB/" + nodeId_1 + "/property/tier/1001", "PUT");
577 Assert.assertEquals(201, httpResponseCode.intValue());
578 result = getJsonResult(baseURL + "node/STUB/" + nodeId_1 + "/property/description/node1", "PUT");
579 Assert.assertEquals(201, httpResponseCode.intValue());
581 // Test for first node
582 result = getJsonResult(baseURL + "nodes");
583 jt = new JSONTokener(result);
584 json = new JSONObject(jt);
585 node = getJsonInstance(json, "nodeProperties", nodeId_1);
586 Assert.assertNotNull(node);
587 Assert.assertEquals(1001, node.getJSONObject("properties").getJSONObject("tier").getInt("value"));
588 Assert.assertEquals("node1", node.getJSONObject("properties").getJSONObject("description").getString("value"));
590 // Test delete nodeConnector property
591 // Delete state property of nodeconnector1
592 result = getJsonResult(baseURL + "nodeconnector/STUB/" + nodeId_1 + "/STUB/" + nodeConnectorId_1
593 + "/property/state", "DELETE");
594 Assert.assertEquals(204, httpResponseCode.intValue());
596 result = getJsonResult(baseURL + "node/STUB/" + nodeId_1);
597 jt = new JSONTokener(result);
598 json = new JSONObject(jt);
599 nodeConnectorPropertiesArray = json.getJSONArray("nodeConnectorProperties");
600 nodeConnectorProperties = nodeConnectorPropertiesArray.getJSONObject(0);
602 testNodeConnectorProperties(nodeConnectorProperties, nodeConnectorId_1, ncType, nodeId_1, nodeType, null,
603 ncCapabilities, ncBandwidth);
605 // Delete capabilities property of nodeconnector2
606 result = getJsonResult(baseURL + "nodeconnector/STUB/" + nodeId_2 + "/STUB/" + nodeConnectorId_2
607 + "/property/capabilities", "DELETE");
608 Assert.assertEquals(204, httpResponseCode.intValue());
610 result = getJsonResult(baseURL + "node/STUB/" + nodeId_2);
611 jt = new JSONTokener(result);
612 json = new JSONObject(jt);
613 nodeConnectorPropertiesArray = json.getJSONArray("nodeConnectorProperties");
614 nodeConnectorProperties = nodeConnectorPropertiesArray.getJSONObject(0);
616 testNodeConnectorProperties(nodeConnectorProperties, nodeConnectorId_2, ncType, nodeId_2, nodeType, ncState,
619 // Test PUT nodeConnector property
620 int newBandwidth = 1001;
622 // Add Name/Bandwidth property to nodeConnector1
623 result = getJsonResult(baseURL + "nodeconnector/STUB/" + nodeId_1 + "/STUB/" + nodeConnectorId_1
624 + "/property/bandwidth/" + newBandwidth, "PUT");
625 Assert.assertEquals(201, httpResponseCode.intValue());
627 result = getJsonResult(baseURL + "node/STUB/" + nodeId_1);
628 jt = new JSONTokener(result);
629 json = new JSONObject(jt);
630 nodeConnectorPropertiesArray = json.getJSONArray("nodeConnectorProperties");
631 nodeConnectorProperties = nodeConnectorPropertiesArray.getJSONObject(0);
633 // Check for new bandwidth value, state value removed from previous
635 testNodeConnectorProperties(nodeConnectorProperties, nodeConnectorId_1, ncType, nodeId_1, nodeType, null,
636 ncCapabilities, newBandwidth);
641 public void testStatistics() throws JSONException {
642 final String actionTypes[] = { "DROP", "LOOPBACK", "FLOOD", "FLOOD_ALL", "CONTROLLER", "SW_PATH", "HW_PATH", "OUTPUT",
643 "SET_DL_SRC", "SET_DL_DST", "SET_DL_TYPE", "SET_VLAN_ID", "SET_VLAN_PCP", "SET_VLAN_CFI", "POP_VLAN", "PUSH_VLAN",
644 "SET_NW_SRC", "SET_NW_DST", "SET_NW_TOS", "SET_TP_SRC", "SET_TP_DST" };
645 System.out.println("Starting Statistics JAXB client.");
647 String baseURL = "http://127.0.0.1:8080/controller/nb/v2/statistics/default/";
649 String result = getJsonResult(baseURL + "flow");
650 JSONTokener jt = new JSONTokener(result);
651 JSONObject json = new JSONObject(jt);
652 JSONObject flowStatistics = getJsonInstance(json, "flowStatistics", 0xCAFE);
653 JSONObject node = flowStatistics.getJSONObject("node");
654 // test that node was returned properly
655 Assert.assertTrue(node.getInt("id") == 0xCAFE);
656 Assert.assertEquals(node.getString("type"), "STUB");
658 // test that flow statistics results are correct
659 JSONArray flowStats = flowStatistics.getJSONArray("flowStatistic");
660 for (int i = 0; i < flowStats.length(); i++) {
662 JSONObject flowStat = flowStats.getJSONObject(i);
663 testFlowStat(flowStat, actionTypes[i], i);
667 // for /controller/nb/v2/statistics/default/port
668 result = getJsonResult(baseURL + "port");
669 jt = new JSONTokener(result);
670 json = new JSONObject(jt);
671 JSONObject portStatistics = getJsonInstance(json, "portStatistics", 0xCAFE);
672 JSONObject node2 = portStatistics.getJSONObject("node");
673 // test that node was returned properly
674 Assert.assertTrue(node2.getInt("id") == 0xCAFE);
675 Assert.assertEquals(node2.getString("type"), "STUB");
677 // test that port statistic results are correct
678 JSONArray portStatArray = portStatistics.getJSONArray("portStatistic");
679 JSONObject portStat = portStatArray.getJSONObject(0);
680 Assert.assertTrue(portStat.getInt("receivePackets") == 250);
681 Assert.assertTrue(portStat.getInt("transmitPackets") == 500);
682 Assert.assertTrue(portStat.getInt("receiveBytes") == 1000);
683 Assert.assertTrue(portStat.getInt("transmitBytes") == 5000);
684 Assert.assertTrue(portStat.getInt("receiveDrops") == 2);
685 Assert.assertTrue(portStat.getInt("transmitDrops") == 50);
686 Assert.assertTrue(portStat.getInt("receiveErrors") == 3);
687 Assert.assertTrue(portStat.getInt("transmitErrors") == 10);
688 Assert.assertTrue(portStat.getInt("receiveFrameError") == 5);
689 Assert.assertTrue(portStat.getInt("receiveOverRunError") == 6);
690 Assert.assertTrue(portStat.getInt("receiveCrcError") == 1);
691 Assert.assertTrue(portStat.getInt("collisionCount") == 4);
693 // test for getting one specific node's stats
694 result = getJsonResult(baseURL + "flow/node/STUB/51966");
695 jt = new JSONTokener(result);
696 json = new JSONObject(jt);
697 node = json.getJSONObject("node");
698 // test that node was returned properly
699 Assert.assertTrue(node.getInt("id") == 0xCAFE);
700 Assert.assertEquals(node.getString("type"), "STUB");
702 // test that flow statistics results are correct
703 flowStats = json.getJSONArray("flowStatistic");
704 for (int i = 0; i < flowStats.length(); i++) {
705 JSONObject flowStat = flowStats.getJSONObject(i);
706 testFlowStat(flowStat, actionTypes[i], i);
709 result = getJsonResult(baseURL + "port/node/STUB/51966");
710 jt = new JSONTokener(result);
711 json = new JSONObject(jt);
712 node2 = json.getJSONObject("node");
713 // test that node was returned properly
714 Assert.assertTrue(node2.getInt("id") == 0xCAFE);
715 Assert.assertEquals(node2.getString("type"), "STUB");
717 // test that port statistic results are correct
718 portStatArray = json.getJSONArray("portStatistic");
719 portStat = portStatArray.getJSONObject(0);
721 Assert.assertTrue(portStat.getInt("receivePackets") == 250);
722 Assert.assertTrue(portStat.getInt("transmitPackets") == 500);
723 Assert.assertTrue(portStat.getInt("receiveBytes") == 1000);
724 Assert.assertTrue(portStat.getInt("transmitBytes") == 5000);
725 Assert.assertTrue(portStat.getInt("receiveDrops") == 2);
726 Assert.assertTrue(portStat.getInt("transmitDrops") == 50);
727 Assert.assertTrue(portStat.getInt("receiveErrors") == 3);
728 Assert.assertTrue(portStat.getInt("transmitErrors") == 10);
729 Assert.assertTrue(portStat.getInt("receiveFrameError") == 5);
730 Assert.assertTrue(portStat.getInt("receiveOverRunError") == 6);
731 Assert.assertTrue(portStat.getInt("receiveCrcError") == 1);
732 Assert.assertTrue(portStat.getInt("collisionCount") == 4);
735 private void testFlowStat(JSONObject flowStat, String actionType, int actIndex) throws JSONException {
736 Assert.assertTrue(flowStat.getInt("tableId") == 1);
737 Assert.assertTrue(flowStat.getInt("durationSeconds") == 40);
738 Assert.assertTrue(flowStat.getInt("durationNanoseconds") == 400);
739 Assert.assertTrue(flowStat.getInt("packetCount") == 200);
740 Assert.assertTrue(flowStat.getInt("byteCount") == 100);
742 // test that flow information is correct
743 JSONObject flow = flowStat.getJSONObject("flow");
744 Assert.assertTrue(flow.getInt("priority") == (3500 + actIndex));
745 Assert.assertTrue(flow.getInt("idleTimeout") == 1000);
746 Assert.assertTrue(flow.getInt("hardTimeout") == 2000);
747 Assert.assertTrue(flow.getInt("id") == 12345);
749 JSONArray matches = (flow.getJSONObject("match").getJSONArray("matchField"));
750 Assert.assertEquals(matches.length(), 1);
751 JSONObject match = matches.getJSONObject(0);
752 Assert.assertTrue(match.getString("type").equals("NW_DST"));
753 Assert.assertTrue(match.getString("value").equals("1.1.1.1"));
755 JSONArray actionsArray = flow.getJSONArray("actions");
756 Assert.assertEquals(actionsArray.length(), 1);
757 JSONObject act = actionsArray.getJSONObject(0);
758 Assert.assertTrue(act.getString("type").equals(actionType));
760 if (act.getString("type").equals("OUTPUT")) {
761 JSONObject port = act.getJSONObject("port");
762 JSONObject port_node = port.getJSONObject("node");
763 Assert.assertTrue(port.getInt("id") == 51966);
764 Assert.assertTrue(port.getString("type").equals("STUB"));
765 Assert.assertTrue(port_node.getInt("id") == 51966);
766 Assert.assertTrue(port_node.getString("type").equals("STUB"));
769 if (act.getString("type").equals("SET_DL_SRC")) {
770 byte srcMatch[] = { (byte) 5, (byte) 4, (byte) 3, (byte) 2, (byte) 1 };
771 String src = act.getString("address");
772 byte srcBytes[] = new byte[5];
773 srcBytes[0] = Byte.parseByte(src.substring(0, 2));
774 srcBytes[1] = Byte.parseByte(src.substring(2, 4));
775 srcBytes[2] = Byte.parseByte(src.substring(4, 6));
776 srcBytes[3] = Byte.parseByte(src.substring(6, 8));
777 srcBytes[4] = Byte.parseByte(src.substring(8, 10));
778 Assert.assertTrue(Arrays.equals(srcBytes, srcMatch));
781 if (act.getString("type").equals("SET_DL_DST")) {
782 byte dstMatch[] = { (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5 };
783 String dst = act.getString("address");
784 byte dstBytes[] = new byte[5];
785 dstBytes[0] = Byte.parseByte(dst.substring(0, 2));
786 dstBytes[1] = Byte.parseByte(dst.substring(2, 4));
787 dstBytes[2] = Byte.parseByte(dst.substring(4, 6));
788 dstBytes[3] = Byte.parseByte(dst.substring(6, 8));
789 dstBytes[4] = Byte.parseByte(dst.substring(8, 10));
790 Assert.assertTrue(Arrays.equals(dstBytes, dstMatch));
792 if (act.getString("type").equals("SET_DL_TYPE")) {
793 Assert.assertTrue(act.getInt("dlType") == 10);
795 if (act.getString("type").equals("SET_VLAN_ID")) {
796 Assert.assertTrue(act.getInt("vlanId") == 2);
798 if (act.getString("type").equals("SET_VLAN_PCP")) {
799 Assert.assertTrue(act.getInt("pcp") == 3);
801 if (act.getString("type").equals("SET_VLAN_CFI")) {
802 Assert.assertTrue(act.getInt("cfi") == 1);
805 if (act.getString("type").equals("SET_NW_SRC")) {
806 Assert.assertTrue(act.getString("address").equals("2.2.2.2"));
808 if (act.getString("type").equals("SET_NW_DST")) {
809 Assert.assertTrue(act.getString("address").equals("1.1.1.1"));
812 if (act.getString("type").equals("PUSH_VLAN")) {
813 int head = act.getInt("VlanHeader");
814 // parsing vlan header
815 int id = head & 0xfff;
816 int cfi = (head >> 12) & 0x1;
817 int pcp = (head >> 13) & 0x7;
818 int tag = (head >> 16) & 0xffff;
819 Assert.assertTrue(id == 1234);
820 Assert.assertTrue(cfi == 1);
821 Assert.assertTrue(pcp == 1);
822 Assert.assertTrue(tag == 0x8100);
824 if (act.getString("type").equals("SET_NW_TOS")) {
825 Assert.assertTrue(act.getInt("tos") == 16);
827 if (act.getString("type").equals("SET_TP_SRC")) {
828 Assert.assertTrue(act.getInt("port") == 4201);
830 if (act.getString("type").equals("SET_TP_DST")) {
831 Assert.assertTrue(act.getInt("port") == 8080);
836 public void testFlowProgrammer() throws JSONException {
837 System.out.println("Starting FlowProgrammer JAXB client.");
838 String baseURL = "http://127.0.0.1:8080/controller/nb/v2/flowprogrammer/default/";
839 // Attempt to get a flow that doesn't exit. Should return 404
841 String result = getJsonResult(baseURL + "node/STUB/51966/staticFlow/test1", "GET");
842 Assert.assertTrue(result.equals("404"));
845 String fc = "{\"name\":\"test1\", \"node\":{\"id\":\"51966\",\"type\":\"STUB\"}, \"actions\":[\"DROP\"]}";
846 result = getJsonResult(baseURL + "node/STUB/51966/staticFlow/test1", "PUT", fc);
847 Assert.assertTrue(httpResponseCode == 201);
849 // test get returns flow that was added.
850 result = getJsonResult(baseURL + "node/STUB/51966/staticFlow/test1", "GET");
851 // check that result came out fine.
852 Assert.assertTrue(httpResponseCode == 200);
853 JSONTokener jt = new JSONTokener(result);
854 JSONObject json = new JSONObject(jt);
855 Assert.assertEquals(json.getString("name"), "test1");
856 JSONArray actionsArray = json.getJSONArray("actions");
857 Assert.assertEquals(actionsArray.getString(0), "DROP");
858 Assert.assertEquals(json.getString("installInHw"), "true");
859 JSONObject node = json.getJSONObject("node");
860 Assert.assertEquals(node.getString("type"), "STUB");
861 Assert.assertEquals(node.getString("id"), "51966");
862 // test adding same flow again succeeds with a change in any field ..return Success
864 fc = "{\"name\":\"test1\", \"node\":{\"id\":\"51966\",\"type\":\"STUB\"}, \"actions\":[\"LOOPBACK\"]}";
865 result = getJsonResult(baseURL + "node/STUB/51966/staticFlow/test1", "PUT", fc);
866 Assert.assertTrue(result.equals("Success"));
868 fc = "{\"name\":\"test2\", \"node\":{\"id\":\"51966\",\"type\":\"STUB\"}, \"actions\":[\"DROP\"]}";
869 result = getJsonResult(baseURL + "node/STUB/51966/staticFlow/test2", "PUT", fc);
870 // test should return 409 for error due to same flow being added.
871 Assert.assertTrue(result.equals("409"));
873 // add second flow that's different
874 fc = "{\"name\":\"test2\", \"nwSrc\":\"1.1.1.1\", \"node\":{\"id\":\"51966\",\"type\":\"STUB\"}, \"actions\":[\"DROP\"]}";
875 result = getJsonResult(baseURL + "node/STUB/51966/staticFlow/test2", "PUT", fc);
876 Assert.assertTrue(httpResponseCode == 201);
878 // check that request returns both flows given node.
879 result = getJsonResult(baseURL + "node/STUB/51966/", "GET");
880 jt = new JSONTokener(result);
881 json = new JSONObject(jt);
882 Assert.assertTrue(json.get("flowConfig") instanceof JSONArray);
883 JSONArray ja = json.getJSONArray("flowConfig");
884 Integer count = ja.length();
885 Assert.assertTrue(count == 2);
887 // check that request returns both flows given just container.
888 result = getJsonResult(baseURL);
889 jt = new JSONTokener(result);
890 json = new JSONObject(jt);
891 Assert.assertTrue(json.get("flowConfig") instanceof JSONArray);
892 ja = json.getJSONArray("flowConfig");
894 Assert.assertTrue(count == 2);
896 // delete a flow, check that it's no longer in list.
897 result = getJsonResult(baseURL + "node/STUB/51966/staticFlow/test2", "DELETE");
898 Assert.assertTrue(httpResponseCode == 204);
900 result = getJsonResult(baseURL + "node/STUB/51966/staticFlow/test2", "GET");
901 Assert.assertTrue(result.equals("404"));
904 // method to extract a JSONObject with specified node ID from a JSONObject
905 // that may contain an array of JSONObjects
906 // This is specifically written for statistics manager northbound REST
908 // array_name should be either "flowStatistics" or "portStatistics"
909 private JSONObject getJsonInstance(JSONObject json, String array_name, Integer nodeId) throws JSONException {
910 JSONObject result = null;
911 if (json.get(array_name) instanceof JSONArray) {
912 JSONArray json_array = json.getJSONArray(array_name);
913 for (int i = 0; i < json_array.length(); i++) {
914 result = json_array.getJSONObject(i);
915 Integer nid = result.getJSONObject("node").getInt("id");
916 if (nid.equals(nodeId)) {
921 result = json.getJSONObject(array_name);
922 Integer nid = result.getJSONObject("node").getInt("id");
923 if (!nid.equals(nodeId)) {
930 // a class to construct query parameter for HTTP request
931 private class QueryParameter {
932 StringBuilder queryString = null;
935 QueryParameter(String key, String value) {
936 queryString = new StringBuilder();
937 queryString.append("?").append(key).append("=").append(value);
940 // method to add more query parameter
941 QueryParameter add(String key, String value) {
942 this.queryString.append("&").append(key).append("=").append(value);
946 // method to get the query parameter string
948 return this.queryString.toString();
954 public void testHostTracker() throws JSONException {
956 System.out.println("Starting HostTracker JAXB client.");
958 // setup 2 host models for @POST method
960 String networkAddress_1 = "192.168.0.8";
961 String dataLayerAddress_1 = "11:22:33:44:55:66";
962 String nodeType_1 = "STUB";
963 Integer nodeId_1 = 3366;
964 String nodeConnectorType_1 = "STUB";
965 Integer nodeConnectorId_1 = 12;
969 String networkAddress_2 = "10.1.1.1";
970 String dataLayerAddress_2 = "1A:2B:3C:4D:5E:6F";
971 String nodeType_2 = "STUB";
972 Integer nodeId_2 = 4477;
973 String nodeConnectorType_2 = "STUB";
974 Integer nodeConnectorId_2 = 34;
975 String vlan_2 = "123";
977 String baseURL = "http://127.0.0.1:8080/controller/nb/v2/hosttracker/default";
979 // test PUT method: addHost()
980 JSONObject fc_json = new JSONObject();
981 fc_json.put("dataLayerAddress", dataLayerAddress_1);
982 fc_json.put("nodeType", nodeType_1);
983 fc_json.put("nodeId", nodeId_1);
984 fc_json.put("nodeConnectorType", nodeType_1);
985 fc_json.put("nodeConnectorId", nodeConnectorId_1.toString());
986 fc_json.put("vlan", vlan_1);
987 fc_json.put("staticHost", "true");
988 fc_json.put("networkAddress", networkAddress_1);
990 String result = getJsonResult(baseURL + "/address/" + networkAddress_1, "PUT", fc_json.toString());
991 Assert.assertTrue(httpResponseCode == 201);
993 fc_json = new JSONObject();
994 fc_json.put("dataLayerAddress", dataLayerAddress_2);
995 fc_json.put("nodeType", nodeType_2);
996 fc_json.put("nodeId", nodeId_2);
997 fc_json.put("nodeConnectorType", nodeType_2);
998 fc_json.put("nodeConnectorId", nodeConnectorId_2.toString());
999 fc_json.put("vlan", vlan_2);
1000 fc_json.put("staticHost", "true");
1001 fc_json.put("networkAddress", networkAddress_2);
1003 result = getJsonResult(baseURL + "/address/" + networkAddress_2 , "PUT", fc_json.toString());
1004 Assert.assertTrue(httpResponseCode == 201);
1006 // define variables for decoding returned strings
1007 String networkAddress;
1010 // the two hosts should be in inactive host DB
1011 // test GET method: getInactiveHosts()
1012 result = getJsonResult(baseURL + "/hosts/inactive", "GET");
1013 Assert.assertTrue(httpResponseCode == 200);
1015 JSONTokener jt = new JSONTokener(result);
1016 JSONObject json = new JSONObject(jt);
1017 // there should be at least two hosts in the DB
1018 Assert.assertTrue(json.get("hostConfig") instanceof JSONArray);
1019 JSONArray ja = json.getJSONArray("hostConfig");
1020 Integer count = ja.length();
1021 Assert.assertTrue(count == 2);
1023 for (int i = 0; i < count; i++) {
1024 host_jo = ja.getJSONObject(i);
1025 networkAddress = host_jo.getString("networkAddress");
1026 if (networkAddress.equalsIgnoreCase(networkAddress_1)) {
1027 Assert.assertTrue(host_jo.getString("dataLayerAddress").equalsIgnoreCase(dataLayerAddress_1));
1028 Assert.assertTrue(host_jo.getString("nodeConnectorType").equalsIgnoreCase(nodeConnectorType_1));
1029 Assert.assertTrue(host_jo.getInt("nodeConnectorId") == nodeConnectorId_1);
1030 Assert.assertTrue(host_jo.getString("nodeType").equalsIgnoreCase(nodeType_1));
1031 Assert.assertTrue(host_jo.getInt("nodeId") == nodeId_1);
1032 Assert.assertTrue(host_jo.getString("vlan").equals("0"));
1033 Assert.assertTrue(host_jo.getBoolean("staticHost"));
1034 } else if (networkAddress.equalsIgnoreCase(networkAddress_2)) {
1035 Assert.assertTrue(host_jo.getString("dataLayerAddress").equalsIgnoreCase(dataLayerAddress_2));
1036 Assert.assertTrue(host_jo.getString("nodeConnectorType").equalsIgnoreCase(nodeConnectorType_2));
1037 Assert.assertTrue(host_jo.getInt("nodeConnectorId") == nodeConnectorId_2);
1038 Assert.assertTrue(host_jo.getString("nodeType").equalsIgnoreCase(nodeType_2));
1039 Assert.assertTrue(host_jo.getInt("nodeId") == nodeId_2);
1040 Assert.assertTrue(host_jo.getString("vlan").equalsIgnoreCase(vlan_2));
1041 Assert.assertTrue(host_jo.getBoolean("staticHost"));
1043 Assert.assertTrue(false);
1047 // test GET method: getActiveHosts() - no host expected
1048 result = getJsonResult(baseURL + "/hosts/active", "GET");
1049 Assert.assertTrue(httpResponseCode == 200);
1051 jt = new JSONTokener(result);
1052 json = new JSONObject(jt);
1053 Assert.assertFalse(hostInJson(json, networkAddress_1));
1054 Assert.assertFalse(hostInJson(json, networkAddress_2));
1056 // put the 1st host into active host DB
1060 nd = new Node(nodeType_1, nodeId_1);
1061 ndc = new NodeConnector(nodeConnectorType_1, nodeConnectorId_1, nd);
1062 this.invtoryListener.notifyNodeConnector(ndc, UpdateType.ADDED, null);
1063 } catch (ConstructionException e) {
1068 // verify the host shows up in active host DB
1070 result = getJsonResult(baseURL + "/hosts/active", "GET");
1071 Assert.assertTrue(httpResponseCode == 200);
1073 jt = new JSONTokener(result);
1074 json = new JSONObject(jt);
1076 Assert.assertTrue(hostInJson(json, networkAddress_1));
1078 // test GET method for getHostDetails()
1080 result = getJsonResult(baseURL + "/address/" + networkAddress_1, "GET");
1081 Assert.assertTrue(httpResponseCode == 200);
1083 jt = new JSONTokener(result);
1084 json = new JSONObject(jt);
1086 Assert.assertFalse(json.length() == 0);
1088 Assert.assertTrue(json.getString("dataLayerAddress").equalsIgnoreCase(dataLayerAddress_1));
1089 Assert.assertTrue(json.getString("nodeConnectorType").equalsIgnoreCase(nodeConnectorType_1));
1090 Assert.assertTrue(json.getInt("nodeConnectorId") == nodeConnectorId_1);
1091 Assert.assertTrue(json.getString("nodeType").equalsIgnoreCase(nodeType_1));
1092 Assert.assertTrue(json.getInt("nodeId") == nodeId_1);
1093 Assert.assertTrue(json.getString("vlan").equals("0"));
1094 Assert.assertTrue(json.getBoolean("staticHost"));
1096 // test DELETE method for deleteFlow()
1098 result = getJsonResult(baseURL + "/address/" + networkAddress_1, "DELETE");
1099 Assert.assertTrue(httpResponseCode == 204);
1101 // verify host_1 removed from active host DB
1102 // test GET method: getActiveHosts() - no host expected
1104 result = getJsonResult(baseURL + "/hosts/active", "GET");
1105 Assert.assertTrue(httpResponseCode == 200);
1107 jt = new JSONTokener(result);
1108 json = new JSONObject(jt);
1110 Assert.assertFalse(hostInJson(json, networkAddress_1));
1114 private Boolean hostInJson(JSONObject json, String hostIp) throws JSONException {
1115 // input JSONObject may be empty
1116 if (json.length() == 0) {
1119 if (json.get("hostConfig") instanceof JSONArray) {
1120 JSONArray ja = json.getJSONArray("hostConfig");
1121 for (int i = 0; i < ja.length(); i++) {
1122 String na = ja.getJSONObject(i).getString("networkAddress");
1123 if (na.equalsIgnoreCase(hostIp)) {
1129 JSONObject ja = json.getJSONObject("hostConfig");
1130 String na = ja.getString("networkAddress");
1131 return (na.equalsIgnoreCase(hostIp)) ? true : false;
1136 public void testTopology() throws JSONException, ConstructionException {
1137 System.out.println("Starting Topology JAXB client.");
1138 String baseURL = "http://127.0.0.1:8080/controller/nb/v2/topology/default";
1140 // === test GET method for getTopology()
1141 short state_1 = State.EDGE_UP, state_2 = State.EDGE_DOWN;
1142 long bw_1 = Bandwidth.BW10Gbps, bw_2 = Bandwidth.BW100Mbps;
1143 long lat_1 = Latency.LATENCY100ns, lat_2 = Latency.LATENCY1ms;
1144 String nodeType = "STUB";
1145 String nodeConnType = "STUB";
1146 int headNC1_nodeId = 1, headNC1_nodeConnId = 11;
1147 int tailNC1_nodeId = 2, tailNC1_nodeConnId = 22;
1148 int headNC2_nodeId = 2, headNC2_nodeConnId = 21;
1149 int tailNC2_nodeId = 1, tailNC2_nodeConnId = 12;
1151 List<TopoEdgeUpdate> topoedgeupdateList = new ArrayList<TopoEdgeUpdate>();
1152 NodeConnector headnc1 = new NodeConnector(nodeConnType, headNC1_nodeConnId, new Node(nodeType, headNC1_nodeId));
1153 NodeConnector tailnc1 = new NodeConnector(nodeConnType, tailNC1_nodeConnId, new Node(nodeType, tailNC1_nodeId));
1154 Edge e1 = new Edge(tailnc1, headnc1);
1155 Set<Property> props_1 = new HashSet<Property>();
1156 props_1.add(new State(state_1));
1157 props_1.add(new Bandwidth(bw_1));
1158 props_1.add(new Latency(lat_1));
1159 TopoEdgeUpdate teu1 = new TopoEdgeUpdate(e1, props_1, UpdateType.ADDED);
1160 topoedgeupdateList.add(teu1);
1162 NodeConnector headnc2 = new NodeConnector(nodeConnType, headNC2_nodeConnId, new Node(nodeType, headNC2_nodeId));
1163 NodeConnector tailnc2 = new NodeConnector(nodeConnType, tailNC2_nodeConnId, new Node(nodeType, tailNC2_nodeId));
1164 Edge e2 = new Edge(tailnc2, headnc2);
1165 Set<Property> props_2 = new HashSet<Property>();
1166 props_2.add(new State(state_2));
1167 props_2.add(new Bandwidth(bw_2));
1168 props_2.add(new Latency(lat_2));
1170 TopoEdgeUpdate teu2 = new TopoEdgeUpdate(e2, props_2, UpdateType.ADDED);
1171 topoedgeupdateList.add(teu2);
1173 topoUpdates.edgeUpdate(topoedgeupdateList);
1176 String result = getJsonResult(baseURL, "GET");
1177 Assert.assertTrue(httpResponseCode == 200);
1179 System.out.println("Get Topology: " + result);
1182 // returned data must be an array of edges
1183 JSONTokener jt = new JSONTokener(result);
1184 JSONObject json = new JSONObject(jt);
1185 Assert.assertTrue(json.get("edgeProperties") instanceof JSONArray);
1186 JSONArray ja = json.getJSONArray("edgeProperties");
1188 for (int i = 0; i < ja.length(); i++) {
1189 JSONObject edgeProp = ja.getJSONObject(i);
1190 JSONObject edge = edgeProp.getJSONObject("edge");
1191 JSONObject tailNC = edge.getJSONObject("tailNodeConnector");
1192 JSONObject tailNode = tailNC.getJSONObject("node");
1194 JSONObject headNC = edge.getJSONObject("headNodeConnector");
1195 JSONObject headNode = headNC.getJSONObject("node");
1196 JSONObject Props = edgeProp.getJSONObject("properties");
1197 JSONObject bandw = Props.getJSONObject("bandwidth");
1198 JSONObject stt = Props.getJSONObject("state");
1199 JSONObject ltc = Props.getJSONObject("latency");
1201 if (headNC.getInt("id") == headNC1_nodeConnId) {
1202 Assert.assertEquals(headNode.getString("type"), nodeType);
1203 Assert.assertEquals(headNode.getLong("id"), headNC1_nodeId);
1204 Assert.assertEquals(headNC.getString("type"), nodeConnType);
1205 Assert.assertEquals(tailNode.getString("type"),nodeType);
1206 Assert.assertEquals(tailNode.getString("type"), nodeConnType);
1207 Assert.assertEquals(tailNC.getLong("id"), tailNC1_nodeConnId);
1208 Assert.assertEquals(bandw.getLong("value"), bw_1);
1209 Assert.assertTrue((short) stt.getInt("value") == state_1);
1210 Assert.assertEquals(ltc.getLong("value"), lat_1);
1211 } else if (headNC.getInt("id") == headNC2_nodeConnId) {
1212 Assert.assertEquals(headNode.getString("type"),nodeType);
1213 Assert.assertEquals(headNode.getLong("id"), headNC2_nodeId);
1214 Assert.assertEquals(headNC.getString("type"), nodeConnType);
1215 Assert.assertEquals(tailNode.getString("type"), nodeType);
1216 Assert.assertTrue(tailNode.getInt("id") == tailNC2_nodeId);
1217 Assert.assertEquals(tailNC.getString("type"), nodeConnType);
1218 Assert.assertEquals(tailNC.getLong("id"), tailNC2_nodeConnId);
1219 Assert.assertEquals(bandw.getLong("value"), bw_2);
1220 Assert.assertTrue((short) stt.getInt("value") == state_2);
1221 Assert.assertEquals(ltc.getLong("value"), lat_2);
1225 // === test POST method for addUserLink()
1226 // define 2 sample nodeConnectors for user link configuration tests
1227 String nodeType_1 = "STUB";
1228 Integer nodeId_1 = 3366;
1229 String nodeConnectorType_1 = "STUB";
1230 Integer nodeConnectorId_1 = 12;
1231 String nodeType_2 = "STUB";
1232 Integer nodeId_2 = 4477;
1233 String nodeConnectorType_2 = "STUB";
1234 Integer nodeConnectorId_2 = 34;
1236 JSONObject jo = new JSONObject()
1237 .put("name", "userLink_1")
1238 .put("srcNodeConnector",
1239 nodeConnectorType_1 + "|" + nodeConnectorId_1 + "@" + nodeType_1 + "|" + nodeId_1)
1240 .put("dstNodeConnector",
1241 nodeConnectorType_2 + "|" + nodeConnectorId_2 + "@" + nodeType_2 + "|" + nodeId_2);
1242 // execute HTTP request and verify response code
1243 result = getJsonResult(baseURL + "/userLink/userLink_1", "PUT", jo.toString());
1244 Assert.assertTrue(httpResponseCode == 201);
1246 // === test GET method for getUserLinks()
1247 result = getJsonResult(baseURL + "/userLinks", "GET");
1248 Assert.assertTrue(httpResponseCode == 200);
1250 System.out.println("result:" + result);
1253 jt = new JSONTokener(result);
1254 json = new JSONObject(jt);
1256 // should have at least one object returned
1257 Assert.assertFalse(json.length() == 0);
1258 JSONObject userlink = new JSONObject();
1260 if (json.get("userLinks") instanceof JSONArray) {
1261 ja = json.getJSONArray("userLinks");
1263 for (i = 0; i < ja.length(); i++) {
1264 userlink = ja.getJSONObject(i);
1265 if (userlink.getString("name").equalsIgnoreCase("userLink_1")) {
1269 Assert.assertFalse(i == ja.length());
1271 userlink = json.getJSONObject("userLinks");
1272 Assert.assertTrue(userlink.getString("name").equalsIgnoreCase("userLink_1"));
1275 String[] level_1, level_2;
1276 level_1 = userlink.getString("srcNodeConnector").split("\\@");
1277 level_2 = level_1[0].split("\\|");
1278 Assert.assertTrue(level_2[0].equalsIgnoreCase(nodeConnectorType_1));
1279 Assert.assertTrue(Integer.parseInt(level_2[1]) == nodeConnectorId_1);
1280 level_2 = level_1[1].split("\\|");
1281 Assert.assertTrue(level_2[0].equalsIgnoreCase(nodeType_1));
1282 Assert.assertTrue(Integer.parseInt(level_2[1]) == nodeId_1);
1283 level_1 = userlink.getString("dstNodeConnector").split("\\@");
1284 level_2 = level_1[0].split("\\|");
1285 Assert.assertTrue(level_2[0].equalsIgnoreCase(nodeConnectorType_2));
1286 Assert.assertTrue(Integer.parseInt(level_2[1]) == nodeConnectorId_2);
1287 level_2 = level_1[1].split("\\|");
1288 Assert.assertTrue(level_2[0].equalsIgnoreCase(nodeType_2));
1289 Assert.assertTrue(Integer.parseInt(level_2[1]) == nodeId_2);
1291 // === test DELETE method for deleteUserLink()
1292 String userName = "userLink_1";
1293 result = getJsonResult(baseURL + "/userLink/" + userName, "DELETE");
1294 Assert.assertTrue(httpResponseCode == 204);
1296 // execute another getUserLinks() request to verify that userLink_1 is
1298 result = getJsonResult(baseURL + "/userLinks", "GET");
1299 Assert.assertTrue(httpResponseCode == 200);
1301 System.out.println("result:" + result);
1303 jt = new JSONTokener(result);
1304 json = new JSONObject(jt);
1306 if (json.length() != 0) {
1307 if (json.get("userLinks") instanceof JSONArray) {
1308 ja = json.getJSONArray("userLinks");
1309 for (int i = 0; i < ja.length(); i++) {
1310 userlink = ja.getJSONObject(i);
1311 Assert.assertFalse(userlink.getString("name").equalsIgnoreCase("userLink_1"));
1314 userlink = json.getJSONObject("userLinks");
1315 Assert.assertFalse(userlink.getString("name").equalsIgnoreCase("userLink_1"));
1319 // Configure the OSGi container
1321 public Option[] config() {
1324 systemProperty("logback.configurationFile").value(
1325 "file:" + PathUtils.getBaseDir() + "/src/test/resources/logback.xml"),
1326 // To start OSGi console for inspection remotely
1327 systemProperty("osgi.console").value("2401"),
1328 systemProperty("org.eclipse.gemini.web.tomcat.config.path").value(
1329 PathUtils.getBaseDir() + "/src/test/resources/tomcat-server.xml"),
1331 // setting default level. Jersey bundles will need to be started
1333 systemProperty("osgi.bundles.defaultStartLevel").value("4"),
1335 // Set the systemPackages (used by clustering)
1336 systemPackages("sun.reflect", "sun.reflect.misc", "sun.misc"),
1337 mavenBundle("org.slf4j", "jcl-over-slf4j").versionAsInProject(),
1338 mavenBundle("org.slf4j", "slf4j-api").versionAsInProject(),
1339 mavenBundle("org.slf4j", "log4j-over-slf4j").versionAsInProject(),
1340 mavenBundle("ch.qos.logback", "logback-core").versionAsInProject(),
1341 mavenBundle("ch.qos.logback", "logback-classic").versionAsInProject(),
1342 mavenBundle("org.apache.commons", "commons-lang3").versionAsInProject(),
1343 mavenBundle("org.apache.felix", "org.apache.felix.dependencymanager").versionAsInProject(),
1345 // the plugin stub to get data for the tests
1346 mavenBundle("org.opendaylight.controller", "protocol_plugins.stub").versionAsInProject(),
1348 // List all the opendaylight modules
1349 mavenBundle("org.opendaylight.controller", "configuration").versionAsInProject(),
1350 mavenBundle("org.opendaylight.controller", "configuration.implementation").versionAsInProject(),
1351 mavenBundle("org.opendaylight.controller", "containermanager").versionAsInProject(),
1352 mavenBundle("org.opendaylight.controller", "containermanager.it.implementation").versionAsInProject(),
1353 mavenBundle("org.opendaylight.controller", "clustering.services").versionAsInProject(),
1354 mavenBundle("org.opendaylight.controller", "clustering.services-implementation").versionAsInProject(),
1355 mavenBundle("org.opendaylight.controller", "security").versionAsInProject().noStart(),
1356 mavenBundle("org.opendaylight.controller", "sal").versionAsInProject(),
1357 mavenBundle("org.opendaylight.controller", "sal.implementation").versionAsInProject(),
1358 mavenBundle("org.opendaylight.controller", "sal.connection").versionAsInProject(),
1359 mavenBundle("org.opendaylight.controller", "sal.connection.implementation").versionAsInProject(),
1360 mavenBundle("org.opendaylight.controller", "switchmanager").versionAsInProject(),
1361 mavenBundle("org.opendaylight.controller", "connectionmanager").versionAsInProject(),
1362 mavenBundle("org.opendaylight.controller", "connectionmanager.implementation").versionAsInProject(),
1363 mavenBundle("org.opendaylight.controller", "switchmanager.implementation").versionAsInProject(),
1364 mavenBundle("org.opendaylight.controller", "forwardingrulesmanager").versionAsInProject(),
1365 mavenBundle("org.opendaylight.controller",
1366 "forwardingrulesmanager.implementation").versionAsInProject(),
1367 mavenBundle("org.opendaylight.controller", "statisticsmanager").versionAsInProject(),
1368 mavenBundle("org.opendaylight.controller", "statisticsmanager.implementation").versionAsInProject(),
1369 mavenBundle("org.opendaylight.controller", "arphandler").versionAsInProject(),
1370 mavenBundle("org.opendaylight.controller", "hosttracker").versionAsInProject(),
1371 mavenBundle("org.opendaylight.controller", "hosttracker.implementation").versionAsInProject(),
1372 mavenBundle("org.opendaylight.controller", "arphandler").versionAsInProject(),
1373 mavenBundle("org.opendaylight.controller", "routing.dijkstra_implementation").versionAsInProject(),
1374 mavenBundle("org.opendaylight.controller", "topologymanager").versionAsInProject(),
1375 mavenBundle("org.opendaylight.controller", "usermanager").versionAsInProject(),
1376 mavenBundle("org.opendaylight.controller", "usermanager.implementation").versionAsInProject(),
1377 mavenBundle("org.opendaylight.controller", "logging.bridge").versionAsInProject(),
1378 // mavenBundle("org.opendaylight.controller", "clustering.test").versionAsInProject(),
1379 mavenBundle("org.opendaylight.controller", "forwarding.staticrouting").versionAsInProject(),
1380 mavenBundle("org.opendaylight.controller", "bundlescanner").versionAsInProject(),
1381 mavenBundle("org.opendaylight.controller", "bundlescanner.implementation").versionAsInProject(),
1382 mavenBundle("org.opendaylight.controller", "commons.httpclient").versionAsInProject(),
1384 // Northbound bundles
1385 mavenBundle("org.opendaylight.controller", "commons.northbound").versionAsInProject(),
1386 mavenBundle("org.opendaylight.controller", "forwarding.staticrouting.northbound").versionAsInProject(),
1387 mavenBundle("org.opendaylight.controller", "statistics.northbound").versionAsInProject(),
1388 mavenBundle("org.opendaylight.controller", "topology.northbound").versionAsInProject(),
1389 mavenBundle("org.opendaylight.controller", "hosttracker.northbound").versionAsInProject(),
1390 mavenBundle("org.opendaylight.controller", "switchmanager.northbound").versionAsInProject(),
1391 mavenBundle("org.opendaylight.controller", "flowprogrammer.northbound").versionAsInProject(),
1392 mavenBundle("org.opendaylight.controller", "subnets.northbound").versionAsInProject(),
1394 mavenBundle("org.codehaus.jackson", "jackson-mapper-asl").versionAsInProject(),
1395 mavenBundle("org.codehaus.jackson", "jackson-core-asl").versionAsInProject(),
1396 mavenBundle("org.codehaus.jackson", "jackson-jaxrs").versionAsInProject(),
1397 mavenBundle("org.codehaus.jackson", "jackson-xc").versionAsInProject(),
1398 mavenBundle("org.codehaus.jettison", "jettison").versionAsInProject(),
1400 mavenBundle("commons-io", "commons-io").versionAsInProject(),
1402 mavenBundle("commons-fileupload", "commons-fileupload").versionAsInProject(),
1404 mavenBundle("equinoxSDK381", "javax.servlet").versionAsInProject(),
1405 mavenBundle("equinoxSDK381", "javax.servlet.jsp").versionAsInProject(),
1406 mavenBundle("equinoxSDK381", "org.eclipse.equinox.ds").versionAsInProject(),
1407 mavenBundle("orbit", "javax.xml.rpc").versionAsInProject(),
1408 mavenBundle("equinoxSDK381", "org.eclipse.equinox.util").versionAsInProject(),
1409 mavenBundle("equinoxSDK381", "org.eclipse.osgi.services").versionAsInProject(),
1410 mavenBundle("equinoxSDK381", "org.apache.felix.gogo.command").versionAsInProject(),
1411 mavenBundle("equinoxSDK381", "org.apache.felix.gogo.runtime").versionAsInProject(),
1412 mavenBundle("equinoxSDK381", "org.apache.felix.gogo.shell").versionAsInProject(),
1413 mavenBundle("equinoxSDK381", "org.eclipse.equinox.cm").versionAsInProject(),
1414 mavenBundle("equinoxSDK381", "org.eclipse.equinox.console").versionAsInProject(),
1415 mavenBundle("equinoxSDK381", "org.eclipse.equinox.launcher").versionAsInProject(),
1417 mavenBundle("geminiweb", "org.eclipse.gemini.web.core").versionAsInProject(),
1418 mavenBundle("geminiweb", "org.eclipse.gemini.web.extender").versionAsInProject(),
1419 mavenBundle("geminiweb", "org.eclipse.gemini.web.tomcat").versionAsInProject(),
1420 mavenBundle("geminiweb", "org.eclipse.virgo.kernel.equinox.extensions").versionAsInProject().noStart(),
1421 mavenBundle("geminiweb", "org.eclipse.virgo.util.common").versionAsInProject(),
1422 mavenBundle("geminiweb", "org.eclipse.virgo.util.io").versionAsInProject(),
1423 mavenBundle("geminiweb", "org.eclipse.virgo.util.math").versionAsInProject(),
1424 mavenBundle("geminiweb", "org.eclipse.virgo.util.osgi").versionAsInProject(),
1425 mavenBundle("geminiweb", "org.eclipse.virgo.util.osgi.manifest").versionAsInProject(),
1426 mavenBundle("geminiweb", "org.eclipse.virgo.util.parser.manifest").versionAsInProject(),
1428 mavenBundle("org.apache.felix", "org.apache.felix.dependencymanager").versionAsInProject(),
1429 mavenBundle("org.apache.felix", "org.apache.felix.dependencymanager.shell").versionAsInProject(),
1431 mavenBundle("com.google.code.gson", "gson").versionAsInProject(),
1432 mavenBundle("org.jboss.spec.javax.transaction", "jboss-transaction-api_1.1_spec").versionAsInProject(),
1433 mavenBundle("org.apache.felix", "org.apache.felix.fileinstall").versionAsInProject(),
1434 mavenBundle("org.apache.commons", "commons-lang3").versionAsInProject(),
1435 mavenBundle("commons-codec", "commons-codec").versionAsInProject(),
1436 mavenBundle("virgomirror", "org.eclipse.jdt.core.compiler.batch").versionAsInProject(),
1437 mavenBundle("eclipselink", "javax.persistence").versionAsInProject(),
1438 mavenBundle("eclipselink", "javax.resource").versionAsInProject(),
1440 mavenBundle("orbit", "javax.activation").versionAsInProject(),
1441 mavenBundle("orbit", "javax.annotation").versionAsInProject(),
1442 mavenBundle("orbit", "javax.ejb").versionAsInProject(),
1443 mavenBundle("orbit", "javax.el").versionAsInProject(),
1444 mavenBundle("orbit", "javax.mail.glassfish").versionAsInProject(),
1445 mavenBundle("orbit", "javax.xml.rpc").versionAsInProject(),
1446 mavenBundle("orbit", "org.apache.catalina").versionAsInProject(),
1447 // these are bundle fragments that can't be started on its own
1448 mavenBundle("orbit", "org.apache.catalina.ha").versionAsInProject().noStart(),
1449 mavenBundle("orbit", "org.apache.catalina.tribes").versionAsInProject().noStart(),
1450 mavenBundle("orbit", "org.apache.coyote").versionAsInProject().noStart(),
1451 mavenBundle("orbit", "org.apache.jasper").versionAsInProject().noStart(),
1453 mavenBundle("orbit", "org.apache.el").versionAsInProject(),
1454 mavenBundle("orbit", "org.apache.juli.extras").versionAsInProject(),
1455 mavenBundle("orbit", "org.apache.tomcat.api").versionAsInProject(),
1456 mavenBundle("orbit", "org.apache.tomcat.util").versionAsInProject().noStart(),
1457 mavenBundle("orbit", "javax.servlet.jsp.jstl").versionAsInProject(),
1458 mavenBundle("orbit", "javax.servlet.jsp.jstl.impl").versionAsInProject(),
1460 mavenBundle("org.ops4j.pax.exam", "pax-exam-container-native").versionAsInProject(),
1461 mavenBundle("org.ops4j.pax.exam", "pax-exam-junit4").versionAsInProject(),
1462 mavenBundle("org.ops4j.pax.exam", "pax-exam-link-mvn").versionAsInProject(),
1463 mavenBundle("org.ops4j.pax.url", "pax-url-aether").versionAsInProject(),
1465 mavenBundle("org.ow2.asm", "asm-all").versionAsInProject(),
1467 mavenBundle("org.springframework", "org.springframework.asm").versionAsInProject(),
1468 mavenBundle("org.springframework", "org.springframework.aop").versionAsInProject(),
1469 mavenBundle("org.springframework", "org.springframework.context").versionAsInProject(),
1470 mavenBundle("org.springframework", "org.springframework.context.support").versionAsInProject(),
1471 mavenBundle("org.springframework", "org.springframework.core").versionAsInProject(),
1472 mavenBundle("org.springframework", "org.springframework.beans").versionAsInProject(),
1473 mavenBundle("org.springframework", "org.springframework.expression").versionAsInProject(),
1474 mavenBundle("org.springframework", "org.springframework.web").versionAsInProject(),
1476 mavenBundle("org.aopalliance", "com.springsource.org.aopalliance").versionAsInProject(),
1477 mavenBundle("org.springframework", "org.springframework.web.servlet").versionAsInProject(),
1478 mavenBundle("org.springframework.security", "spring-security-config").versionAsInProject(),
1479 mavenBundle("org.springframework.security", "spring-security-core").versionAsInProject(),
1480 mavenBundle("org.springframework.security", "spring-security-web").versionAsInProject(),
1481 mavenBundle("org.springframework.security", "spring-security-taglibs").versionAsInProject(),
1482 mavenBundle("org.springframework", "org.springframework.transaction").versionAsInProject(),
1484 mavenBundle("org.ow2.chameleon.management", "chameleon-mbeans").versionAsInProject(),
1485 mavenBundle("org.opendaylight.controller.thirdparty", "net.sf.jung2").versionAsInProject(),
1486 mavenBundle("org.opendaylight.controller.thirdparty", "com.sun.jersey.jersey-servlet")
1487 .versionAsInProject(),
1488 mavenBundle("org.opendaylight.controller.thirdparty", "org.apache.catalina.filters.CorsFilter")
1489 .versionAsInProject().noStart(),
1491 // Jersey needs to be started before the northbound application
1492 // bundles, using a lower start level
1493 mavenBundle("com.sun.jersey", "jersey-client").versionAsInProject(),
1494 mavenBundle("com.sun.jersey", "jersey-server").versionAsInProject().startLevel(2),
1495 mavenBundle("com.sun.jersey", "jersey-core").versionAsInProject().startLevel(2),
1496 mavenBundle("com.sun.jersey", "jersey-json").versionAsInProject().startLevel(2), junitBundles());