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