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