opendaylight/md-sal/sal-remoterpc-connector/integrationtest/test-it/src/test/java/org/opendaylight/controller/sample/zeromq/test/it/RouterTest.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  * This program and the accompanying materials are made available under the
   4  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   5  * and is available at http://www.eclipse.org/legal/epl-v10.html
   6  */
   7
   8 package org.opendaylight.controller.sample.zeromq.test.it;
   9
  10 import junit.framework.Assert;
  11
  12 import org.junit.Test;
  13 import org.junit.runner.RunWith;
  14
  15 import org.opendaylight.controller.sal.connector.remoterpc.RemoteRpcClient;
  16
  17 import org.opendaylight.controller.sal.connector.remoterpc.dto.Message;
  18 import org.opendaylight.controller.sal.core.api.Broker;
  19 import org.opendaylight.controller.sample.zeromq.consumer.ExampleConsumer;
  20 import org.opendaylight.controller.sample.zeromq.provider.ExampleProvider;
  21
  22 import org.opendaylight.controller.test.sal.binding.it.TestHelper;
  23 import org.opendaylight.yangtools.yang.common.QName;
  24 import org.opendaylight.yangtools.yang.common.RpcError;
  25 import org.opendaylight.yangtools.yang.common.RpcResult;
  26 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  27 import org.ops4j.pax.exam.Configuration;
  28 import org.ops4j.pax.exam.Option;
  29 import org.ops4j.pax.exam.junit.PaxExam;
  30 import org.ops4j.pax.exam.util.Filter;
  31 import org.osgi.framework.Bundle;
  32 import org.osgi.framework.BundleException;
  33 import org.osgi.framework.ServiceReference;
  34
  35 import org.slf4j.Logger;
  36 import org.slf4j.LoggerFactory;
  37 import org.zeromq.ZMQ;
  38
  39 import javax.inject.Inject;
  40
  41 import java.io.IOException;
  42 import java.net.URI;
  43
  44 import static org.opendaylight.controller.test.sal.binding.it.TestHelper.baseModelBundles;
  45 import static org.opendaylight.controller.test.sal.binding.it.TestHelper.bindingAwareSalBundles;
  46
  47 //import static org.ops4j.pax.exam.CoreOptions.*;
  48
  49 @RunWith(PaxExam.class)
  50 public class RouterTest {
  51
  52   private Logger _logger = LoggerFactory.getLogger(RouterTest.class);
  53
  54   public static final String ODL = "org.opendaylight.controller";
  55   public static final String YANG = "org.opendaylight.yangtools";
  56   public static final String SAMPLE = "org.opendaylight.controller.tests";
  57   private final URI namespace = URI.create("http://cisco.com/example");
  58   private final QName QNAME = new QName(namespace, "heartbeat");
  59
  60
  61   @Inject
  62   org.osgi.framework.BundleContext ctx;
  63
  64   @Inject
  65   @Filter(timeout=60*1000)
  66   Broker broker;
  67
  68   private ZMQ.Context zmqCtx = ZMQ.context(1);
  69   //private Server router;
  70   //private ExampleProvider provider;
  71
  72   //@Test
  73   public void testInvokeRpc() throws Exception{
  74     //Thread.sleep(1000);
  75     //Send announcement
  76     ServiceReference providerRef = ctx.getServiceReference(ExampleProvider.class);
  77     Assert.assertNotNull(providerRef);
  78
  79     ExampleProvider provider = (ExampleProvider)ctx.getService(providerRef);
  80     Assert.assertNotNull(provider);
  81
  82     ServiceReference consumerRef = ctx.getServiceReference(ExampleConsumer.class);
  83     Assert.assertNotNull(consumerRef);
  84     ExampleConsumer consumer = (ExampleConsumer)ctx.getService(consumerRef);
  85     Assert.assertNotNull(consumer);
  86
  87
  88     _logger.debug("Provider sends announcement [{}]", "heartbeat");
  89     provider.announce(QNAME);
  90     ServiceReference routerRef = ctx.getServiceReference(RemoteRpcClient.class);
  91     RemoteRpcClient router = (RemoteRpcClient) ctx.getService(routerRef);
  92     _logger.debug("Found router[{}]", router);
  93     _logger.debug("Invoking RPC [{}]", QNAME);
  94     for (int i = 0; i < 3; i++) {
  95       RpcResult<CompositeNode> result = router.invokeRpc(QNAME, consumer.getValidCompositeNodeWithOneSimpleChild());
  96       _logger.debug("{}-> Result is: Successful:[{}], Payload:[{}], Errors: [{}]", i, result.isSuccessful(), result.getResult(), result.getErrors());
  97       Assert.assertNotNull(result);
  98     }
  99   }
 100
 101   @Test
 102   public void testInvokeRpcWithValidSimpleNode() throws Exception{
 103     //Thread.sleep(1500);
 104
 105     ServiceReference providerRef = ctx.getServiceReference(ExampleProvider.class);
 106     Assert.assertNotNull(providerRef);
 107     ExampleProvider provider = (ExampleProvider)ctx.getService(providerRef);
 108     Assert.assertNotNull(provider);
 109     ServiceReference consumerRef = ctx.getServiceReference(ExampleConsumer.class);
 110     Assert.assertNotNull(consumerRef);
 111     ExampleConsumer consumer = (ExampleConsumer)ctx.getService(consumerRef);
 112     Assert.assertNotNull(consumer);
 113
 114     // Provider sends announcement
 115     _logger.debug("Provider sends announcement [{}]", "heartbeat");
 116     provider.announce(QNAME);
 117     // Consumer invokes RPC
 118     _logger.debug("Invoking RPC [{}]", QNAME);
 119     CompositeNode input = consumer.getValidCompositeNodeWithOneSimpleChild();
 120     for (int i = 0; i < 3; i++) {
 121       RpcResult<CompositeNode> result = consumer.invokeRpc(QNAME, input);
 122       Assert.assertNotNull(result);
 123       _logger.debug("{}-> Result is: Successful:[{}], Payload:[{}], Errors: [{}]", i, result.isSuccessful(), result.getResult(), result.getErrors());
 124       Assert.assertTrue(result.isSuccessful());
 125       Assert.assertNotNull(result.getResult());
 126       Assert.assertEquals(0, result.getErrors().size());
 127       Assert.assertEquals(input.getChildren().size()+1, result.getResult().getChildren().size());
 128     }
 129   }
 130
 131   @Test
 132   public void testInvokeRpcWithValidSimpleNodes() throws Exception{
 133     //Thread.sleep(1500);
 134
 135     ServiceReference providerRef = ctx.getServiceReference(ExampleProvider.class);
 136     Assert.assertNotNull(providerRef);
 137     ExampleProvider provider = (ExampleProvider)ctx.getService(providerRef);
 138     Assert.assertNotNull(provider);
 139     ServiceReference consumerRef = ctx.getServiceReference(ExampleConsumer.class);
 140     Assert.assertNotNull(consumerRef);
 141     ExampleConsumer consumer = (ExampleConsumer)ctx.getService(consumerRef);
 142     Assert.assertNotNull(consumer);
 143
 144     // Provider sends announcement
 145     _logger.debug("Provider sends announcement [{}]", "heartbeat");
 146     provider.announce(QNAME);
 147     // Consumer invokes RPC
 148     _logger.debug("Invoking RPC [{}]", QNAME);
 149     CompositeNode input = consumer.getValidCompositeNodeWithFourSimpleChildren();
 150     for (int i = 0; i < 3; i++) {
 151       RpcResult<CompositeNode> result = consumer.invokeRpc(QNAME, input);
 152       Assert.assertNotNull(result);
 153       _logger.debug("{}-> Result is: Successful:[{}], Payload:[{}], Errors: [{}]", i, result.isSuccessful(), result.getResult(), result.getErrors());
 154       Assert.assertTrue(result.isSuccessful());
 155       Assert.assertNotNull(result.getResult());
 156       Assert.assertEquals(0, result.getErrors().size());
 157       Assert.assertEquals(input.getChildren().size()+1, result.getResult().getChildren().size());
 158     }
 159   }
 160
 161   @Test
 162   public void testInvokeRpcWithValidCompositeNode() throws Exception{
 163     //Thread.sleep(1500);
 164
 165     ServiceReference providerRef = ctx.getServiceReference(ExampleProvider.class);
 166     Assert.assertNotNull(providerRef);
 167     ExampleProvider provider = (ExampleProvider)ctx.getService(providerRef);
 168     Assert.assertNotNull(provider);
 169     ServiceReference consumerRef = ctx.getServiceReference(ExampleConsumer.class);
 170     Assert.assertNotNull(consumerRef);
 171     ExampleConsumer consumer = (ExampleConsumer)ctx.getService(consumerRef);
 172     Assert.assertNotNull(consumer);
 173
 174     // Provider sends announcement
 175     _logger.debug("Provider sends announcement [{}]", "heartbeat");
 176     provider.announce(QNAME);
 177     // Consumer invokes RPC
 178     _logger.debug("Invoking RPC [{}]", QNAME);
 179     CompositeNode input = consumer.getValidCompositeNodeWithTwoCompositeChildren();
 180     for (int i = 0; i < 3; i++) {
 181       RpcResult<CompositeNode> result = consumer.invokeRpc(QNAME, input);
 182       Assert.assertNotNull(result);
 183       _logger.debug("{}-> Result is: Successful:[{}], Payload:[{}], Errors: [{}]", i, result.isSuccessful(), result.getResult(), result.getErrors());
 184       Assert.assertTrue(result.isSuccessful());
 185       Assert.assertNotNull(result.getResult());
 186       Assert.assertEquals(0, result.getErrors().size());
 187       Assert.assertEquals(input.getChildren().size()+1, result.getResult().getChildren().size());
 188     }
 189   }
 190
 191   @Test
 192   public void testInvokeRpcWithNullInput() throws Exception{
 193     //Thread.sleep(1500);
 194
 195     ServiceReference providerRef = ctx.getServiceReference(ExampleProvider.class);
 196     Assert.assertNotNull(providerRef);
 197     ExampleProvider provider = (ExampleProvider)ctx.getService(providerRef);
 198     Assert.assertNotNull(provider);
 199     ServiceReference consumerRef = ctx.getServiceReference(ExampleConsumer.class);
 200     Assert.assertNotNull(consumerRef);
 201     ExampleConsumer consumer = (ExampleConsumer)ctx.getService(consumerRef);
 202     Assert.assertNotNull(consumer);
 203
 204     // Provider sends announcement
 205     _logger.debug("Provider sends announcement [{}]", QNAME.getLocalName());
 206     provider.announce(QNAME);
 207     // Consumer invokes RPC
 208     _logger.debug("Invoking RPC [{}]", QNAME);
 209     for (int i = 0; i < 3; i++) {
 210       RpcResult<CompositeNode> result = consumer.invokeRpc(QNAME, null);
 211       Assert.assertNotNull(result);
 212       _logger.debug("{}-> Result is: Successful:[{}], Payload:[{}], Errors: [{}]", i, result.isSuccessful(), result.getResult(), result.getErrors());
 213       Assert.assertFalse(result.isSuccessful());
 214       Assert.assertNull(result.getResult());
 215       Assert.assertEquals(1, result.getErrors().size());
 216       Assert.assertEquals(RpcError.ErrorSeverity.WARNING, ((RpcError)result.getErrors().toArray()[0]).getSeverity());
 217     }
 218   }
 219
 220   @Test
 221   public void testInvokeRpcWithInvalidSimpleNode() throws Exception{
 222     //Thread.sleep(1500);
 223
 224     ServiceReference providerRef = ctx.getServiceReference(ExampleProvider.class);
 225     Assert.assertNotNull(providerRef);
 226     ExampleProvider provider = (ExampleProvider)ctx.getService(providerRef);
 227     Assert.assertNotNull(provider);
 228     ServiceReference consumerRef = ctx.getServiceReference(ExampleConsumer.class);
 229     Assert.assertNotNull(consumerRef);
 230     ExampleConsumer consumer = (ExampleConsumer)ctx.getService(consumerRef);
 231     Assert.assertNotNull(consumer);
 232
 233     // Provider sends announcement
 234     _logger.debug("Provider sends announcement [{}]", QNAME.getLocalName());
 235     provider.announce(QNAME);
 236     // Consumer invokes RPC
 237     _logger.debug("Invoking RPC [{}]", QNAME);
 238     CompositeNode input = consumer.getInvalidCompositeNodeSimpleChild();
 239     for (int i = 0; i < 3; i++) {
 240       RpcResult<CompositeNode> result = consumer.invokeRpc(QNAME, input);
 241       Assert.assertNotNull(result);
 242       _logger.debug("{}-> Result is: Successful:[{}], Payload:[{}], Errors: [{}]", i, result.isSuccessful(), result.getResult(), result.getErrors());
 243       Assert.assertFalse(result.isSuccessful());
 244       Assert.assertNull(result.getResult());
 245       Assert.assertEquals(1, result.getErrors().size());
 246       Assert.assertEquals(RpcError.ErrorSeverity.ERROR, ((RpcError)result.getErrors().toArray()[0]).getSeverity());
 247     }
 248   }
 249
 250   @Test
 251   public void testInvokeRpcWithInvalidCompositeNode() throws Exception{
 252     //Thread.sleep(1500);
 253
 254     ServiceReference providerRef = ctx.getServiceReference(ExampleProvider.class);
 255     Assert.assertNotNull(providerRef);
 256     ExampleProvider provider = (ExampleProvider)ctx.getService(providerRef);
 257     Assert.assertNotNull(provider);
 258     ServiceReference consumerRef = ctx.getServiceReference(ExampleConsumer.class);
 259     Assert.assertNotNull(consumerRef);
 260     ExampleConsumer consumer = (ExampleConsumer)ctx.getService(consumerRef);
 261     Assert.assertNotNull(consumer);
 262
 263     // Provider sends announcement
 264     _logger.debug("Provider sends announcement [{}]", QNAME.getLocalName());
 265     provider.announce(QNAME);
 266     // Consumer invokes RPC
 267     _logger.debug("Invoking RPC [{}]", QNAME);
 268     CompositeNode input = consumer.getInvalidCompositeNodeCompositeChild();
 269     for (int i = 0; i < 3; i++) {
 270       RpcResult<CompositeNode> result = consumer.invokeRpc(QNAME, input);
 271       Assert.assertNotNull(result);
 272       _logger.debug("{}-> Result is: Successful:[{}], Payload:[{}], Errors: [{}]", i, result.isSuccessful(), result.getResult(), result.getErrors());
 273       Assert.assertFalse(result.isSuccessful());
 274       Assert.assertNull(result.getResult());
 275       Assert.assertEquals(1, result.getErrors().size());
 276       Assert.assertEquals(RpcError.ErrorSeverity.ERROR, ((RpcError)result.getErrors().toArray()[0]).getSeverity());
 277     }
 278   }
 279
 280   //@Test
 281   // This method is UNTESTED -- need to get around the bundling issues before I know if this even work
 282 //  public void testInvokeRpcWithValidCompositeNode() throws Exception{
 283 //    Thread.sleep(10000);
 284 //    //Send announcement
 285 //    ServiceReference providerRef = ctx.getServiceReference(ExampleProvider.class);
 286 //    Assert.assertNotNull(providerRef);
 287 //
 288 //    ExampleProvider provider = (ExampleProvider)ctx.getService(providerRef);
 289 //    Assert.assertNotNull(provider);
 290 //
 291 //    ServiceReference consumerRef = ctx.getServiceReference(ExampleConsumer.class);
 292 //    Assert.assertNotNull(consumerRef);
 293 //
 294 //    ExampleConsumer consumer = (ExampleConsumer)ctx.getService(consumerRef);
 295 //    Assert.assertNotNull(consumer);
 296 //
 297 //    _logger.debug("Provider sends announcement [{}]", "heartbeat");
 298 //    provider.announce(QNAME);
 299 //    ServiceReference routerRef = ctx.getServiceReference(Client.class);
 300 //    Client router = (Client) ctx.getService(routerRef);
 301 //    _logger.debug("Found router[{}]", router);
 302 //    _logger.debug("Invoking RPC [{}]", QNAME);
 303 //    for (int i = 0; i < 3; i++) {
 304 //      RpcResult<CompositeNode> result = router.getInstance().invokeRpc(QNAME, consumer.getValidCompositeNodeWithOneSimpleChild());
 305 //      _logger.debug("{}-> Result is: Successful:[{}], Payload:[{}], Errors: [{}]", i, result.isSuccessful(), result.getResult(), result.getErrors());
 306 //      Assert.assertNotNull(result);
 307 //    }
 308 //  }
 309
 310   private Message send(Message msg) throws IOException {
 311     ZMQ.Socket reqSocket = zmqCtx.socket(ZMQ.REQ);
 312     reqSocket.connect("tcp://localhost:5555");
 313     reqSocket.send(Message.serialize(msg));
 314     Message response = parseMessage(reqSocket);
 315
 316     return response;
 317   }
 318
 319   /**
 320    * @param socket
 321    * @return
 322    */
 323   private Message parseMessage(ZMQ.Socket socket) {
 324
 325     Message msg = null;
 326     try {
 327       byte[] bytes = socket.recv();
 328       _logger.debug("Received bytes:[{}]", bytes.length);
 329       msg = (Message) Message.deserialize(bytes);
 330     } catch (Throwable t) {
 331       t.printStackTrace();
 332     }
 333     return msg;
 334   }
 335
 336
 337   private void printState(){
 338     Bundle[] b = ctx.getBundles();
 339     _logger.debug("\n\nNumber of bundles [{}]\n\n]", b.length);
 340     for (int i=0;i<b.length;i++){
 341       _logger.debug("Bundle States {}-{} ",b[i].getSymbolicName(), stateToString(b[i].getState()));
 342
 343       if ( Bundle.INSTALLED == b[i].getState() || (Bundle.RESOLVED == b[i].getState())){
 344         try {
 345           b[i].start();
 346         } catch (BundleException e) {
 347           e.printStackTrace();
 348         }
 349       }
 350     }
 351   }
 352
 353   private String stateToString(int state) {
 354     switch (state) {
 355       case Bundle.ACTIVE:
 356         return "ACTIVE";
 357       case Bundle.INSTALLED:
 358         return "INSTALLED";
 359       case Bundle.RESOLVED:
 360         return "RESOLVED";
 361       case Bundle.UNINSTALLED:
 362         return "UNINSTALLED";
 363       default:
 364         return "Not CONVERTED";
 365     }
 366   }
 367
 368   @Configuration
 369   public Option[] config() {
 370     return options(systemProperty("osgi.console").value("2401"),
 371             systemProperty("rpc.port").value("5555"),
 372             mavenBundle("org.slf4j", "slf4j-api").versionAsInProject(), //
 373             mavenBundle("org.slf4j", "log4j-over-slf4j").versionAsInProject(), //
 374             mavenBundle("ch.qos.logback", "logback-core").versionAsInProject(), //
 375             mavenBundle("ch.qos.logback", "logback-classic").versionAsInProject(), //
 376
 377             //mavenBundle(ODL, "sal-binding-broker-impl").versionAsInProject().update(), //
 378             mavenBundle(ODL, "sal-common").versionAsInProject(), //
 379             mavenBundle(ODL, "sal-common-api").versionAsInProject(),//
 380             mavenBundle(ODL, "sal-common-impl").versionAsInProject(), //
 381             mavenBundle(ODL, "sal-common-util").versionAsInProject(), //
 382             mavenBundle(ODL, "sal-core-api").versionAsInProject().update(), //
 383             mavenBundle(ODL, "sal-broker-impl").versionAsInProject(), //
 384             mavenBundle(ODL, "sal-core-spi").versionAsInProject().update(), //
 385             mavenBundle(ODL, "sal-connector-api").versionAsInProject(), //
 386
 387
 388             baseModelBundles(),
 389             bindingAwareSalBundles(),
 390             TestHelper.bindingIndependentSalBundles(),
 391             TestHelper.configMinumumBundles(),
 392             TestHelper.mdSalCoreBundles(),
 393
 394             //Added the consumer
 395             mavenBundle(SAMPLE, "sal-remoterpc-connector-test-consumer").versionAsInProject(), //
 396             //**** These two bundles below are NOT successfully resolved -- some of their dependencies must be missing
 397             //**** This causes the "Message" error to occur, the class cannot be found
 398             mavenBundle(SAMPLE, "sal-remoterpc-connector-test-provider").versionAsInProject(), //
 399             mavenBundle(ODL, "sal-remoterpc-connector").versionAsInProject(), //
 400
 401             mavenBundle(ODL, "zeromq-routingtable.implementation").versionAsInProject(),
 402             mavenBundle(YANG, "concepts").versionAsInProject(),
 403             mavenBundle(YANG, "yang-binding").versionAsInProject(), //
 404             mavenBundle(YANG, "yang-common").versionAsInProject(), //
 405             mavenBundle(YANG, "yang-data-api").versionAsInProject(), //
 406             mavenBundle(YANG, "yang-data-impl").versionAsInProject(), //
 407             mavenBundle(YANG, "yang-model-api").versionAsInProject(), //
 408             mavenBundle(YANG, "yang-parser-api").versionAsInProject(), //
 409             mavenBundle(YANG, "yang-parser-impl").versionAsInProject(), //
 410             mavenBundle(YANG, "yang-model-util").versionAsInProject(), //
 411             mavenBundle(YANG + ".thirdparty", "xtend-lib-osgi").versionAsInProject(), //
 412             mavenBundle(YANG + ".thirdparty", "antlr4-runtime-osgi-nohead").versionAsInProject(), //
 413             mavenBundle("com.google.guava", "guava").versionAsInProject(), //
 414             mavenBundle("org.zeromq", "jeromq").versionAsInProject(),
 415             mavenBundle("org.codehaus.jackson", "jackson-mapper-asl").versionAsInProject(),
 416             mavenBundle("org.codehaus.jackson", "jackson-core-asl").versionAsInProject(),
 417             //routingtable dependencies
 418             systemPackages("sun.reflect", "sun.reflect.misc", "sun.misc"),
 419             // List framework bundles
 420             mavenBundle("equinoxSDK381", "org.eclipse.equinox.console").versionAsInProject(),
 421             mavenBundle("equinoxSDK381", "org.eclipse.equinox.util").versionAsInProject(),
 422             mavenBundle("equinoxSDK381", "org.eclipse.osgi.services").versionAsInProject(),
 423             mavenBundle("equinoxSDK381", "org.eclipse.equinox.ds").versionAsInProject(),
 424             mavenBundle("equinoxSDK381", "org.apache.felix.gogo.command").versionAsInProject(),
 425             mavenBundle("equinoxSDK381", "org.apache.felix.gogo.runtime").versionAsInProject(),
 426             mavenBundle("equinoxSDK381", "org.apache.felix.gogo.shell").versionAsInProject(),
 427             // List logger bundles
 428
 429             mavenBundle("org.opendaylight.controller", "clustering.services")
 430                     .versionAsInProject(),
 431             mavenBundle("org.opendaylight.controller", "clustering.stub")
 432                     .versionAsInProject(),
 433
 434
 435             // List all the bundles on which the test case depends
 436             mavenBundle("org.opendaylight.controller", "sal")
 437                     .versionAsInProject(),
 438             mavenBundle("org.opendaylight.controller", "sal.implementation")
 439                     .versionAsInProject(),
 440             mavenBundle("org.jboss.spec.javax.transaction",
 441                     "jboss-transaction-api_1.1_spec").versionAsInProject(),
 442             mavenBundle("org.apache.commons", "commons-lang3")
 443                     .versionAsInProject(),
 444             mavenBundle("org.apache.felix",
 445                     "org.apache.felix.dependencymanager")
 446                     .versionAsInProject(),
 447
 448             junitBundles()
 449     );
 450   }
 451
 452 }