import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
-import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.epoll.Epoll;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionConfiguration;
import org.opendaylight.openflowjava.protocol.api.connection.SwitchConnectionHandler;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
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;
import org.opendaylight.openflowjava.protocol.impl.deserialization.DeserializerRegistryImpl;
import org.opendaylight.openflowjava.protocol.impl.serialization.SerializationFactory;
import org.opendaylight.openflowjava.protocol.impl.serialization.SerializerRegistryImpl;
+import org.opendaylight.openflowjava.protocol.api.keys.TypeToClassKey;
import org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.TransportProtocol;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.MatchField;
*/
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;
@Override
public void setSwitchConnectionHandler(final SwitchConnectionHandler switchConnectionHandler) {
- LOGGER.debug("setSwitchConnectionHandler");
+ 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();
@Override
public ListenableFuture<Boolean> startup() {
- LOGGER.debug("Startup summoned");
+ LOG.debug("Startup summoned");
ListenableFuture<Boolean> result = null;
try {
serverFacade = createAndConfigureServer();
* @return
*/
private ServerFacade createAndConfigureServer() {
- LOGGER.debug("Configuring ..");
+ LOG.debug("Configuring ..");
ServerFacade server = null;
final ChannelInitializerFactory factory = new ChannelInitializerFactory();
factory.setSwitchConnectionHandler(switchConnectionHandler);
factory.setDeserializationFactory(deserializationFactory);
factory.setUseBarrier(connConfig.useBarrier());
final TransportProtocol transportProtocol = (TransportProtocol) connConfig.getTransferProtocol();
- if (transportProtocol.equals(TransportProtocol.TCP) || transportProtocol.equals(TransportProtocol.TLS)) {
+
+ // Check if Epoll native transport is available.
+ // TODO : Add option to disable Epoll.
+ boolean isEpollEnabled = Epoll.isAvailable();
+
+ if ((TransportProtocol.TCP.equals(transportProtocol) || TransportProtocol.TLS.equals(transportProtocol))) {
server = new TcpHandler(connConfig.getAddress(), connConfig.getPort());
final TcpChannelInitializer channelInitializer = factory.createPublishingChannelInitializer();
((TcpHandler) server).setChannelInitializer(channelInitializer);
- ((TcpHandler) server).initiateEventLoopGroups(connConfig.getThreadConfiguration());
+ ((TcpHandler) server).initiateEventLoopGroups(connConfig.getThreadConfiguration(), isEpollEnabled);
- final NioEventLoopGroup workerGroupFromTcpHandler = ((TcpHandler) server).getWorkerGroup();
- connectionInitializer = new TcpConnectionInitializer(workerGroupFromTcpHandler);
+ final EventLoopGroup workerGroupFromTcpHandler = ((TcpHandler) server).getWorkerGroup();
+ connectionInitializer = new TcpConnectionInitializer(workerGroupFromTcpHandler, isEpollEnabled);
connectionInitializer.setChannelInitializer(channelInitializer);
connectionInitializer.run();
- } else if (transportProtocol.equals(TransportProtocol.UDP)){
+ } else if (TransportProtocol.UDP.equals(transportProtocol)){
server = new UdpHandler(connConfig.getAddress(), connConfig.getPort());
+ ((UdpHandler) server).initiateEventLoopGroups(connConfig.getThreadConfiguration(), isEpollEnabled);
((UdpHandler) server).setChannelInitializer(factory.createUdpChannelInitializer());
} else {
throw new IllegalStateException("Unknown transport protocol received: " + transportProtocol);
}
@Override
+ /**
+ * @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 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;
+ }
+
+ @Override
+ public <K> void registerSerializer(MessageTypeKey<K> key, OFGeneralSerializer serializer) {
+ serializerRegistry.registerSerializer(key, serializer);
+ }
+
+ @Override
+ public void registerDeserializer(MessageCodeKey key, OFGeneralDeserializer deserializer) {
+ deserializerRegistry.registerDeserializer(key, deserializer);
+ }
+
+ @Override
+ public void registerDeserializerMapping(final TypeToClassKey key, final Class<?> clazz) {
+ deserializationFactory.registerMapping(key, clazz);
+ }
+
+ @Override
+ public boolean unregisterDeserializerMapping(final TypeToClassKey key) {
+ return deserializationFactory.unregisterMapping(key);
+ }
}