openflowplugin/src/test/java/org/opendaylight/openflowplugin/openflow/md/core/session/MessageDispatchServiceImplTest.java

   1 /**
   2  * Copyright IBM Corporation, 2013.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.openflowplugin.openflow.md.core.session;
   9
  10 import org.junit.Assert;
  11 import org.junit.Before;
  12 import org.junit.Test;
  13 import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
  14 import org.opendaylight.openflowjava.protocol.api.connection.ConnectionReadyListener;
  15 import org.opendaylight.openflowplugin.openflow.md.ModelDrivenSwitch;
  16 import org.opendaylight.openflowplugin.openflow.md.OFConstants;
  17 import org.opendaylight.openflowplugin.openflow.md.core.ConnectionConductor;
  18 import org.opendaylight.openflowplugin.openflow.md.core.ErrorHandler;
  19 import org.opendaylight.openflowplugin.openflow.md.core.SwitchConnectionDistinguisher;
  20 import org.opendaylight.openflowplugin.openflow.md.queue.QueueProcessor;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.*;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.system.rev130927.SystemNotificationsListener;
  23 import org.opendaylight.yangtools.concepts.CompositeObjectRegistration;
  24 import org.opendaylight.yangtools.yang.binding.DataObject;
  25 import org.opendaylight.yangtools.yang.common.RpcError;
  26 import org.opendaylight.yangtools.yang.common.RpcResult;
  27
  28 import java.util.*;
  29 import java.util.Map.Entry;
  30 import java.util.concurrent.Future;
  31
  32 /**
  33  * test for {@link MessageDispatchServiceImpl}
  34  */
  35 public class MessageDispatchServiceImplTest {
  36
  37     MockSessionContext session;
  38
  39     /**
  40      * @throws java.lang.Exception
  41      */
  42     @Before
  43     public void setUp() throws Exception {
  44         session = new MockSessionContext(0);
  45
  46     }
  47
  48     /**
  49      * Test barrier message for null cookie
  50      *
  51      * @throws Exception
  52      */
  53     @Test
  54     public void testBarrierMessageForPrimary() throws Exception {
  55         MockConnectionConductor conductor = new MockConnectionConductor(1);
  56         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
  57         BarrierInputBuilder barrierMsg = new BarrierInputBuilder();
  58         session.getMessageDispatchService().barrier(barrierMsg.build(), cookie);
  59         Assert.assertEquals(MessageType.BARRIER, session.getPrimaryConductor().getMessageType());
  60     }
  61
  62     /**
  63      * Test packet out message for primary connection
  64      *
  65      * @throws Exception
  66      */
  67     @Test
  68     public void testPacketOutMessageForPrimary() throws Exception {
  69         session.getMessageDispatchService().packetOut(null, null);
  70         Assert.assertEquals(MessageType.PACKETOUT, session.getPrimaryConductor().getMessageType());
  71     }
  72
  73     /**
  74      * Test packet out message for auxiliary connection
  75      *
  76      * @throws Exception
  77      */
  78     @Test
  79     public void testPacketOutMessageForAuxiliary() throws Exception {
  80         MockConnectionConductor conductor = new MockConnectionConductor(1);
  81         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
  82         session.addAuxiliaryConductor(cookie, conductor);
  83         session.getMessageDispatchService().packetOut(null, cookie);
  84         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor().getMessageType());
  85         conductor = (MockConnectionConductor) session.getAuxiliaryConductor(cookie);
  86         Assert.assertEquals(MessageType.PACKETOUT, conductor.getMessageType());
  87     }
  88
  89     /**
  90      * Test packet out message when multiple auxiliary connection exist
  91      *
  92      * @throws Exception
  93      */
  94     @Test
  95     public void testPacketOutMessageForMultipleAuxiliary() throws Exception {
  96         MockConnectionConductor conductor1 = new MockConnectionConductor(1);
  97         SwitchConnectionDistinguisher cookie1 = conductor1.getAuxiliaryKey();
  98         session.addAuxiliaryConductor(cookie1, conductor1);
  99         MockConnectionConductor conductor2 = new MockConnectionConductor(2);
 100         SwitchConnectionDistinguisher cookie2 = conductor2.getAuxiliaryKey();
 101         session.addAuxiliaryConductor(cookie2, conductor2);
 102         MockConnectionConductor conductor3 = new MockConnectionConductor(3);
 103         SwitchConnectionDistinguisher cookie3 = conductor3.getAuxiliaryKey();
 104         session.addAuxiliaryConductor(cookie3, conductor3);
 105         PacketOutInputBuilder builder = new PacketOutInputBuilder();
 106         // send message
 107         session.getMessageDispatchService().packetOut(builder.build(), cookie2);
 108
 109         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor().getMessageType());
 110
 111         conductor3 = (MockConnectionConductor) session.getAuxiliaryConductor(cookie3);
 112         Assert.assertEquals(MessageType.NONE, conductor3.getMessageType());
 113
 114         conductor2 = (MockConnectionConductor) session.getAuxiliaryConductor(cookie2);
 115         Assert.assertEquals(MessageType.PACKETOUT, conductor2.getMessageType());
 116
 117         conductor1 = (MockConnectionConductor) session.getAuxiliaryConductor(cookie1);
 118         Assert.assertEquals(MessageType.NONE, conductor1.getMessageType());
 119
 120     }
 121
 122     /**
 123      * Test for invalid session
 124      *
 125      * @throws Exception
 126      */
 127     @Test
 128     public void testInvalidSession() throws Exception {
 129         session.setValid(false);
 130         Future<RpcResult<Void>> resultFuture = session.getMessageDispatchService().packetOut(null, null);
 131         if (resultFuture.isDone()) {
 132             RpcResult<Void> rpcResult = resultFuture.get();
 133             Assert.assertTrue(!rpcResult.getErrors().isEmpty());
 134
 135             Iterator<RpcError> it = rpcResult.getErrors().iterator();
 136             RpcError rpcError = it.next();
 137
 138             Assert.assertTrue(rpcError.getApplicationTag().equals(OFConstants.APPLICATION_TAG));
 139             Assert.assertTrue(rpcError.getTag().equals(OFConstants.ERROR_TAG_TIMEOUT));
 140             Assert.assertTrue(rpcError.getErrorType().equals(RpcError.ErrorType.TRANSPORT));
 141         }
 142     }
 143
 144 }
 145
 146 class MockSessionContext implements SessionContext {
 147     private MockConnectionConductor conductor;
 148     private Map<SwitchConnectionDistinguisher, ConnectionConductor> map;
 149     private IMessageDispatchService messageService;
 150     private boolean isValid = true;
 151     private CompositeObjectRegistration<ModelDrivenSwitch> registration;
 152     private int seed;
 153
 154     MockSessionContext(int conductorNum) {
 155         conductor = new MockConnectionConductor(conductorNum);
 156         map = new HashMap<SwitchConnectionDistinguisher, ConnectionConductor>();
 157         messageService = new MessageDispatchServiceImpl(this);
 158     }
 159
 160     @Override
 161     public MockConnectionConductor getPrimaryConductor() {
 162         // TODO Auto-generated method stub
 163         return conductor;
 164     }
 165
 166     @Override
 167     public GetFeaturesOutput getFeatures() {
 168         // TODO Auto-generated method stub
 169         return null;
 170     }
 171
 172     @Override
 173     public ConnectionConductor getAuxiliaryConductor(SwitchConnectionDistinguisher auxiliaryKey) {
 174
 175         return map.get(auxiliaryKey);
 176     }
 177
 178     @Override
 179     public Set<Entry<SwitchConnectionDistinguisher, ConnectionConductor>> getAuxiliaryConductors() {
 180         // TODO Auto-generated method stub
 181         return null;
 182     }
 183
 184     @Override
 185     public void addAuxiliaryConductor(SwitchConnectionDistinguisher auxiliaryKey, ConnectionConductor conductorArg) {
 186         map.put(auxiliaryKey, conductorArg);
 187     }
 188
 189     @Override
 190     public ConnectionConductor removeAuxiliaryConductor(SwitchConnectionDistinguisher connectionCookie) {
 191         return map.remove(connectionCookie);
 192     }
 193
 194     @Override
 195     public boolean isValid() {
 196         // TODO Auto-generated method stub
 197         return isValid;
 198     }
 199
 200     @Override
 201     public void setValid(boolean valid) {
 202         isValid = valid;
 203     }
 204
 205     @Override
 206     public SwitchSessionKeyOF getSessionKey() {
 207         // TODO Auto-generated method stub
 208         return null;
 209     }
 210
 211     @Override
 212     public IMessageDispatchService getMessageDispatchService() {
 213         // TODO Auto-generated method stub
 214         return messageService;
 215     }
 216
 217     @Override
 218     public Long getNextXid() {
 219         // TODO Auto-generated method stub
 220         return null;
 221     }
 222
 223     @Override
 224     public Map<Long, PortGrouping> getPhysicalPorts() {
 225         // TODO Auto-generated method stub
 226         return null;
 227     }
 228
 229     @Override
 230     public Set<Long> getPorts() {
 231         // TODO Auto-generated method stub
 232         return null;
 233     }
 234
 235     @Override
 236     public PortGrouping getPhysicalPort(Long portNumber) {
 237         // TODO Auto-generated method stub
 238         return null;
 239     }
 240
 241     @Override
 242     public Boolean getPortBandwidth(Long portNumber) {
 243         // TODO Auto-generated method stub
 244         return null;
 245     }
 246
 247     @Override
 248     public boolean isPortEnabled(long portNumber) {
 249         // TODO Auto-generated method stub
 250         return false;
 251     }
 252
 253     @Override
 254     public boolean isPortEnabled(PortGrouping port) {
 255         // TODO Auto-generated method stub
 256         return false;
 257     }
 258
 259     @Override
 260     public List<PortGrouping> getEnabledPorts() {
 261         // TODO Auto-generated method stub
 262         return null;
 263     }
 264
 265     @Override
 266     public Map<Long, Boolean> getPortsBandwidth() {
 267         // TODO Auto-generated method stub
 268         return null;
 269     }
 270
 271     @Override
 272     public CompositeObjectRegistration<ModelDrivenSwitch> getProviderRegistration() {
 273         return registration;
 274     }
 275
 276     @Override
 277     public void setProviderRegistration(
 278             CompositeObjectRegistration<ModelDrivenSwitch> registration) {
 279         this.registration = registration;
 280     }
 281
 282     @Override
 283     public int getSeed() {
 284         return seed;
 285     }
 286
 287     /**
 288      * @param seed the seed to set
 289      */
 290     public void setSeed(int seed) {
 291         this.seed = seed;
 292     }
 293 }
 294
 295 class MockConnectionConductor implements ConnectionConductor {
 296
 297     private int conductorNum;
 298     private MockConnectionAdapter adapter;
 299
 300     public MockConnectionConductor(int conductorNumber) {
 301         conductorNum = conductorNumber;
 302         adapter = new MockConnectionAdapter();
 303     }
 304
 305     @Override
 306     public void init() {
 307         // TODO Auto-generated method stub
 308
 309     }
 310
 311     @Override
 312     public Short getVersion() {
 313         // TODO Auto-generated method stub
 314         return null;
 315     }
 316
 317     @Override
 318     public CONDUCTOR_STATE getConductorState() {
 319         // TODO Auto-generated method stub
 320         return null;
 321     }
 322
 323     @Override
 324     public void setConductorState(CONDUCTOR_STATE conductorState) {
 325         // TODO Auto-generated method stub
 326
 327     }
 328
 329     @Override
 330     public Future<Boolean> disconnect() {
 331         // TODO Auto-generated method stub
 332         return null;
 333     }
 334
 335     @Override
 336     public void setSessionContext(SessionContext context) {
 337         // TODO Auto-generated method stub
 338
 339     }
 340
 341     @Override
 342     public void setConnectionCookie(SwitchConnectionDistinguisher auxiliaryKey) {
 343         // TODO Auto-generated method stub
 344
 345     }
 346
 347     @Override
 348     public SessionContext getSessionContext() {
 349         // TODO Auto-generated method stub
 350         return null;
 351     }
 352
 353     @Override
 354     public SwitchConnectionDistinguisher getAuxiliaryKey() {
 355         if (0 != conductorNum) {
 356             SwitchConnectionCookieOFImpl key = new SwitchConnectionCookieOFImpl();
 357             key.setAuxiliaryId((short) conductorNum);
 358             key.init(42);
 359             return key;
 360         }
 361         return null;
 362     }
 363
 364     @Override
 365     public ConnectionAdapter getConnectionAdapter() {
 366         // TODO Auto-generated method stub
 367         return adapter;
 368     }
 369
 370     public MessageType getMessageType() {
 371         return adapter.getMessageType();
 372     }
 373
 374     @Override
 375     public void setQueueProcessor(QueueProcessor<OfHeader, DataObject> queueKeeper) {
 376         // NOOP
 377     }
 378
 379     @Override
 380     public void setErrorHandler(ErrorHandler errorHandler) {
 381         // NOOP
 382     }
 383
 384     @Override
 385     public void setId(int conductorId) {
 386         // NOOP
 387     }
 388 }
 389
 390 enum MessageType {
 391     NONE, BARRIER, FLOWMOD, TABLEMOD, PACKETOUT;
 392 }
 393
 394 class MockConnectionAdapter implements ConnectionAdapter {
 395
 396     private MessageType messageType;
 397     private ConnectionReadyListener connectionReadyListener;
 398
 399     public MockConnectionAdapter() {
 400         setMessageType(MessageType.NONE);
 401     }
 402
 403     @Override
 404     public Future<RpcResult<BarrierOutput>> barrier(BarrierInput input) {
 405         setMessageType(MessageType.BARRIER);
 406         return null;
 407     }
 408
 409     @Override
 410     public Future<RpcResult<EchoOutput>> echo(EchoInput input) {
 411         // TODO Auto-generated method stub
 412         return null;
 413     }
 414
 415     @Override
 416     public Future<RpcResult<Void>> echoReply(EchoReplyInput input) {
 417         // TODO Auto-generated method stub
 418         return null;
 419     }
 420
 421     @Override
 422     public Future<RpcResult<Void>> experimenter(ExperimenterInput input) {
 423         // TODO Auto-generated method stub
 424         return null;
 425     }
 426
 427     @Override
 428     public Future<RpcResult<Void>> flowMod(FlowModInput input) {
 429         setMessageType(MessageType.FLOWMOD);
 430         return null;
 431     }
 432
 433     @Override
 434     public Future<RpcResult<GetAsyncOutput>> getAsync(GetAsyncInput input) {
 435         // TODO Auto-generated method stub
 436         return null;
 437     }
 438
 439     @Override
 440     public Future<RpcResult<GetConfigOutput>> getConfig(GetConfigInput input) {
 441         // TODO Auto-generated method stub
 442         return null;
 443     }
 444
 445     @Override
 446     public Future<RpcResult<GetFeaturesOutput>> getFeatures(GetFeaturesInput input) {
 447         // TODO Auto-generated method stub
 448         return null;
 449     }
 450
 451     @Override
 452     public Future<RpcResult<GetQueueConfigOutput>> getQueueConfig(GetQueueConfigInput input) {
 453         // TODO Auto-generated method stub
 454         return null;
 455     }
 456
 457     @Override
 458     public Future<RpcResult<Void>> groupMod(GroupModInput input) {
 459         // TODO Auto-generated method stub
 460         return null;
 461     }
 462
 463     @Override
 464     public Future<RpcResult<Void>> hello(HelloInput input) {
 465         // TODO Auto-generated method stub
 466         return null;
 467     }
 468
 469     @Override
 470     public Future<RpcResult<Void>> meterMod(MeterModInput input) {
 471         // TODO Auto-generated method stub
 472         return null;
 473     }
 474
 475     @Override
 476     public Future<RpcResult<Void>> packetOut(PacketOutInput input) {
 477         setMessageType(MessageType.PACKETOUT);
 478         return null;
 479     }
 480
 481     @Override
 482     public Future<RpcResult<Void>> portMod(PortModInput input) {
 483         // TODO Auto-generated method stub
 484         return null;
 485     }
 486
 487     @Override
 488     public Future<RpcResult<RoleRequestOutput>> roleRequest(RoleRequestInput input) {
 489         // TODO Auto-generated method stub
 490         return null;
 491     }
 492
 493     @Override
 494     public Future<RpcResult<Void>> setAsync(SetAsyncInput input) {
 495         // TODO Auto-generated method stub
 496         return null;
 497     }
 498
 499     @Override
 500     public Future<RpcResult<Void>> setConfig(SetConfigInput input) {
 501         // TODO Auto-generated method stub
 502         return null;
 503     }
 504
 505     @Override
 506     public Future<RpcResult<Void>> tableMod(TableModInput input) {
 507         setMessageType(MessageType.TABLEMOD);
 508         return null;
 509     }
 510
 511     @Override
 512     public Future<Boolean> disconnect() {
 513         // TODO Auto-generated method stub
 514         return null;
 515     }
 516
 517     @Override
 518     public boolean isAlive() {
 519         // TODO Auto-generated method stub
 520         return false;
 521     }
 522
 523     @Override
 524     public void setMessageListener(OpenflowProtocolListener messageListener) {
 525         // TODO Auto-generated method stub
 526
 527     }
 528
 529     @Override
 530     public void setSystemListener(SystemNotificationsListener systemListener) {
 531         // TODO Auto-generated method stub
 532
 533     }
 534
 535     @Override
 536     public void checkListeners() {
 537         // TODO Auto-generated method stub
 538
 539     }
 540
 541     /**
 542      * @return the messageType
 543      */
 544     public MessageType getMessageType() {
 545         return messageType;
 546     }
 547
 548     /**
 549      * @param messageType the messageType to set
 550      */
 551     public void setMessageType(MessageType messageType) {
 552         this.messageType = messageType;
 553     }
 554
 555     @Override
 556     public void fireConnectionReadyNotification() {
 557         connectionReadyListener.onConnectionReady();
 558     }
 559
 560     @Override
 561     public void setConnectionReadyListener(
 562             ConnectionReadyListener connectionReadyListener) {
 563         this.connectionReadyListener = connectionReadyListener;
 564     }
 565
 566     @Override
 567     public Future<RpcResult<Void>> multipartRequest(
 568             MultipartRequestInput input) {
 569         // TODO Auto-generated method stub
 570         return null;
 571     }
 572 }