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