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