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