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.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.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
  56  * @author mirehak
  57  * @author michal.polkorab
  58  */
  59 public class SwitchConnectionProviderImpl implements SwitchConnectionProvider {
  60
  61     private static final Logger LOGGER = LoggerFactory
  62             .getLogger(SwitchConnectionProviderImpl.class);
  63     private SwitchConnectionHandler switchConnectionHandler;
  64     private ServerFacade serverFacade;
  65     private ConnectionConfiguration connConfig;
  66     private SerializationFactory serializationFactory;
  67     private SerializerRegistry serializerRegistry;
  68     private DeserializerRegistry deserializerRegistry;
  69     private DeserializationFactory deserializationFactory;
  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(ConnectionConfiguration connConfig) {
  85         this.connConfig = connConfig;
  86     }
  87
  88     @Override
  89     public void setSwitchConnectionHandler(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 (Exception e) {
 116             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         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         TransportProtocol transportProtocol = (TransportProtocol) connConfig.getTransferProtocol();
 136         if (transportProtocol.equals(TransportProtocol.TCP) || transportProtocol.equals(TransportProtocol.TLS)) {
 137             server = new TcpHandler(connConfig.getAddress(), connConfig.getPort());
 138             ((TcpHandler) server).setChannelInitializer(factory.createPublishingChannelInitializer());
 139         } else if (transportProtocol.equals(TransportProtocol.UDP)){
 140             server = new UdpHandler(connConfig.getAddress(), connConfig.getPort());
 141             ((UdpHandler) server).setChannelInitializer(factory.createUdpChannelInitializer());
 142         } else {
 143             throw new IllegalStateException("Unknown transport protocol received: " + transportProtocol);
 144         }
 145         server.setThreadConfig(connConfig.getThreadConfiguration());
 146         return server;
 147     }
 148
 149     /**
 150      * @return servers
 151      */
 152     public ServerFacade getServerFacade() {
 153         return serverFacade;
 154     }
 155
 156     @Override
 157     public void close() throws Exception {
 158         shutdown();
 159     }
 160
 161     @Override
 162     public boolean unregisterSerializer(ExperimenterSerializerKey key) {
 163         return serializerRegistry.unregisterSerializer((MessageTypeKey<?>) key);
 164     }
 165
 166     @Override
 167     public boolean unregisterDeserializer(ExperimenterDeserializerKey key) {
 168         return deserializerRegistry.unregisterDeserializer((MessageCodeKey) key);
 169     }
 170
 171     @Override
 172     public void registerActionSerializer(ExperimenterActionSerializerKey key,
 173             OFGeneralSerializer serializer) {
 174         serializerRegistry.registerSerializer(key, serializer);
 175     }
 176
 177     @Override
 178     public void registerActionDeserializer(ExperimenterActionDeserializerKey key,
 179             OFGeneralDeserializer deserializer) {
 180         deserializerRegistry.registerDeserializer(key, deserializer);
 181     }
 182
 183     @Override
 184     public void registerInstructionSerializer(ExperimenterInstructionSerializerKey key,
 185             OFGeneralSerializer serializer) {
 186         serializerRegistry.registerSerializer(key, serializer);
 187     }
 188
 189     @Override
 190     public void registerInstructionDeserializer(ExperimenterInstructionDeserializerKey key,
 191             OFGeneralDeserializer deserializer) {
 192         deserializerRegistry.registerDeserializer(key, deserializer);
 193     }
 194
 195     @Override
 196     public <OXM_CLASS extends OxmClassBase, OXM_TYPE extends MatchField> void registerMatchEntrySerializer(MatchEntrySerializerKey<OXM_CLASS, OXM_TYPE> key,
 197             OFGeneralSerializer serializer) {
 198         serializerRegistry.registerSerializer(key, serializer);
 199     }
 200
 201     @Override
 202     public void registerMatchEntryDeserializer(MatchEntryDeserializerKey key,
 203             OFGeneralDeserializer deserializer) {
 204         deserializerRegistry.registerDeserializer(key, deserializer);
 205     }
 206
 207     @Override
 208     public void registerErrorDeserializer(ExperimenterIdDeserializerKey key,
 209             OFDeserializer<ErrorMessage> deserializer) {
 210         deserializerRegistry.registerDeserializer(key, deserializer);
 211     }
 212
 213     @Override
 214     public void registerExperimenterMessageDeserializer(ExperimenterIdDeserializerKey key,
 215             OFDeserializer<ExperimenterMessage> deserializer) {
 216         deserializerRegistry.registerDeserializer(key, deserializer);
 217     }
 218
 219     @Override
 220     public void registerMultipartReplyMessageDeserializer(ExperimenterIdDeserializerKey key,
 221             OFDeserializer<MultipartReplyMessage> deserializer) {
 222         deserializerRegistry.registerDeserializer(key, deserializer);
 223     }
 224
 225     @Override
 226     public void registerMultipartReplyTFDeserializer(ExperimenterIdDeserializerKey key,
 227             OFGeneralDeserializer deserializer) {
 228         deserializerRegistry.registerDeserializer(key, deserializer);
 229     }
 230
 231     @Override
 232     public void registerQueuePropertyDeserializer(ExperimenterIdDeserializerKey key,
 233             OFDeserializer<QueueProperty> deserializer) {
 234         deserializerRegistry.registerDeserializer(key, deserializer);
 235     }
 236
 237     @Override
 238     public void registerMeterBandDeserializer(ExperimenterIdDeserializerKey key,
 239             OFDeserializer<MeterBandExperimenterCase> deserializer) {
 240         deserializerRegistry.registerDeserializer(key, deserializer);
 241     }
 242
 243     @Override
 244     public void registerExperimenterMessageSerializer(ExperimenterIdSerializerKey<ExperimenterInput> key,
 245             OFSerializer<ExperimenterInput> serializer) {
 246         serializerRegistry.registerSerializer(key, serializer);
 247     }
 248
 249     @Override
 250     public void registerMultipartRequestSerializer(ExperimenterIdSerializerKey<MultipartRequestExperimenterCase> key,
 251             OFSerializer<MultipartRequestExperimenterCase> serializer) {
 252         serializerRegistry.registerSerializer(key, serializer);
 253     }
 254
 255     @Override
 256     public void registerMultipartRequestTFSerializer(ExperimenterIdSerializerKey<TableFeatureProperties> key,
 257             OFGeneralSerializer serializer) {
 258         serializerRegistry.registerSerializer(key, serializer);
 259     }
 260
 261     @Override
 262     public void registerMeterBandSerializer(ExperimenterIdSerializerKey<MeterBandExperimenterCase> key,
 263             OFSerializer<MeterBandExperimenterCase> serializer) {
 264         serializerRegistry.registerSerializer(key, serializer);
 265     }
 266 }