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 java.net.InetSocketAddress;
  11 import java.util.HashMap;
  12 import java.util.Iterator;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.Map.Entry;
  16 import java.util.Set;
  17 import java.util.concurrent.ExecutionException;
  18 import java.util.concurrent.Future;
  19
  20 import org.junit.Assert;
  21 import org.junit.Before;
  22 import org.junit.Test;
  23 import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
  24 import org.opendaylight.openflowjava.protocol.api.connection.ConnectionReadyListener;
  25 import org.opendaylight.openflowplugin.api.openflow.md.core.session.IMessageDispatchService;
  26 import org.opendaylight.openflowplugin.api.openflow.md.core.session.SessionContext;
  27 import org.opendaylight.openflowplugin.api.openflow.md.core.session.SwitchSessionKeyOF;
  28 import org.opendaylight.openflowplugin.api.openflow.md.ModelDrivenSwitch;
  29 import org.opendaylight.openflowplugin.api.OFConstants;
  30 import org.opendaylight.openflowplugin.api.openflow.md.core.ConnectionConductor;
  31 import org.opendaylight.openflowplugin.api.openflow.md.core.ErrorHandler;
  32 import org.opendaylight.openflowplugin.api.openflow.md.core.NotificationEnqueuer;
  33 import org.opendaylight.openflowplugin.api.openflow.md.core.NotificationQueueWrapper;
  34 import org.opendaylight.openflowplugin.api.openflow.md.core.SwitchConnectionDistinguisher;
  35 import org.opendaylight.openflowplugin.api.openflow.md.queue.QueueProcessor;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.BarrierInput;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.BarrierInputBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.BarrierOutput;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.EchoInput;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.EchoOutput;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.EchoReplyInput;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterInput;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterInputBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FlowModInput;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncInput;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncInputBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncOutput;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetConfigInput;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetConfigInputBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetConfigOutput;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesInput;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesInputBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesOutput;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetQueueConfigInput;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetQueueConfigInputBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetQueueConfigOutput;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GroupModInput;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.HelloInput;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MeterModInput;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartRequestInput;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartRequestInputBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OpenflowProtocolListener;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketOutInput;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketOutInputBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortGrouping;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortModInput;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.RoleRequestInput;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.RoleRequestInputBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.RoleRequestOutput;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.SetAsyncInput;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.SetConfigInput;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.TableModInput;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.TableModInputBuilder;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.system.rev130927.SystemNotificationsListener;
  76 import org.opendaylight.yangtools.concepts.CompositeObjectRegistration;
  77 import org.opendaylight.yangtools.yang.binding.DataObject;
  78 import org.opendaylight.yangtools.yang.common.RpcError;
  79 import org.opendaylight.yangtools.yang.common.RpcResult;
  80
  81 /**
  82  * test for {@link MessageDispatchServiceImpl}
  83  */
  84 public class MessageDispatchServiceImplTest {
  85
  86     MockSessionContext session;
  87
  88     /**
  89      * @throws java.lang.Exception
  90      */
  91     @Before
  92     public void setUp() throws Exception {
  93         session = new MockSessionContext(0);
  94
  95     }
  96
  97     /**
  98      * Test barrier message for null cookie
  99      *
 100      * @throws Exception
 101      */
 102     @Test
 103     public void testBarrierMessageForPrimary() throws Exception {
 104         MockConnectionConductor conductor = new MockConnectionConductor(1);
 105         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 106         BarrierInputBuilder barrierMsg = new BarrierInputBuilder();
 107         session.getMessageDispatchService().barrier(barrierMsg.build(), cookie);
 108         Assert.assertEquals(MessageType.BARRIER, session.getPrimaryConductor().getMessageType());
 109     }
 110
 111     /**
 112      * Test experimenter message for null cookie
 113      */
 114     @Test
 115     public void testExperimenter() {
 116         MockConnectionConductor conductor = new MockConnectionConductor(1);
 117         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 118         ExperimenterInputBuilder experimenterInputBuilder = new ExperimenterInputBuilder();
 119         session.getMessageDispatchService().experimenter(experimenterInputBuilder.build(), cookie);
 120         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor().getMessageType());
 121     }
 122
 123     /**
 124      * Test get async input with null cookie
 125      */
 126     @Test
 127     public void testGetAsync() throws ExecutionException, InterruptedException {
 128         MockConnectionConductor conductor = new MockConnectionConductor(1);
 129         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 130         GetAsyncInputBuilder getAsyncInputBuilder = new GetAsyncInputBuilder();
 131         session.getMessageDispatchService().getAsync(getAsyncInputBuilder.build(), cookie);
 132         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor().getMessageType());
 133     }
 134
 135     /**
 136      * Test get async output with null cookie
 137      */
 138     @Test
 139     public void testGetConfig() {
 140         MockConnectionConductor conductor = new MockConnectionConductor(1);
 141         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 142         GetConfigInputBuilder getConfigInputBuilder = new GetConfigInputBuilder();
 143         session.getMessageDispatchService().getConfig(getConfigInputBuilder.build(), cookie);
 144         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor().getMessageType());
 145     }
 146
 147     /**
 148      * Test get features with null cookie
 149      */
 150     @Test
 151     public void testGetFeatures() {
 152         MockConnectionConductor conductor = new MockConnectionConductor(1);
 153         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 154         GetFeaturesInputBuilder getFeaturesInputBuilder = new GetFeaturesInputBuilder();
 155         session.getMessageDispatchService().getFeatures(getFeaturesInputBuilder.build(), cookie);
 156         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor().getMessageType());
 157     }
 158
 159     /**
 160      * Test get queue config with null cookie
 161      */
 162     @Test
 163     public void testGetQueueConfig() {
 164         MockConnectionConductor conductor = new MockConnectionConductor(1);
 165         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 166         GetQueueConfigInputBuilder getQueueConfigInputBuilder = new GetQueueConfigInputBuilder();
 167         session.getMessageDispatchService().getQueueConfig(getQueueConfigInputBuilder.build(), cookie);
 168         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor().getMessageType());
 169     }
 170
 171     /**
 172      * Test multipart request with null cookie
 173      */
 174     @Test
 175     public void testGetMultipart() {
 176         MockConnectionConductor conductor = new MockConnectionConductor(1);
 177         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 178         MultipartRequestInputBuilder multipartRequestInputBuilder = new MultipartRequestInputBuilder();
 179         session.getMessageDispatchService().multipartRequest(multipartRequestInputBuilder.build(), cookie);
 180         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor().getMessageType());
 181     }
 182
 183     /**
 184      * Test role request with null cookie
 185      */
 186     @Test
 187     public void testRoleRequest() {
 188         MockConnectionConductor conductor = new MockConnectionConductor(1);
 189         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 190         RoleRequestInputBuilder roleRequestInputBuilder = new RoleRequestInputBuilder();
 191         session.getMessageDispatchService().roleRequest(roleRequestInputBuilder.build(), cookie);
 192         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor().getMessageType());
 193     }
 194
 195     /**
 196      * Test table mod with null cookie
 197      */
 198     @Test
 199     public void testTableMod() {
 200         MockConnectionConductor conductor = new MockConnectionConductor(1);
 201         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 202         TableModInputBuilder tableModInputBuilder = new TableModInputBuilder();
 203         session.getMessageDispatchService().tableMod(tableModInputBuilder.build(), cookie);
 204         Assert.assertEquals(MessageType.TABLEMOD, session.getPrimaryConductor().getMessageType());
 205     }
 206
 207
 208     /**
 209      * Test packet out message for primary connection
 210      *
 211      * @throws Exception
 212      */
 213     @Test
 214     public void testPacketOutMessageForPrimary() throws Exception {
 215         session.getMessageDispatchService().packetOut(null, null);
 216         Assert.assertEquals(MessageType.PACKETOUT, session.getPrimaryConductor().getMessageType());
 217     }
 218
 219     /**
 220      * Test packet out message for auxiliary connection
 221      *
 222      * @throws Exception
 223      */
 224     @Test
 225     public void testPacketOutMessageForAuxiliary() throws Exception {
 226         MockConnectionConductor conductor = new MockConnectionConductor(1);
 227         SwitchConnectionDistinguisher cookie = conductor.getAuxiliaryKey();
 228         session.addAuxiliaryConductor(cookie, conductor);
 229         session.getMessageDispatchService().packetOut(null, cookie);
 230         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor().getMessageType());
 231         conductor = (MockConnectionConductor) session.getAuxiliaryConductor(cookie);
 232         Assert.assertEquals(MessageType.PACKETOUT, conductor.getMessageType());
 233     }
 234
 235     /**
 236      * Test packet out message when multiple auxiliary connection exist
 237      *
 238      * @throws Exception
 239      */
 240     @Test
 241     public void testPacketOutMessageForMultipleAuxiliary() throws Exception {
 242         MockConnectionConductor conductor1 = new MockConnectionConductor(1);
 243         SwitchConnectionDistinguisher cookie1 = conductor1.getAuxiliaryKey();
 244         session.addAuxiliaryConductor(cookie1, conductor1);
 245         MockConnectionConductor conductor2 = new MockConnectionConductor(2);
 246         SwitchConnectionDistinguisher cookie2 = conductor2.getAuxiliaryKey();
 247         session.addAuxiliaryConductor(cookie2, conductor2);
 248         MockConnectionConductor conductor3 = new MockConnectionConductor(3);
 249         SwitchConnectionDistinguisher cookie3 = conductor3.getAuxiliaryKey();
 250         session.addAuxiliaryConductor(cookie3, conductor3);
 251         PacketOutInputBuilder builder = new PacketOutInputBuilder();
 252         // send message
 253         session.getMessageDispatchService().packetOut(builder.build(), cookie2);
 254
 255         Assert.assertEquals(MessageType.NONE, session.getPrimaryConductor().getMessageType());
 256
 257         conductor3 = (MockConnectionConductor) session.getAuxiliaryConductor(cookie3);
 258         Assert.assertEquals(MessageType.NONE, conductor3.getMessageType());
 259
 260         conductor2 = (MockConnectionConductor) session.getAuxiliaryConductor(cookie2);
 261         Assert.assertEquals(MessageType.PACKETOUT, conductor2.getMessageType());
 262
 263         conductor1 = (MockConnectionConductor) session.getAuxiliaryConductor(cookie1);
 264         Assert.assertEquals(MessageType.NONE, conductor1.getMessageType());
 265
 266     }
 267
 268     /**
 269      * Test for invalid session
 270      *
 271      * @throws Exception
 272      */
 273     @Test
 274     public void testInvalidSession() throws Exception {
 275         session.setValid(false);
 276         Future<RpcResult<Void>> resultFuture = session.getMessageDispatchService().packetOut(null, null);
 277         if (resultFuture.isDone()) {
 278             RpcResult<Void> rpcResult = resultFuture.get();
 279             Assert.assertTrue(!rpcResult.getErrors().isEmpty());
 280
 281             Iterator<RpcError> it = rpcResult.getErrors().iterator();
 282             RpcError rpcError = it.next();
 283
 284             Assert.assertTrue(rpcError.getApplicationTag().equals(OFConstants.APPLICATION_TAG));
 285             Assert.assertTrue(rpcError.getTag().equals(OFConstants.ERROR_TAG_TIMEOUT));
 286             Assert.assertTrue(rpcError.getErrorType().equals(RpcError.ErrorType.TRANSPORT));
 287         }
 288     }
 289
 290 }
 291
 292 class MockSessionContext implements SessionContext {
 293     private MockConnectionConductor conductor;
 294     private Map<SwitchConnectionDistinguisher, ConnectionConductor> map;
 295     private IMessageDispatchService messageService;
 296     private boolean isValid = true;
 297     private CompositeObjectRegistration<ModelDrivenSwitch> registration;
 298     private int seed;
 299
 300     MockSessionContext(int conductorNum) {
 301         conductor = new MockConnectionConductor(conductorNum);
 302         map = new HashMap<SwitchConnectionDistinguisher, ConnectionConductor>();
 303         messageService = new MessageDispatchServiceImpl(this);
 304     }
 305
 306     @Override
 307     public MockConnectionConductor getPrimaryConductor() {
 308         // TODO Auto-generated method stub
 309         return conductor;
 310     }
 311
 312     @Override
 313     public GetFeaturesOutput getFeatures() {
 314         // TODO Auto-generated method stub
 315         return null;
 316     }
 317
 318     @Override
 319     public ConnectionConductor getAuxiliaryConductor(SwitchConnectionDistinguisher auxiliaryKey) {
 320
 321         return map.get(auxiliaryKey);
 322     }
 323
 324     @Override
 325     public Set<Entry<SwitchConnectionDistinguisher, ConnectionConductor>> getAuxiliaryConductors() {
 326         // TODO Auto-generated method stub
 327         return null;
 328     }
 329
 330     @Override
 331     public void addAuxiliaryConductor(SwitchConnectionDistinguisher auxiliaryKey, ConnectionConductor conductorArg) {
 332         map.put(auxiliaryKey, conductorArg);
 333     }
 334
 335     @Override
 336     public ConnectionConductor removeAuxiliaryConductor(SwitchConnectionDistinguisher connectionCookie) {
 337         return map.remove(connectionCookie);
 338     }
 339
 340     @Override
 341     public boolean isValid() {
 342         // TODO Auto-generated method stub
 343         return isValid;
 344     }
 345
 346     @Override
 347     public void setValid(boolean valid) {
 348         isValid = valid;
 349     }
 350
 351     @Override
 352     public SwitchSessionKeyOF getSessionKey() {
 353         // TODO Auto-generated method stub
 354         return null;
 355     }
 356
 357     @Override
 358     public IMessageDispatchService getMessageDispatchService() {
 359         // TODO Auto-generated method stub
 360         return messageService;
 361     }
 362
 363     @Override
 364     public Long getNextXid() {
 365         // TODO Auto-generated method stub
 366         return null;
 367     }
 368
 369     @Override
 370     public Map<Long, PortGrouping> getPhysicalPorts() {
 371         // TODO Auto-generated method stub
 372         return null;
 373     }
 374
 375     @Override
 376     public Set<Long> getPorts() {
 377         // TODO Auto-generated method stub
 378         return null;
 379     }
 380
 381     @Override
 382     public PortGrouping getPhysicalPort(Long portNumber) {
 383         // TODO Auto-generated method stub
 384         return null;
 385     }
 386
 387     @Override
 388     public Boolean getPortBandwidth(Long portNumber) {
 389         // TODO Auto-generated method stub
 390         return null;
 391     }
 392
 393     @Override
 394     public boolean isPortEnabled(long portNumber) {
 395         // TODO Auto-generated method stub
 396         return false;
 397     }
 398
 399     @Override
 400     public boolean isPortEnabled(PortGrouping port) {
 401         // TODO Auto-generated method stub
 402         return false;
 403     }
 404
 405     @Override
 406     public List<PortGrouping> getEnabledPorts() {
 407         // TODO Auto-generated method stub
 408         return null;
 409     }
 410
 411     @Override
 412     public Map<Long, Boolean> getPortsBandwidth() {
 413         // TODO Auto-generated method stub
 414         return null;
 415     }
 416
 417     @Override
 418     public CompositeObjectRegistration<ModelDrivenSwitch> getProviderRegistration() {
 419         return registration;
 420     }
 421
 422     @Override
 423     public void setProviderRegistration(
 424             CompositeObjectRegistration<ModelDrivenSwitch> registration) {
 425         this.registration = registration;
 426     }
 427
 428     @Override
 429     public int getSeed() {
 430         return seed;
 431     }
 432
 433     /**
 434      * @param seed the seed to set
 435      */
 436     public void setSeed(int seed) {
 437         this.seed = seed;
 438     }
 439
 440     @Override
 441     public NotificationEnqueuer getNotificationEnqueuer() {
 442         return conductor;
 443     }
 444 }
 445
 446 class MockConnectionConductor implements ConnectionConductor, NotificationEnqueuer {
 447
 448     private int conductorNum;
 449     private MockConnectionAdapter adapter;
 450
 451     public MockConnectionConductor(int conductorNumber) {
 452         conductorNum = conductorNumber;
 453         adapter = new MockConnectionAdapter();
 454     }
 455
 456     @Override
 457     public void init() {
 458         // TODO Auto-generated method stub
 459
 460     }
 461
 462     @Override
 463     public Short getVersion() {
 464         // TODO Auto-generated method stub
 465         return null;
 466     }
 467
 468     @Override
 469     public CONDUCTOR_STATE getConductorState() {
 470         // TODO Auto-generated method stub
 471         return null;
 472     }
 473
 474     @Override
 475     public void setConductorState(CONDUCTOR_STATE conductorState) {
 476         // TODO Auto-generated method stub
 477
 478     }
 479
 480     @Override
 481     public Future<Boolean> disconnect() {
 482         // TODO Auto-generated method stub
 483         return null;
 484     }
 485
 486     @Override
 487     public void setSessionContext(SessionContext context) {
 488         // TODO Auto-generated method stub
 489
 490     }
 491
 492     @Override
 493     public void setConnectionCookie(SwitchConnectionDistinguisher auxiliaryKey) {
 494         // TODO Auto-generated method stub
 495
 496     }
 497
 498     @Override
 499     public SessionContext getSessionContext() {
 500         // TODO Auto-generated method stub
 501         return null;
 502     }
 503
 504     @Override
 505     public SwitchConnectionDistinguisher getAuxiliaryKey() {
 506         if (0 != conductorNum) {
 507             SwitchConnectionCookieOFImpl key = new SwitchConnectionCookieOFImpl();
 508             key.setAuxiliaryId((short) conductorNum);
 509             key.init(42);
 510             return key;
 511         }
 512         return null;
 513     }
 514
 515     @Override
 516     public ConnectionAdapter getConnectionAdapter() {
 517         // TODO Auto-generated method stub
 518         return adapter;
 519     }
 520
 521     public MessageType getMessageType() {
 522         return adapter.getMessageType();
 523     }
 524
 525     @Override
 526     public void setQueueProcessor(QueueProcessor<OfHeader, DataObject> queueKeeper) {
 527         // NOOP
 528     }
 529
 530     @Override
 531     public void setErrorHandler(ErrorHandler errorHandler) {
 532         // NOOP
 533     }
 534
 535     @Override
 536     public void setId(int conductorId) {
 537         // NOOP
 538     }
 539
 540     @Override
 541     public void enqueueNotification(NotificationQueueWrapper notification) {
 542         // NOOP
 543     }
 544 }
 545
 546 enum MessageType {
 547     NONE, BARRIER, FLOWMOD, TABLEMOD, PACKETOUT;
 548 }
 549
 550 class MockConnectionAdapter implements ConnectionAdapter {
 551
 552     private MessageType messageType;
 553     private ConnectionReadyListener connectionReadyListener;
 554
 555     public MockConnectionAdapter() {
 556         setMessageType(MessageType.NONE);
 557     }
 558
 559     @Override
 560     public Future<RpcResult<BarrierOutput>> barrier(BarrierInput input) {
 561         setMessageType(MessageType.BARRIER);
 562         return null;
 563     }
 564
 565     @Override
 566     public Future<RpcResult<EchoOutput>> echo(EchoInput input) {
 567         // TODO Auto-generated method stub
 568         return null;
 569     }
 570
 571     @Override
 572     public Future<RpcResult<Void>> echoReply(EchoReplyInput input) {
 573         // TODO Auto-generated method stub
 574         return null;
 575     }
 576
 577     @Override
 578     public Future<RpcResult<Void>> experimenter(ExperimenterInput input) {
 579         // TODO Auto-generated method stub
 580         return null;
 581     }
 582
 583     @Override
 584     public Future<RpcResult<Void>> flowMod(FlowModInput input) {
 585         setMessageType(MessageType.FLOWMOD);
 586         return null;
 587     }
 588
 589     @Override
 590     public Future<RpcResult<GetAsyncOutput>> getAsync(GetAsyncInput input) {
 591         // TODO Auto-generated method stub
 592         return null;
 593     }
 594
 595     @Override
 596     public Future<RpcResult<GetConfigOutput>> getConfig(GetConfigInput input) {
 597         // TODO Auto-generated method stub
 598         return null;
 599     }
 600
 601     @Override
 602     public Future<RpcResult<GetFeaturesOutput>> getFeatures(GetFeaturesInput input) {
 603         // TODO Auto-generated method stub
 604         return null;
 605     }
 606
 607     @Override
 608     public Future<RpcResult<GetQueueConfigOutput>> getQueueConfig(GetQueueConfigInput input) {
 609         // TODO Auto-generated method stub
 610         return null;
 611     }
 612
 613     @Override
 614     public Future<RpcResult<Void>> groupMod(GroupModInput input) {
 615         // TODO Auto-generated method stub
 616         return null;
 617     }
 618
 619     @Override
 620     public Future<RpcResult<Void>> hello(HelloInput input) {
 621         // TODO Auto-generated method stub
 622         return null;
 623     }
 624
 625     @Override
 626     public Future<RpcResult<Void>> meterMod(MeterModInput input) {
 627         // TODO Auto-generated method stub
 628         return null;
 629     }
 630
 631     @Override
 632     public Future<RpcResult<Void>> packetOut(PacketOutInput input) {
 633         setMessageType(MessageType.PACKETOUT);
 634         return null;
 635     }
 636
 637     @Override
 638     public Future<RpcResult<Void>> portMod(PortModInput input) {
 639         // TODO Auto-generated method stub
 640         return null;
 641     }
 642
 643     @Override
 644     public Future<RpcResult<RoleRequestOutput>> roleRequest(RoleRequestInput input) {
 645         // TODO Auto-generated method stub
 646         return null;
 647     }
 648
 649     @Override
 650     public Future<RpcResult<Void>> setAsync(SetAsyncInput input) {
 651         // TODO Auto-generated method stub
 652         return null;
 653     }
 654
 655     @Override
 656     public Future<RpcResult<Void>> setConfig(SetConfigInput input) {
 657         // TODO Auto-generated method stub
 658         return null;
 659     }
 660
 661     @Override
 662     public Future<RpcResult<Void>> tableMod(TableModInput input) {
 663         setMessageType(MessageType.TABLEMOD);
 664         return null;
 665     }
 666
 667     @Override
 668     public Future<Boolean> disconnect() {
 669         // TODO Auto-generated method stub
 670         return null;
 671     }
 672
 673     @Override
 674     public boolean isAlive() {
 675         // TODO Auto-generated method stub
 676         return false;
 677     }
 678
 679     @Override
 680     public void setMessageListener(OpenflowProtocolListener messageListener) {
 681         // TODO Auto-generated method stub
 682
 683     }
 684
 685     @Override
 686     public void setSystemListener(SystemNotificationsListener systemListener) {
 687         // TODO Auto-generated method stub
 688
 689     }
 690
 691     @Override
 692     public void checkListeners() {
 693         // TODO Auto-generated method stub
 694
 695     }
 696
 697     /**
 698      * @return the messageType
 699      */
 700     public MessageType getMessageType() {
 701         return messageType;
 702     }
 703
 704     /**
 705      * @param messageType the messageType to set
 706      */
 707     public void setMessageType(MessageType messageType) {
 708         this.messageType = messageType;
 709     }
 710
 711     @Override
 712     public void fireConnectionReadyNotification() {
 713         connectionReadyListener.onConnectionReady();
 714     }
 715
 716     @Override
 717     public void setConnectionReadyListener(
 718             ConnectionReadyListener connectionReadyListener) {
 719         this.connectionReadyListener = connectionReadyListener;
 720     }
 721
 722     @Override
 723     public Future<RpcResult<Void>> multipartRequest(
 724             MultipartRequestInput input) {
 725         // TODO Auto-generated method stub
 726         return null;
 727     }
 728
 729     /* (non-Javadoc)
 730      * @see org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter#getRemoteAddress()
 731      */
 732     @Override
 733     public InetSocketAddress getRemoteAddress() {
 734         // TODO Auto-generated method stub
 735         return null;
 736     }
 737 }