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