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