-/* Copyright (C)2013 Pantheon Technologies, s.r.o. All rights reserved. */
+/*
+ * Copyright (c) 2013 Pantheon Technologies s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
-package org.opendaylight.openflowjava.protocol.impl.connection;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.Future;
+package org.opendaylight.openflowjava.protocol.impl.connection;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionConfiguration;
+import org.opendaylight.openflowjava.protocol.api.connection.ConnectionConfiguration.FEATURE_SUPPORT;
import org.opendaylight.openflowjava.protocol.api.connection.SwitchConnectionHandler;
+import org.opendaylight.openflowjava.protocol.api.extensibility.MessageTypeKey;
+import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
+import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
import org.opendaylight.openflowjava.protocol.impl.core.TcpHandler;
+import org.opendaylight.openflowjava.protocol.impl.serialization.SerializationFactory;
+import org.opendaylight.openflowjava.protocol.impl.serialization.SerializerRegistryImpl;
import org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProvider;
+import org.opendaylight.yangtools.yang.binding.DataObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
/**
+ * Exposed class for server handling
* @author mirehak
* @author michal.polkorab
*/
public class SwitchConnectionProviderImpl implements SwitchConnectionProvider {
-
- private static final Logger LOG = LoggerFactory
+
+ private static final Logger LOGGER = LoggerFactory
.getLogger(SwitchConnectionProviderImpl.class);
private SwitchConnectionHandler switchConnectionHandler;
- private Set<ServerFacade> serverLot;
+ private ServerFacade serverFacade;
+ private ConnectionConfiguration connConfig;
+ private SerializationFactory serializationFactory;
+ private SerializerRegistry serializerRegistry;
- @Override
- public void configure(Collection<ConnectionConfiguration> connConfigs) {
- LOG.debug("Configurating ..");
+ /** Constructor */
+ public SwitchConnectionProviderImpl() {
+ serializerRegistry = new SerializerRegistryImpl();
+ serializerRegistry.init();
+ serializationFactory = new SerializationFactory();
+ serializationFactory.setSerializerTable(serializerRegistry);
+ }
- //TODO - configure servers according to configuration
- serverLot = new HashSet<>();
- for (Iterator<ConnectionConfiguration> iterator = connConfigs.iterator(); iterator.hasNext();) {
- ConnectionConfiguration connConfig = iterator.next();
- serverLot.add(new TcpHandler(connConfig.getAddress(), connConfig.getPort()));
- }
+ @Override
+ public void setConfiguration(ConnectionConfiguration connConfig) {
+ this.connConfig = connConfig;
}
@Override
public void setSwitchConnectionHandler(SwitchConnectionHandler switchConnectionHandler) {
- LOG.debug("setSwitchConnectionHanler");
+ LOGGER.debug("setSwitchConnectionHandler");
this.switchConnectionHandler = switchConnectionHandler;
}
@Override
- public Future<List<Boolean>> shutdown() {
- LOG.debug("Shutdown summoned");
- ListenableFuture<List<Boolean>> result = SettableFuture.create();
- try {
- List<ListenableFuture<Boolean>> shutdownChain = new ArrayList<>();
- for (ServerFacade server : serverLot) {
- ListenableFuture<Boolean> shutdownFuture = server.shutdown();
- shutdownChain.add(shutdownFuture);
- }
- if (!shutdownChain.isEmpty()) {
- result = Futures.allAsList(shutdownChain);
- } else {
- throw new IllegalStateException("No servers configured");
- }
- } catch (Exception e) {
- SettableFuture<List<Boolean>> exFuture = SettableFuture.create();
- exFuture.setException(e);
- result = exFuture;
- }
+ public ListenableFuture<Boolean> shutdown() {
+ LOGGER.debug("Shutdown summoned");
+ //TODO: provide exception in case of: not started, not configured (already stopped)
+ ListenableFuture<Boolean> result = serverFacade.shutdown();
return result;
}
@Override
- public Future<List<Boolean>> startup() {
- LOG.debug("startup summoned");
- ListenableFuture<List<Boolean>> result = SettableFuture.create();
+ public ListenableFuture<Boolean> startup() {
+ LOGGER.debug("Startup summoned");
+ serverFacade = createAndConfigureServer();
+
+ LOGGER.debug("Starting ..");
+ ListenableFuture<Boolean> result = null;
try {
- if (serverLot.isEmpty()) {
- throw new IllegalStateException("No servers configured");
+ if (serverFacade == null) {
+ throw new IllegalStateException("No server configured");
}
- for (ServerFacade server : serverLot) {
- if (server.getIsOnlineFuture().isDone()) {
- throw new IllegalStateException("Servers already running");
- }
+ if (serverFacade.getIsOnlineFuture().isDone()) {
+ throw new IllegalStateException("Server already running");
}
if (switchConnectionHandler == null) {
throw new IllegalStateException("switchConnectionHandler is not set");
}
- List<ListenableFuture<Boolean>> starterChain = new ArrayList<>();
- for (ServerFacade server : serverLot) {
- new Thread(server).start();
- ListenableFuture<Boolean> isOnlineFuture = server.getIsOnlineFuture();
- starterChain.add(isOnlineFuture);
- }
- if (!starterChain.isEmpty()) {
- result = Futures.allAsList(starterChain);
- } else {
- throw new IllegalStateException("No servers configured");
- }
+ new Thread(serverFacade).start();
+ result = serverFacade.getIsOnlineFuture();
} catch (Exception e) {
- SettableFuture<List<Boolean>> exFuture = SettableFuture.create();
- exFuture.setException(e);
- result = exFuture;
+ SettableFuture<Boolean> exResult = SettableFuture.create();
+ exResult.setException(e);
+ result = exResult;
}
return result;
}
+ /**
+ * @return
+ */
+ private TcpHandler createAndConfigureServer() {
+ LOGGER.debug("Configuring ..");
+ TcpHandler server = new TcpHandler(connConfig.getAddress(), connConfig.getPort());
+ server.setSwitchConnectionHandler(switchConnectionHandler);
+ server.setSwitchIdleTimeout(connConfig.getSwitchIdleTimeout());
+ boolean tlsSupported = FEATURE_SUPPORT.REQUIRED.equals(connConfig.getTlsSupport());
+ server.setEncryption(tlsSupported);
+ server.setSerializationFactory(serializationFactory);
+ return server;
+ }
+
+ /**
+ * @return servers
+ */
+ public ServerFacade getServerFacade() {
+ return serverFacade;
+ }
+
+ @Override
+ public <E extends DataObject> void registerCustomSerializer(MessageTypeKey<E> key,
+ OFSerializer<E> serializer) {
+ serializerRegistry.registerSerializer(key, serializer);
+ }
+
+ @Override
+ public void close() throws Exception {
+ shutdown();
+ }
}
Code Review / openflowjava.git / blobdiff