2 * Copyright (c) 2014 Pantheon Technologies s.r.o. and others. All rights reserved.
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
8 package org.opendaylight.openflowjava.protocol.impl.core.connection;
10 import com.google.common.collect.Lists;
11 import com.google.common.util.concurrent.ListenableFuture;
12 import java.net.InetAddress;
13 import java.net.UnknownHostException;
14 import org.junit.Assert;
15 import org.junit.Test;
16 import org.mockito.Mock;
17 import org.mockito.MockitoAnnotations;
18 import org.opendaylight.openflowjava.protocol.api.connection.SwitchConnectionHandler;
19 import org.opendaylight.openflowjava.protocol.api.connection.TlsConfiguration;
20 import org.opendaylight.openflowjava.protocol.api.connection.TlsConfigurationImpl;
21 import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
22 import org.opendaylight.openflowjava.protocol.api.extensibility.OFGeneralDeserializer;
23 import org.opendaylight.openflowjava.protocol.api.extensibility.OFGeneralSerializer;
24 import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
25 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterActionDeserializerKey;
26 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterActionSerializerKey;
27 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdDeserializerKey;
28 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdSerializerKey;
29 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterInstructionDeserializerKey;
30 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterInstructionSerializerKey;
31 import org.opendaylight.openflowjava.protocol.api.keys.MatchEntryDeserializerKey;
32 import org.opendaylight.openflowjava.protocol.api.keys.MatchEntrySerializerKey;
33 import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
34 import org.opendaylight.openflowjava.protocol.impl.core.ServerFacade;
35 import org.opendaylight.openflowjava.protocol.impl.core.SwitchConnectionProviderImpl;
36 import org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProvider;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.ExperimenterActionSubType;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.KeystoreType;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.PathType;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.TransportProtocol;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.InPort;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.OpenflowBasicClass;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ErrorMessage;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterInput;
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.meter.band.header.meter.band.MeterBandExperimenterCase;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestExperimenterCase;
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;
54 * @author michal.polkorab
56 public class SwitchConnectionProviderImpl02Test {
57 @Mock SwitchConnectionHandler handler;
58 @Mock OFGeneralSerializer serializer;
59 @Mock OFGeneralDeserializer deserializer;
60 @Mock OFDeserializer<ErrorMessage> deserializerError;
61 @Mock OFDeserializer<ExperimenterMessage> deserializerExpMsg;
62 @Mock OFDeserializer<MultipartReplyMessage> deserializerMultipartRplMsg;
63 @Mock OFDeserializer<QueueProperty> deserializerQueueProperty;
64 @Mock OFDeserializer<MeterBandExperimenterCase> deserializerMeterBandExpCase;
65 @Mock OFSerializer<ExperimenterInput> serializerExperimenterInput;
66 @Mock OFSerializer<MultipartRequestExperimenterCase> serializerMultipartRequestExpCase;
67 @Mock OFSerializer<MeterBandExperimenterCase> serializerMeterBandExpCase;
68 private static final int SWITCH_IDLE_TIMEOUT = 2000;
69 private InetAddress startupAddress;
70 private TlsConfiguration tlsConfiguration;
71 private SwitchConnectionProviderImpl provider;
72 private ConnectionConfigurationImpl config;
75 * Creates new {@link SwitchConnectionProvider} instance for each test
76 * @param protocol communication protocol
78 public void startUp(final TransportProtocol protocol) {
79 MockitoAnnotations.initMocks(this);
81 if (protocol != null) {
82 createConfig(protocol);
84 provider = new SwitchConnectionProviderImpl();
87 private void createConfig(final TransportProtocol protocol) {
89 startupAddress = InetAddress.getLocalHost();
90 } catch (final UnknownHostException e) {
93 tlsConfiguration = null;
94 if (protocol.equals(TransportProtocol.TLS)) {
95 tlsConfiguration = new TlsConfigurationImpl(KeystoreType.JKS,
96 "/selfSignedSwitch", PathType.CLASSPATH, KeystoreType.JKS,
97 "/selfSignedController", PathType.CLASSPATH,
98 Lists.newArrayList("TLS_RSA_WITH_AES_128_CBC_SHA", "TLS_RSA_WITH_AES_128_CBC_SHA256")) ;
100 config = new ConnectionConfigurationImpl(startupAddress, 0, tlsConfiguration, SWITCH_IDLE_TIMEOUT, true);
101 config.setTransferProtocol(protocol);
106 * Test getServerFacade
109 public void testServerFacade(){
110 startUp(TransportProtocol.TCP);
111 provider.setConfiguration(config);
112 final ListenableFuture<Boolean> future = provider.startup();
113 final ServerFacade serverFacade = provider.getServerFacade();
114 Assert.assertNotNull("Wrong -- getServerFacade return null",serverFacade);
118 * Test shutdown on unconfigured provider
120 @Test(expected = IllegalStateException.class)
121 public void testShutdownUnconfigured(){
122 startUp(TransportProtocol.TCP);
126 * Test unregister by wrong key
129 public void testUnregisterWrongKeys(){
130 startUp(TransportProtocol.TCP);
131 provider.setConfiguration(config);
132 final ExperimenterInstructionSerializerKey testSerKey
133 = new ExperimenterInstructionSerializerKey(EncodeConstants.OF10_VERSION_ID,42L);
134 Assert.assertFalse("Wrong -- unregisterSerializer",provider.unregisterSerializer(testSerKey));
135 final ExperimenterInstructionDeserializerKey tesDeserKey
136 = new ExperimenterInstructionDeserializerKey(EncodeConstants.OF10_VERSION_ID,24L);
137 Assert.assertFalse("Wrong -- unregisterDeserializer",provider.unregisterDeserializer(tesDeserKey));
141 * Test register and unregister method
144 public void testUnregisterExistingKeys(){
145 startUp(TransportProtocol.TCP);
146 provider.setConfiguration(config);
147 // -- registerActionSerializer
148 final 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 final 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 final 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 final 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 final 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 final 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 final 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 final 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 final 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 final 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 final 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 final 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 final 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 final 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 final 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 final 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));
245 private static class TestSubType extends ExperimenterActionSubType {
246 // empty class - only used in test for comparation