Bug 6744 - the parameters of the function of registerMeterBandSerializer need to...

[openflowjava.git] / openflow-protocol-impl / src / main / java / org / opendaylight / openflowjava / protocol / impl / core / SwitchConnectionProviderImpl.java

diff --git a/openflow-protocol-impl/src/main/java/org/opendaylight/openflowjava/protocol/impl/core/SwitchConnectionProviderImpl.java b/openflow-protocol-impl/src/main/java/org/opendaylight/openflowjava/protocol/impl/core/SwitchConnectionProviderImpl.java
old mode 100644 (file)
new mode 100755 (executable)
index 5d6d26c..3658cb7
--- a/openflow-protocol-impl/src/main/java/org/opendaylight/openflowjava/protocol/impl/core/SwitchConnectionProviderImpl.java
+++ b/openflow-protocol-impl/src/main/java/org/opendaylight/openflowjava/protocol/impl/core/SwitchConnectionProviderImpl.java
@@ -24,6 +24,7 @@ import org.opendaylight.openflowjava.protocol.api.keys.ActionSerializerKey;
 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterActionDeserializerKey;
 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterDeserializerKey;
 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdDeserializerKey;
+import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdMeterSubTypeSerializerKey;
 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdSerializerKey;
 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterInstructionDeserializerKey;
 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterSerializerKey;
@@ -41,12 +42,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.T
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.MatchField;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.OxmClassBase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ErrorMessage;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterMessage;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReplyMessage;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.experimenter.core.ExperimenterDataOfChoice;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.meter.band.MeterBandExperimenterCase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestExperimenterCase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.queue.property.header.QueueProperty;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.table.features.properties.grouping.TableFeatureProperties;
 import org.slf4j.Logger;
@@ -61,15 +58,15 @@ import org.slf4j.LoggerFactory;
  */
 public class SwitchConnectionProviderImpl implements SwitchConnectionProvider, ConnectionInitializer {
 
-    private static final Logger LOGGER = LoggerFactory
+    private static final Logger LOG = LoggerFactory
             .getLogger(SwitchConnectionProviderImpl.class);
     private SwitchConnectionHandler switchConnectionHandler;
     private ServerFacade serverFacade;
     private ConnectionConfiguration connConfig;
-    private SerializationFactory serializationFactory;
-    private SerializerRegistry serializerRegistry;
-    private DeserializerRegistry deserializerRegistry;
-    private DeserializationFactory deserializationFactory;
+    private final SerializationFactory serializationFactory;
+    private final SerializerRegistry serializerRegistry;
+    private final DeserializerRegistry deserializerRegistry;
+    private final DeserializationFactory deserializationFactory;
     private TcpConnectionInitializer connectionInitializer;
 
     /** Constructor */
@@ -85,21 +82,21 @@ public class SwitchConnectionProviderImpl implements SwitchConnectionProvider, C
     }
 
     @Override
