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