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 SerializationFactory serializationFactory;
  66     private SerializerRegistry serializerRegistry;
  67     private DeserializerRegistry deserializerRegistry;
  68     private 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(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             TcpChannelInitializer channelInitializer = factory.createPublishingChannelInitializer();
 139             ((TcpHandler) server).setChannelInitializer(channelInitializer);
 140             ((TcpHandler) server).initiateEventLoopGroups(connConfig.getThreadConfiguration());
 141
 142             NioEventLoopGroup workerGroupFromTcpHandler = ((TcpHandler) server).getWorkerGroup();
 143             connectionInitializer = new TcpConnectionInitializer(workerGroupFromTcpHandler);
 144             connectionInitializer.setChannelInitializer(channelInitializer);
 145             connectionInitializer.run();
 146         } else if (transportProtocol.equals(TransportProtocol.UDP)){
 147             server = new UdpHandler(connConfig.getAddress(), connConfig.getPort());
 148             ((UdpHandler) server).setChannelInitializer(factory.createUdpChannelInitializer());
 149         } else {
 150             throw new IllegalStateException("Unknown transport protocol received: " + transportProtocol);
 151         }
 152         server.setThreadConfig(connConfig.getThreadConfiguration());
 153         return server;
 154     }
 155
 156     /**
 157      * @return servers
 158      */
 159     public ServerFacade getServerFacade() {
 160         return serverFacade;
 161     }
 162
 163     @Override
 164     public void close() throws Exception {
 165         shutdown();
 166     }
 167
 168     @Override
 169     public boolean unregisterSerializer(ExperimenterSerializerKey key) {
 170         return serializerRegistry.unregisterSerializer((MessageTypeKey<?>) key);
 171     }
 172
 173     @Override
 174     public boolean unregisterDeserializer(ExperimenterDeserializerKey key) {
 175         return deserializerRegistry.unregisterDeserializer((MessageCodeKey) key);
 176     }
 177
 178     @Override
 179     public void registerActionSerializer(ActionSerializerKey<?> key,
 180             OFGeneralSerializer serializer) {
 181         serializerRegistry.registerSerializer(key, serializer);
 182     }
 183
 184     @Override
 185     public void registerActionDeserializer(ExperimenterActionDeserializerKey key,
 186             OFGeneralDeserializer deserializer) {
 187         deserializerRegistry.registerDeserializer(key, deserializer);
 188     }
 189
 190     @Override
 191     public void registerInstructionSerializer(InstructionSerializerKey<?> key,
 192             OFGeneralSerializer serializer) {
 193         serializerRegistry.registerSerializer(key, serializer);
 194     }
 195
 196     @Override
 197     public void registerInstructionDeserializer(ExperimenterInstructionDeserializerKey key,
 198             OFGeneralDeserializer deserializer) {
 199         deserializerRegistry.registerDeserializer(key, deserializer);
 200     }
 201
 202     @Override
 203     public <C extends OxmClassBase, F extends MatchField> void registerMatchEntrySerializer(MatchEntrySerializerKey<C, F> key,
 204             OFGeneralSerializer serializer) {
 205         serializerRegistry.registerSerializer(key, serializer);
 206     }
 207
 208     @Override
 209     public void registerMatchEntryDeserializer(MatchEntryDeserializerKey key,
 210             OFGeneralDeserializer deserializer) {
 211         deserializerRegistry.registerDeserializer(key, deserializer);
 212     }
 213
 214     @Override
 215     public void registerErrorDeserializer(ExperimenterIdDeserializerKey key,
 216             OFDeserializer<ErrorMessage> deserializer) {
 217         deserializerRegistry.registerDeserializer(key, deserializer);
 218     }
 219
 220     @Override
 221     public void registerExperimenterMessageDeserializer(ExperimenterIdDeserializerKey key,
 222                                                         OFDeserializer<? extends ExperimenterDataOfChoice> deserializer) {
 223         deserializerRegistry.registerDeserializer(key, deserializer);
 224     }
 225
 226     @Override
 227     public void registerMultipartReplyMessageDeserializer(ExperimenterIdDeserializerKey key,
 228                                                           OFDeserializer<? extends ExperimenterDataOfChoice> deserializer) {
 229         deserializerRegistry.registerDeserializer(key, deserializer);
 230     }
 231
 232     @Override
 233     public void registerMultipartReplyTFDeserializer(ExperimenterIdDeserializerKey key,
 234             OFGeneralDeserializer deserializer) {
 235         deserializerRegistry.registerDeserializer(key, deserializer);
 236     }
 237
 238     @Override
 239     public void registerQueuePropertyDeserializer(ExperimenterIdDeserializerKey key,
 240             OFDeserializer<QueueProperty> deserializer) {
 241         deserializerRegistry.registerDeserializer(key, deserializer);
 242     }
 243
 244     @Override
 245     public void registerMeterBandDeserializer(ExperimenterIdDeserializerKey key,
 246             OFDeserializer<MeterBandExperimenterCase> deserializer) {
 247         deserializerRegistry.registerDeserializer(key, deserializer);
 248     }
 249
 250     @Override
 251     public void registerExperimenterMessageSerializer(ExperimenterIdSerializerKey<? extends ExperimenterDataOfChoice> key,
 252                                                       OFSerializer<? extends ExperimenterDataOfChoice> serializer) {
 253         serializerRegistry.registerSerializer(key, serializer);
 254     }
 255
 256     @Override
 257     public void registerMultipartRequestSerializer(ExperimenterIdSerializerKey<? extends ExperimenterDataOfChoice> key,
 258                                                    OFSerializer<? extends ExperimenterDataOfChoice> serializer) {
 259         serializerRegistry.registerSerializer(key, serializer);
 260     }
 261
 262     @Override
 263     public void registerMultipartRequestTFSerializer(ExperimenterIdSerializerKey<TableFeatureProperties> key,
 264             OFGeneralSerializer serializer) {
 265         serializerRegistry.registerSerializer(key, serializer);
 266     }
 267
 268     @Override
 269     public void registerMeterBandSerializer(ExperimenterIdSerializerKey<MeterBandExperimenterCase> key,
 270             OFSerializer<MeterBandExperimenterCase> serializer) {
 271         serializerRegistry.registerSerializer(key, serializer);
 272     }
 273
 274     @Override
 275     public void initiateConnection(String host, int port) {
 276         connectionInitializer.initiateConnection(host, port);
 277     }
 278
 279 }