-    public void setConfiguration(ConnectionConfiguration connConfig) {
+    public void setConfiguration(final ConnectionConfiguration connConfig) {
         this.connConfig = connConfig;
     }
 
     @Override
-    public void setSwitchConnectionHandler(SwitchConnectionHandler switchConnectionHandler) {
-        LOGGER.debug("setSwitchConnectionHandler");
+    public void setSwitchConnectionHandler(final SwitchConnectionHandler switchConnectionHandler) {
+        LOG.debug("setSwitchConnectionHandler");
         this.switchConnectionHandler = switchConnectionHandler;
     }
 
     @Override
     public ListenableFuture<Boolean> shutdown() {
-        LOGGER.debug("Shutdown summoned");
+        LOG.debug("Shutdown summoned");
         if(serverFacade == null){
-            LOGGER.warn("Can not shutdown - not configured or started");
+            LOG.warn("Can not shutdown - not configured or started");
             throw new IllegalStateException("SwitchConnectionProvider is not started or not configured.");
         }
         return serverFacade.shutdown();
@@ -107,7 +104,7 @@ public class SwitchConnectionProviderImpl implements SwitchConnectionProvider, C
 
     @Override
     public ListenableFuture<Boolean> startup() {
-        LOGGER.debug("Startup summoned");
+        LOG.debug("Startup summoned");
         ListenableFuture<Boolean> result = null;
         try {
             serverFacade = createAndConfigureServer();
@@ -116,8 +113,8 @@ public class SwitchConnectionProviderImpl implements SwitchConnectionProvider, C
             }
             new Thread(serverFacade).start();
             result = serverFacade.getIsOnlineFuture();
-        } catch (Exception e) {
-            SettableFuture<Boolean> exResult = SettableFuture.create();
+        } catch (final Exception e) {
+            final SettableFuture<Boolean> exResult = SettableFuture.create();
             exResult.setException(e);
             result = exResult;
         }
@@ -128,22 +125,23 @@ public class SwitchConnectionProviderImpl implements SwitchConnectionProvider, C
      * @return
      */
     private ServerFacade createAndConfigureServer() {
-        LOGGER.debug("Configuring ..");
+        LOG.debug("Configuring ..");
         ServerFacade server = null;
-        ChannelInitializerFactory factory = new ChannelInitializerFactory();
+        final ChannelInitializerFactory factory = new ChannelInitializerFactory();
         factory.setSwitchConnectionHandler(switchConnectionHandler);
         factory.setSwitchIdleTimeout(connConfig.getSwitchIdleTimeout());
         factory.setTlsConfig(connConfig.getTlsConfiguration());
         factory.setSerializationFactory(serializationFactory);
         factory.setDeserializationFactory(deserializationFactory);
-        TransportProtocol transportProtocol = (TransportProtocol) connConfig.getTransferProtocol();
+        factory.setUseBarrier(connConfig.useBarrier());
+        final TransportProtocol transportProtocol = (TransportProtocol) connConfig.getTransferProtocol();
         if (transportProtocol.equals(TransportProtocol.TCP) || transportProtocol.equals(TransportProtocol.TLS)) {
             server = new TcpHandler(connConfig.getAddress(), connConfig.getPort());
-            TcpChannelInitializer channelInitializer = factory.createPublishingChannelInitializer();
+            final TcpChannelInitializer channelInitializer = factory.createPublishingChannelInitializer();
             ((TcpHandler) server).setChannelInitializer(channelInitializer);
             ((TcpHandler) server).initiateEventLoopGroups(connConfig.getThreadConfiguration());
 
-            NioEventLoopGroup workerGroupFromTcpHandler = ((TcpHandler) server).getWorkerGroup();
+            final NioEventLoopGroup workerGroupFromTcpHandler = ((TcpHandler) server).getWorkerGroup();
             connectionInitializer = new TcpConnectionInitializer(workerGroupFromTcpHandler);
             connectionInitializer.setChannelInitializer(channelInitializer);
             connectionInitializer.run();
@@ -170,84 +168,84 @@ public class SwitchConnectionProviderImpl implements SwitchConnectionProvider, C
     }
 
     @Override
-    public boolean unregisterSerializer(ExperimenterSerializerKey key) {
+    public boolean unregisterSerializer(final ExperimenterSerializerKey key) {
         return serializerRegistry.unregisterSerializer((MessageTypeKey<?>) key);
     }
 
     @Override
-    public boolean unregisterDeserializer(ExperimenterDeserializerKey key) {
+    public boolean unregisterDeserializer(final ExperimenterDeserializerKey key) {
         return deserializerRegistry.unregisterDeserializer((MessageCodeKey) key);
     }
 
     @Override
-    public void registerActionSerializer(ActionSerializerKey<?> key,
-            OFGeneralSerializer serializer) {
+    public void registerActionSerializer(final ActionSerializerKey<?> key,
+            final OFGeneralSerializer serializer) {
         serializerRegistry.registerSerializer(key, serializer);
     }
 
     @Override
-    public void registerActionDeserializer(ExperimenterActionDeserializerKey key,
-            OFGeneralDeserializer deserializer) {
+    public void registerActionDeserializer(final ExperimenterActionDeserializerKey key,
+            final OFGeneralDeserializer deserializer) {
         deserializerRegistry.registerDeserializer(key, deserializer);
     }
 
     @Override
-    public void registerInstructionSerializer(InstructionSerializerKey<?> key,
-            OFGeneralSerializer serializer) {
+    public void registerInstructionSerializer(final InstructionSerializerKey<?> key,
+            final OFGeneralSerializer serializer) {
         serializerRegistry.registerSerializer(key, serializer);
     }
 
     @Override
-    public void registerInstructionDeserializer(ExperimenterInstructionDeserializerKey key,
-            OFGeneralDeserializer deserializer) {
+    public void registerInstructionDeserializer(final ExperimenterInstructionDeserializerKey key,
+            final OFGeneralDeserializer deserializer) {
         deserializerRegistry.registerDeserializer(key, deserializer);
     }
 
     @Override
-    public <C extends OxmClassBase, F extends MatchField> void registerMatchEntrySerializer(MatchEntrySerializerKey<C, F> key,
-            OFGeneralSerializer serializer) {
+    public <C extends OxmClassBase, F extends MatchField> void registerMatchEntrySerializer(final MatchEntrySerializerKey<C, F> key,
+            final OFGeneralSerializer serializer) {
         serializerRegistry.registerSerializer(key, serializer);
     }
 
     @Override
-    public void registerMatchEntryDeserializer(MatchEntryDeserializerKey key,
-            OFGeneralDeserializer deserializer) {
+    public void registerMatchEntryDeserializer(final MatchEntryDeserializerKey key,
+            final OFGeneralDeserializer deserializer) {
         deserializerRegistry.registerDeserializer(key, deserializer);
     }
 
     @Override
-    public void registerErrorDeserializer(ExperimenterIdDeserializerKey key,
-            OFDeserializer<ErrorMessage> deserializer) {
+    public void registerErrorDeserializer(final ExperimenterIdDeserializerKey key,
+            final OFDeserializer<ErrorMessage> deserializer) {
         deserializerRegistry.registerDeserializer(key, deserializer);
     }
 
     @Override
     public void registerExperimenterMessageDeserializer(ExperimenterIdDeserializerKey key,
-            OFDeserializer<ExperimenterMessage> deserializer) {
+                                                        OFDeserializer<? extends ExperimenterDataOfChoice> deserializer) {
         deserializerRegistry.registerDeserializer(key, deserializer);
     }
 
     @Override
     public void registerMultipartReplyMessageDeserializer(ExperimenterIdDeserializerKey key,
-            OFDeserializer<MultipartReplyMessage> deserializer) {
+                                                          OFDeserializer<? extends ExperimenterDataOfChoice> deserializer) {
         deserializerRegistry.registerDeserializer(key, deserializer);
     }
 
     @Override
-    public void registerMultipartReplyTFDeserializer(ExperimenterIdDeserializerKey key,
-            OFGeneralDeserializer deserializer) {
+    public void registerMultipartReplyTFDeserializer(final ExperimenterIdDeserializerKey key,
+            final OFGeneralDeserializer deserializer) {
         deserializerRegistry.registerDeserializer(key, deserializer);
     }
 
     @Override
-    public void registerQueuePropertyDeserializer(ExperimenterIdDeserializerKey key,
-            OFDeserializer<QueueProperty> deserializer) {
+    public void registerQueuePropertyDeserializer(final ExperimenterIdDeserializerKey key,
+            final OFDeserializer<QueueProperty> deserializer) {
         deserializerRegistry.registerDeserializer(key, deserializer);
     }
 
     @Override
-    public void registerMeterBandDeserializer(ExperimenterIdDeserializerKey key,
-            OFDeserializer<MeterBandExperimenterCase> deserializer) {
+    public void registerMeterBandDeserializer(final ExperimenterIdDeserializerKey key,
+            final OFDeserializer<MeterBandExperimenterCase> deserializer) {
         deserializerRegistry.registerDeserializer(key, deserializer);
     }
 
@@ -264,20 +262,36 @@ public class SwitchConnectionProviderImpl implements SwitchConnectionProvider, C
     }
 
     @Override
-    public void registerMultipartRequestTFSerializer(ExperimenterIdSerializerKey<TableFeatureProperties> key,
-            OFGeneralSerializer serializer) {
+    public void registerMultipartRequestTFSerializer(final ExperimenterIdSerializerKey<TableFeatureProperties> key,
+            final OFGeneralSerializer serializer) {
         serializerRegistry.registerSerializer(key, serializer);
     }
 
     @Override
-    public void registerMeterBandSerializer(ExperimenterIdSerializerKey<MeterBandExperimenterCase> key,
-            OFSerializer<MeterBandExperimenterCase> serializer) {
+    /**
+     * @deprecated Since we have used ExperimenterIdMeterSubTypeSerializerKey as MeterBandSerializer's key, in order to avoid
+     * the occurrence of an error, we should discard this function
+     */
+    @Deprecated
+    public void registerMeterBandSerializer(final ExperimenterIdSerializerKey<MeterBandExperimenterCase> key,
+            final OFSerializer<MeterBandExperimenterCase> serializer) {
         serializerRegistry.registerSerializer(key, serializer);
     }
 
     @Override
-    public void initiateConnection(String host, int port) {
+    public void registerMeterBandSerializer(final ExperimenterIdMeterSubTypeSerializerKey<MeterBandExperimenterCase> key,
+                                            final OFSerializer<MeterBandExperimenterCase> serializer) {
+        serializerRegistry.registerSerializer(key, serializer);
+    }
+
+    @Override
+    public void initiateConnection(final String host, final int port) {
         connectionInitializer.initiateConnection(host, port);
     }
 
+    @Override
+    public ConnectionConfiguration getConfiguration() {
+        return this.connConfig;
+    }
+
 }