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

   1 /*
   2  * Copyright (c) 2013 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
   9
  10 package org.opendaylight.openflowjava.protocol.impl.core;
  11
  12 import com.google.common.util.concurrent.ListenableFuture;
  13 import com.google.common.util.concurrent.SettableFuture;
  14 import io.netty.channel.nio.NioEventLoopGroup;
  15 import org.opendaylight.openflowjava.protocol.api.connection.ConnectionConfiguration;
  16 import org.opendaylight.openflowjava.protocol.api.connection.SwitchConnectionHandler;
  17 import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
  18 import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
  19 import org.opendaylight.openflowjava.protocol.api.extensibility.OFGeneralDeserializer;
  20 import org.opendaylight.openflowjava.protocol.api.extensibility.OFGeneralSerializer;
  21 import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
  22 import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
  23 import org.opendaylight.openflowjava.protocol.api.keys.ActionSerializerKey;
  24 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterActionDeserializerKey;
  25 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterDeserializerKey;
  26 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdDeserializerKey;
  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.ExperimenterSerializerKey;
  30 import org.opendaylight.openflowjava.protocol.api.keys.InstructionSerializerKey;
  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.keys.MessageCodeKey;
  34 import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey;
  35 import org.opendaylight.openflowjava.protocol.impl.deserialization.DeserializationFactory;
  36 import org.opendaylight.openflowjava.protocol.impl.deserialization.DeserializerRegistryImpl;
  37 import org.opendaylight.openflowjava.protocol.impl.serialization.SerializationFactory;
  38 import org.opendaylight.openflowjava.protocol.impl.serialization.SerializerRegistryImpl;
  39 import org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProvider;
  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.MatchField;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.OxmClassBase;
  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.experimenter.core.ExperimenterDataOfChoice;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.meter.band.MeterBandExperimenterCase;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.queue.property.header.QueueProperty;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.table.features.properties.grouping.TableFeatureProperties;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 /**
  52  * Exposed class for server handling<br>
  53  * C - {@link MatchEntrySerializerKey} parameter representing oxm_class (see specification)<br>
  54  * F - {@link MatchEntrySerializerKey} parameter representing oxm_field (see specification)
  55  * @author mirehak
  56  * @author michal.polkorab
  57  */
  58 public class SwitchConnectionProviderImpl implements SwitchConnectionProvider, ConnectionInitializer {
  59
  60     private static final Logger LOGGER = LoggerFactory
  61             .getLogger(SwitchConnectionProviderImpl.class);
  62     private SwitchConnectionHandler switchConnectionHandler;
  63     private ServerFacade serverFacade;
  64     private ConnectionConfiguration connConfig;
  65     private final SerializationFactory serializationFactory;
  66     private final SerializerRegistry serializerRegistry;
  67     private final DeserializerRegistry deserializerRegistry;
  68     private final DeserializationFactory deserializationFactory;
  69     private TcpConnectionInitializer connectionInitializer;
  70
  71     /** Constructor */
  72     public SwitchConnectionProviderImpl() {
  73         serializerRegistry = new SerializerRegistryImpl();
  74         serializerRegistry.init();
  75         serializationFactory = new SerializationFactory();
  76         serializationFactory.setSerializerTable(serializerRegistry);
  77         deserializerRegistry = new DeserializerRegistryImpl();
  78         deserializerRegistry.init();
  79         deserializationFactory = new DeserializationFactory();
  80         deserializationFactory.setRegistry(deserializerRegistry);
  81     }
  82
  83     @Override
  84     public void setConfiguration(final ConnectionConfiguration connConfig) {
  85         this.connConfig = connConfig;
  86     }
  87
  88     @Override
  89     public void setSwitchConnectionHandler(final SwitchConnectionHandler switchConnectionHandler) {
  90         LOGGER.debug("setSwitchConnectionHandler");
  91         this.switchConnectionHandler = switchConnectionHandler;
  92     }
  93
  94     @Override
  95     public ListenableFuture<Boolean> shutdown() {
  96         LOGGER.debug("Shutdown summoned");
  97         if(serverFacade == null){
  98             LOGGER.warn("Can not shutdown - not configured or started");
  99             throw new IllegalStateException("SwitchConnectionProvider is not started or not configured.");
 100         }
 101         return serverFacade.shutdown();
 102     }
 103
 104     @Override
 105     public ListenableFuture<Boolean> startup() {
 106         LOGGER.debug("Startup summoned");
 107         ListenableFuture<Boolean> result = null;
 108         try {
 109             serverFacade = createAndConfigureServer();
 110             if (switchConnectionHandler == null) {
 111                 throw new IllegalStateException("SwitchConnectionHandler is not set");
 112             }
 113             new Thread(serverFacade).start();
 114             result = serverFacade.getIsOnlineFuture();
 115         } catch (final Exception e) {
 116             final SettableFuture<Boolean> exResult = SettableFuture.create();
 117             exResult.setException(e);
 118             result = exResult;
 119         }
 120         return result;
 121     }
 122
 123     /**
 124      * @return
 125      */
 126     private ServerFacade createAndConfigureServer() {
 127         LOGGER.debug("Configuring ..");
 128         ServerFacade server = null;
 129         final ChannelInitializerFactory factory = new ChannelInitializerFactory();
 130         factory.setSwitchConnectionHandler(switchConnectionHandler);
 131         factory.setSwitchIdleTimeout(connConfig.getSwitchIdleTimeout());
 132         factory.setTlsConfig(connConfig.getTlsConfiguration());
 133         factory.setSerializationFactory(serializationFactory);
 134         factory.setDeserializationFactory(deserializationFactory);
 135         factory.setUseBarrier(connConfig.useBarrier());
 136         final TransportProtocol transportProtocol = (TransportProtocol) connConfig.getTransferProtocol();
 137         if (transportProtocol.equals(TransportProtocol.TCP) || transportProtocol.equals(TransportProtocol.TLS)) {
 138             server = new TcpHandler(connConfig.getAddress(), connConfig.getPort());
 139             final TcpChannelInitializer channelInitializer = factory.createPublishingChannelInitializer();
 140             ((TcpHandler) server).setChannelInitializer(channelInitializer);
 141             ((TcpHandler) server).initiateEventLoopGroups(connConfig.getThreadConfiguration());
 142
 143             final NioEventLoopGroup workerGroupFromTcpHandler = ((TcpHandler) server).getWorkerGroup();
 144             connectionInitializer = new TcpConnectionInitializer(workerGroupFromTcpHandler);
 145             connectionInitializer.setChannelInitializer(channelInitializer);
 146             connectionInitializer.run();
 147         } else if (transportProtocol.equals(TransportProtocol.UDP)){
 148             server = new UdpHandler(connConfig.getAddress(), connConfig.getPort());
 149             ((UdpHandler) server).setChannelInitializer(factory.createUdpChannelInitializer());
 150         } else {
 151             throw new IllegalStateException("Unknown transport protocol received: " + transportProtocol);
 152         }
 153         server.setThreadConfig(connConfig.getThreadConfiguration());
 154         return server;
 155     }
 156
 157     /**
 158      * @return servers
 159      */
 160     public ServerFacade getServerFacade() {
 161         return serverFacade;
 162     }
 163
 164     @Override
 165     public void close() throws Exception {
 166         shutdown();
 167     }
 168
 169     @Override
 170     public boolean unregisterSerializer(final ExperimenterSerializerKey key) {
 171         return serializerRegistry.unregisterSerializer((MessageTypeKey<?>) key);
 172     }
 173
 174     @Override
 175     public boolean unregisterDeserializer(final ExperimenterDeserializerKey key) {
 176         return deserializerRegistry.unregisterDeserializer((MessageCodeKey) key);
 177     }
 178
 179     @Override
 180     public void registerActionSerializer(final ActionSerializerKey<?> key,
 181             final OFGeneralSerializer serializer) {
 182         serializerRegistry.registerSerializer(key, serializer);
 183     }
 184
 185     @Override
 186     public void registerActionDeserializer(final ExperimenterActionDeserializerKey key,
 187             final OFGeneralDeserializer deserializer) {
 188         deserializerRegistry.registerDeserializer(key, deserializer);
 189     }
 190
 191     @Override
 192     public void registerInstructionSerializer(final InstructionSerializerKey<?> key,
 193             final OFGeneralSerializer serializer) {
 194         serializerRegistry.registerSerializer(key, serializer);
 195     }
 196
 197     @Override
 198     public void registerInstructionDeserializer(final ExperimenterInstructionDeserializerKey key,
 199             final OFGeneralDeserializer deserializer) {
 200         deserializerRegistry.registerDeserializer(key, deserializer);
 201     }
 202
 203     @Override
 204     public <C extends OxmClassBase, F extends MatchField> void registerMatchEntrySerializer(final MatchEntrySerializerKey<C, F> key,
 205             final OFGeneralSerializer serializer) {
 206         serializerRegistry.registerSerializer(key, serializer);
 207     }
 208
 209     @Override
 210     public void registerMatchEntryDeserializer(final MatchEntryDeserializerKey key,
 211             final OFGeneralDeserializer deserializer) {
 212         deserializerRegistry.registerDeserializer(key, deserializer);
 213     }
 214
 215     @Override
 216     public void registerErrorDeserializer(final ExperimenterIdDeserializerKey key,
 217             final OFDeserializer<ErrorMessage> deserializer) {
 218         deserializerRegistry.registerDeserializer(key, deserializer);
 219     }
 220
 221     @Override
 222     public void registerExperimenterMessageDeserializer(ExperimenterIdDeserializerKey key,
 223                                                         OFDeserializer<? extends ExperimenterDataOfChoice> deserializer) {
 224         deserializerRegistry.registerDeserializer(key, deserializer);
 225     }
 226
 227     @Override
 228     public void registerMultipartReplyMessageDeserializer(ExperimenterIdDeserializerKey key,
 229                                                           OFDeserializer<? extends ExperimenterDataOfChoice> deserializer) {
 230         deserializerRegistry.registerDeserializer(key, deserializer);
 231     }
 232
 233     @Override
 234     public void registerMultipartReplyTFDeserializer(final ExperimenterIdDeserializerKey key,
 235             final OFGeneralDeserializer deserializer) {
 236         deserializerRegistry.registerDeserializer(key, deserializer);
 237     }
 238
 239     @Override
 240     public void registerQueuePropertyDeserializer(final ExperimenterIdDeserializerKey key,
 241             final OFDeserializer<QueueProperty> deserializer) {
 242         deserializerRegistry.registerDeserializer(key, deserializer);
 243     }
 244
 245     @Override
 246     public void registerMeterBandDeserializer(final ExperimenterIdDeserializerKey key,
 247             final OFDeserializer<MeterBandExperimenterCase> deserializer) {
 248         deserializerRegistry.registerDeserializer(key, deserializer);
 249     }
 250
 251     @Override
 252     public void registerExperimenterMessageSerializer(ExperimenterIdSerializerKey<? extends ExperimenterDataOfChoice> key,
 253                                                       OFSerializer<? extends ExperimenterDataOfChoice> serializer) {
 254         serializerRegistry.registerSerializer(key, serializer);
 255     }
 256
 257     @Override
 258     public void registerMultipartRequestSerializer(ExperimenterIdSerializerKey<? extends ExperimenterDataOfChoice> key,
 259                                                    OFSerializer<? extends ExperimenterDataOfChoice> serializer) {
 260         serializerRegistry.registerSerializer(key, serializer);
 261     }
 262
 263     @Override
 264     public void registerMultipartRequestTFSerializer(final ExperimenterIdSerializerKey<TableFeatureProperties> key,
 265             final OFGeneralSerializer serializer) {
 266         serializerRegistry.registerSerializer(key, serializer);
 267     }
 268
 269     @Override
 270     public void registerMeterBandSerializer(final ExperimenterIdSerializerKey<MeterBandExperimenterCase> key,
 271             final OFSerializer<MeterBandExperimenterCase> serializer) {
 272         serializerRegistry.registerSerializer(key, serializer);
 273     }
 274
 275     @Override
 276     public void initiateConnection(final String host, final int port) {
 277         connectionInitializer.initiateConnection(host, port);
 278     }
 279
 280 }