openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/core/connection/SwitchConnectionProviderImpl02Test.java

   1 /*
   2  * Copyright (c) 2014 Pantheon Technologies s.r.o. and others. 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.openflowjava.protocol.impl.core.connection;
   9
  10 import java.net.InetAddress;
  11 import java.net.UnknownHostException;
  12
  13 import org.junit.Assert;
  14 import org.junit.Test;
  15 import org.mockito.Mock;
  16 import org.mockito.MockitoAnnotations;
  17 import org.opendaylight.openflowjava.protocol.api.connection.SwitchConnectionHandler;
  18 import org.opendaylight.openflowjava.protocol.api.connection.TlsConfiguration;
  19 import org.opendaylight.openflowjava.protocol.api.connection.TlsConfigurationImpl;
  20 import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
  21 import org.opendaylight.openflowjava.protocol.api.extensibility.OFGeneralDeserializer;
  22 import org.opendaylight.openflowjava.protocol.api.extensibility.OFGeneralSerializer;
  23 import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
  24 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterActionDeserializerKey;
  25 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterActionSerializerKey;
  26 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdDeserializerKey;
  27 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdSerializerKey;
  28 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterInstructionDeserializerKey;
  29 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterInstructionSerializerKey;
  30 import org.opendaylight.openflowjava.protocol.api.keys.MatchEntryDeserializerKey;
  31 import org.opendaylight.openflowjava.protocol.api.keys.MatchEntrySerializerKey;
  32 import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
  33 import org.opendaylight.openflowjava.protocol.impl.core.ServerFacade;
  34 import org.opendaylight.openflowjava.protocol.impl.core.SwitchConnectionProviderImpl;
  35 import org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProvider;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.ExperimenterActionSubType;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.KeystoreType;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.PathType;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.TransportProtocol;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.InPort;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.OpenflowBasicClass;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ErrorMessage;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterInput;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterMessage;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReplyMessage;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.meter.band.MeterBandExperimenterCase;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestExperimenterCase;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.queue.property.header.QueueProperty;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.table.features.properties.grouping.TableFeatureProperties;
  50
  51 import com.google.common.util.concurrent.ListenableFuture;
  52
  53 /**
  54  * @author madamjak
  55  * @author michal.polkorab
  56  */
  57 public class SwitchConnectionProviderImpl02Test {
  58     @Mock SwitchConnectionHandler handler;
  59     @Mock OFGeneralSerializer serializer;
  60     @Mock OFGeneralDeserializer deserializer;
  61     @Mock OFDeserializer<ErrorMessage> deserializerError;
  62     @Mock OFDeserializer<ExperimenterMessage> deserializerExpMsg;
  63     @Mock OFDeserializer<MultipartReplyMessage> deserializerMultipartRplMsg;
  64     @Mock OFDeserializer<QueueProperty> deserializerQueueProperty;
  65     @Mock OFDeserializer<MeterBandExperimenterCase> deserializerMeterBandExpCase;
  66     @Mock OFSerializer<ExperimenterInput> serializerExperimenterInput;
  67     @Mock OFSerializer<MultipartRequestExperimenterCase> serializerMultipartRequestExpCase;
  68     @Mock OFSerializer<MeterBandExperimenterCase> serializerMeterBandExpCase;
  69     private static final int SWITCH_IDLE_TIMEOUT = 2000;
  70     private InetAddress startupAddress;
  71     private TlsConfiguration tlsConfiguration;
  72     private SwitchConnectionProviderImpl provider;
  73     private ConnectionConfigurationImpl config;
  74
  75     /**
  76      * Creates new {@link SwitchConnectionProvider} instance for each test
  77      * @param protocol communication protocol
  78      */
  79     public void startUp(TransportProtocol protocol) {
  80         MockitoAnnotations.initMocks(this);
  81         config = null;
  82         if (protocol != null) {
  83             createConfig(protocol);
  84         }
  85         provider = new SwitchConnectionProviderImpl();
  86     }
  87
  88     private void createConfig(TransportProtocol protocol) {
  89         try {
  90             startupAddress = InetAddress.getLocalHost();
  91         } catch (UnknownHostException e) {
  92             e.printStackTrace();
  93         }
  94         tlsConfiguration = null;
  95         if (protocol.equals(TransportProtocol.TLS)) {
  96             tlsConfiguration = new TlsConfigurationImpl(KeystoreType.JKS,
  97                     "/selfSignedSwitch", PathType.CLASSPATH, KeystoreType.JKS,
  98                     "/selfSignedController", PathType.CLASSPATH) ;
  99         }
 100         config = new ConnectionConfigurationImpl(startupAddress, 0, tlsConfiguration, SWITCH_IDLE_TIMEOUT);
 101         config.setTransferProtocol(protocol);
 102     }
 103
 104
 105     /**
 106      * Test getServerFacade
 107      */
 108     @Test
 109     public void testServerFacade(){
 110         startUp(TransportProtocol.TCP);
 111         provider.setConfiguration(config);
 112         ListenableFuture<Boolean> future = provider.startup();
 113         ServerFacade serverFacade = provider.getServerFacade();
 114         Assert.assertNotNull("Wrong -- getServerFacade return null",serverFacade);
 115     }
 116
 117     /**
 118      * Test shutdown on unconfigured provider
 119      */
 120     @Test(expected = IllegalStateException.class)
 121     public void testShutdownUnconfigured(){
 122         startUp(TransportProtocol.TCP);
 123         provider.shutdown();
 124     }
 125     /**
 126      * Test unregister by wrong key
 127      */
 128     @Test
 129     public void testUnregisterWrongKeys(){
 130         startUp(TransportProtocol.TCP);
 131         provider.setConfiguration(config);
 132         ExperimenterInstructionSerializerKey testSerKey
 133             = new ExperimenterInstructionSerializerKey(EncodeConstants.OF10_VERSION_ID,42L);
 134         Assert.assertFalse("Wrong -- unregisterSerializer",provider.unregisterSerializer(testSerKey));
 135         ExperimenterInstructionDeserializerKey tesDeserKey
 136             = new ExperimenterInstructionDeserializerKey(EncodeConstants.OF10_VERSION_ID,24L);
 137         Assert.assertFalse("Wrong -- unregisterDeserializer",provider.unregisterDeserializer(tesDeserKey));
 138     }
 139
 140     /**
 141      * Test register and unregister method
 142      */
 143     @Test
 144     public void testUnregisterExistingKeys(){
 145         startUp(TransportProtocol.TCP);
 146         provider.setConfiguration(config);
 147         // -- registerActionSerializer
 148         ExperimenterActionSerializerKey key1
 149             = new ExperimenterActionSerializerKey(EncodeConstants.OF10_VERSION_ID, 42L, TestSubType.class);
 150         provider.registerActionSerializer(key1, serializer);
 151         Assert.assertTrue("Wrong -- unregister ActionSerializer", provider.unregisterSerializer(key1));
 152         Assert.assertFalse("Wrong -- unregister ActionSerializer by not existing key", provider.unregisterSerializer(key1));
 153         // -- registerActionDeserializer
 154         ExperimenterActionDeserializerKey key2
 155             = new ExperimenterActionDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L);
 156         provider.registerActionDeserializer(key2, deserializer);
 157         Assert.assertTrue("Wrong -- unregister ActionDeserializer", provider.unregisterDeserializer(key2));
 158         Assert.assertFalse("Wrong -- unregister ActionDeserializer by not existing key", provider.unregisterDeserializer(key2));
 159         // -- registerInstructionSerializer
 160         ExperimenterInstructionSerializerKey key3
 161             = new ExperimenterInstructionSerializerKey(EncodeConstants.OF10_VERSION_ID,42L);
 162         provider.registerInstructionSerializer(key3, serializer);
 163         Assert.assertTrue("Wrong -- unregister InstructionSerializer", provider.unregisterSerializer(key3));
 164         Assert.assertFalse("Wrong -- unregister InstructionSerializer by not existing key", provider.unregisterSerializer(key3));
 165         // -- registerInstructionDeserializer
 166         ExperimenterInstructionDeserializerKey key4
 167             = new ExperimenterInstructionDeserializerKey(EncodeConstants.OF10_VERSION_ID,42L);
 168         provider.registerInstructionDeserializer(key4, deserializer);
 169         Assert.assertTrue("Wrong -- unregister InstructionDeserializer", provider.unregisterDeserializer(key4));
 170         Assert.assertFalse("Wrong -- unregister InstructionDeserializer by not existing key", provider.unregisterDeserializer(key4));
 171         // -- registerMatchEntryDeserializer
 172         MatchEntryDeserializerKey key5
 173             = new MatchEntryDeserializerKey(EncodeConstants.OF10_VERSION_ID, 0x8000, 42);
 174         provider.registerMatchEntryDeserializer(key5, deserializer);
 175         Assert.assertTrue("Wrong -- unregister MatchEntryDeserializer", provider.unregisterDeserializer(key5));
 176         Assert.assertFalse("Wrong -- unregister MatchEntryDeserializer by not existing key", provider.unregisterDeserializer(key5));
 177         // -- registerErrorDeserializer
 178         ExperimenterIdDeserializerKey key6
 179             = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, ErrorMessage.class);
 180         provider.registerErrorDeserializer(key6, deserializerError);
 181         Assert.assertTrue("Wrong -- unregister ErrorDeserializer", provider.unregisterDeserializer(key6));
 182         Assert.assertFalse("Wrong -- unregister ErrorDeserializer by not existing key", provider.unregisterDeserializer(key6));
 183         // -- registerExperimenterMessageDeserializer
 184         ExperimenterIdDeserializerKey key7
 185             = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, ExperimenterMessage.class);
 186         provider.registerExperimenterMessageDeserializer(key7, deserializerExpMsg);
 187         Assert.assertTrue("Wrong -- unregister ExperimenterMessageDeserializer", provider.unregisterDeserializer(key7));
 188         Assert.assertFalse("Wrong -- unregister ExperimenterMessageDeserializer by not existing key", provider.unregisterDeserializer(key7));
 189         // -- registerMultipartReplyMessageDeserializer
 190         ExperimenterIdDeserializerKey key8
 191             = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, MultipartReplyMessage.class);
 192         provider.registerMultipartReplyMessageDeserializer(key8, deserializerMultipartRplMsg);
 193         Assert.assertTrue("Wrong -- unregister MultipartReplyMessageDeserializer", provider.unregisterDeserializer(key8));
 194         Assert.assertFalse("Wrong -- unregister MultipartReplyMessageDeserializer by not existing key", provider.unregisterDeserializer(key8));
 195         // -- registerMultipartReplyTFDeserializer
 196         ExperimenterIdDeserializerKey key9 =
 197                 new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, MultipartReplyMessage.class);
 198         provider.registerMultipartReplyTFDeserializer(key9, deserializer);
 199         Assert.assertTrue("Wrong -- unregister MultipartReplyTFDeserializer", provider.unregisterDeserializer(key9));
 200         Assert.assertFalse("Wrong -- unregister MultipartReplyTFDeserializer by non existing key", provider.unregisterDeserializer(key9));
 201         // -- registerQueuePropertyDeserializer
 202         ExperimenterIdDeserializerKey key10
 203             = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, QueueProperty.class);
 204         provider.registerQueuePropertyDeserializer(key10, deserializerQueueProperty);
 205         Assert.assertTrue("Wrong -- unregister QueuePropertyDeserializer", provider.unregisterDeserializer(key10));
 206         Assert.assertFalse("Wrong -- unregister QueuePropertyDeserializer by not existing key", provider.unregisterDeserializer(key10));
 207         // -- registerMeterBandDeserializer
 208         ExperimenterIdDeserializerKey key11
 209             = new ExperimenterIdDeserializerKey(EncodeConstants.OF10_VERSION_ID, 42L, MeterBandExperimenterCase.class);
 210         provider.registerMeterBandDeserializer(key11, deserializerMeterBandExpCase);
 211         Assert.assertTrue("Wrong -- unregister MeterBandDeserializer", provider.unregisterDeserializer(key11));
 212         Assert.assertFalse("Wrong -- unregister MeterBandDeserializer by not existing key", provider.unregisterDeserializer(key11));
 213         // -- registerExperimenterMessageSerializer
 214         ExperimenterIdSerializerKey<ExperimenterInput> key12
 215             = new ExperimenterIdSerializerKey<>(EncodeConstants.OF10_VERSION_ID,42L,ExperimenterInput.class);
 216         provider.registerExperimenterMessageSerializer(key12, serializerExperimenterInput);
 217         Assert.assertTrue("Wrong -- unregister ExperimenterMessageSerializer", provider.unregisterSerializer(key12));
 218         Assert.assertFalse("Wrong -- unregister ExperimenterMessageSerializer by not existing key", provider.unregisterSerializer(key12));
 219         //registerMultipartRequestSerializer
 220         ExperimenterIdSerializerKey<MultipartRequestExperimenterCase> key13
 221             = new ExperimenterIdSerializerKey<>(EncodeConstants.OF10_VERSION_ID,42L,MultipartRequestExperimenterCase.class);
 222         provider.registerMultipartRequestSerializer(key13, serializerMultipartRequestExpCase);
 223         Assert.assertTrue("Wrong -- unregister MultipartRequestSerializer", provider.unregisterSerializer(key13));
 224         Assert.assertFalse("Wrong -- unregister MultipartRequestSerializer by not existing key", provider.unregisterSerializer(key13));
 225         // -- registerMultipartRequestTFSerializer
 226         ExperimenterIdSerializerKey<TableFeatureProperties> key14
 227             = new ExperimenterIdSerializerKey<>(EncodeConstants.OF10_VERSION_ID,42L,TableFeatureProperties.class);
 228         provider.registerMultipartRequestTFSerializer(key14, serializer);
 229         Assert.assertTrue("Wrong -- unregister MultipartRequestTFSerializer", provider.unregisterSerializer(key14));
 230         Assert.assertFalse("Wrong -- unregister MultipartRequestTFSerializer by not existing key", provider.unregisterSerializer(key14));
 231         // -- registerMeterBandSerializer
 232         ExperimenterIdSerializerKey<MeterBandExperimenterCase> key15
 233             = new ExperimenterIdSerializerKey<>(EncodeConstants.OF10_VERSION_ID,42L,MeterBandExperimenterCase.class);
 234         provider.registerMeterBandSerializer(key15, serializerMeterBandExpCase);
 235         Assert.assertTrue("Wrong -- unregister MeterBandSerializer", provider.unregisterSerializer(key15));
 236         Assert.assertFalse("Wrong -- unregister MeterBandSerializer by not existing key", provider.unregisterSerializer(key15));
 237         // -- registerMatchEntrySerializer
 238         MatchEntrySerializerKey<OpenflowBasicClass, InPort> key16
 239             = new MatchEntrySerializerKey<>(EncodeConstants.OF13_VERSION_ID, OpenflowBasicClass.class, InPort.class);
 240         provider.registerMatchEntrySerializer(key16, serializer);
 241         Assert.assertTrue("Wrong -- unregister MatchEntrySerializer", provider.unregisterSerializer(key16));
 242         Assert.assertFalse("Wrong -- unregister MatchEntrySerializer by not existing key", provider.unregisterSerializer(key15));
 243     }
 244
 245     private static class TestSubType extends ExperimenterActionSubType {
 246         // empty class - only used in test for comparation
 247     }
 248 }