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