import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
import io.netty.util.HashedWheelTimer;
import java.lang.management.ManagementFactory;
import java.util.Collection;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import javax.management.MalformedObjectNameException;
import javax.management.NotCompliantMBeanException;
import javax.management.ObjectName;
-import org.apache.aries.blueprint.annotation.service.Reference;
-import org.apache.aries.blueprint.annotation.service.Service;
import org.opendaylight.infrautils.diagstatus.ServiceState;
import org.opendaylight.infrautils.ready.SystemReadyListener;
import org.opendaylight.infrautils.ready.SystemReadyMonitor;
import org.opendaylight.openflowjava.protocol.api.connection.OpenflowDiagStatusProvider;
import org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProvider;
import org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProviderList;
+import org.opendaylight.openflowplugin.api.openflow.FlowGroupInfoHistories;
+import org.opendaylight.openflowplugin.api.openflow.FlowGroupInfoHistory;
import org.opendaylight.openflowplugin.api.openflow.OpenFlowPluginProvider;
import org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationService;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionManager;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorManager;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorManagerFactory;
import org.opendaylight.openflowplugin.openflow.md.core.session.OFSessionUtil;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.OpenflowProviderConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Singleton
-@Service(classes = { OpenFlowPluginProvider.class, OpenFlowPluginExtensionRegistratorProvider.class })
public class OpenFlowPluginProviderImpl implements
OpenFlowPluginProvider,
OpenFlowPluginExtensionRegistratorProvider,
+ FlowGroupInfoHistories,
SystemReadyListener {
private static final Logger LOG = LoggerFactory.getLogger(OpenFlowPluginProviderImpl.class);
private StatisticsManager statisticsManager;
private RoleManager roleManager;
private ConnectionManager connectionManager;
- private ListeningExecutorService executorService;
+ private ExecutorService executorService;
private ContextChainHolderImpl contextChainHolder;
private final OpenflowDiagStatusProvider openflowDiagStatusProvider;
+ private final SystemReadyMonitor systemReadyMonitor;
private final SettableFuture<Void> fullyStarted = SettableFuture.create();
private static final String OPENFLOW_SERVICE_NAME = "OPENFLOW";
public OpenFlowPluginProviderImpl(final ConfigurationService configurationService,
final SwitchConnectionProviderList switchConnectionProviders,
final PingPongDataBroker pingPongDataBroker,
- final @Reference RpcProviderService rpcProviderRegistry,
- final @Reference NotificationPublishService notificationPublishService,
- final @Reference ClusterSingletonServiceProvider singletonServiceProvider,
- final @Reference EntityOwnershipService entityOwnershipService,
+ final RpcProviderService rpcProviderRegistry,
+ final NotificationPublishService notificationPublishService,
+ final ClusterSingletonServiceProvider singletonServiceProvider,
+ final EntityOwnershipService entityOwnershipService,
final MastershipChangeServiceManager mastershipChangeServiceManager,
- final @Reference OpenflowDiagStatusProvider openflowDiagStatusProvider,
- final @Reference SystemReadyMonitor systemReadyMonitor) {
+ final OpenflowDiagStatusProvider openflowDiagStatusProvider,
+ final SystemReadyMonitor systemReadyMonitor) {
this.switchConnectionProviders = switchConnectionProviders;
this.dataBroker = pingPongDataBroker;
this.rpcProviderRegistry = rpcProviderRegistry;
config = new OpenFlowProviderConfigImpl(configurationService);
this.mastershipChangeServiceManager = mastershipChangeServiceManager;
this.openflowDiagStatusProvider = openflowDiagStatusProvider;
- systemReadyMonitor.registerListener(this);
- LOG.info("registered onSystemBootReady() listener for deferred startSwitchConnections()");
+ this.systemReadyMonitor = systemReadyMonitor;
}
@Override
LOG.info("onSystemBootReady() received, starting the switch connections");
Futures.addCallback(Futures.allAsList(switchConnectionProviders.stream().map(switchConnectionProvider -> {
// Inject OpenFlowPlugin custom serializers and deserializers into OpenFlowJava
- if (config.isUseSingleLayerSerialization()) {
+ if (config.getUseSingleLayerSerialization()) {
SerializerInjector.injectSerializers(switchConnectionProvider,
switchConnectionProvider.getConfiguration().isGroupAddModEnabled());
DeserializerInjector.injectDeserializers(switchConnectionProvider);
final ListenableFuture<List<Boolean>> listListenableFuture =
Futures.allAsList(switchConnectionProviders.stream().map(switchConnectionProvider -> {
// Revert deserializers to their original state
- if (config.isUseSingleLayerSerialization()) {
+ if (config.getUseSingleLayerSerialization()) {
DeserializerInjector.revertDeserializers(switchConnectionProvider);
}
// Creates a thread pool that creates new threads as needed, but will reuse previously
// constructed threads when they are available.
// Threads that have not been used for x seconds are terminated and removed from the cache.
- executorService = MoreExecutors.listeningDecorator(new ThreadPoolLoggingExecutor(
- config.getThreadPoolMinThreads(),
- config.getThreadPoolMaxThreads().getValue(),
- config.getThreadPoolTimeout(),
- TimeUnit.SECONDS, new SynchronousQueue<>(), POOL_NAME));
+ executorService = new ThreadPoolLoggingExecutor(
+ config.getThreadPoolMinThreads().toJava(),
+ config.getThreadPoolMaxThreads().getValue().toJava(),
+ config.getThreadPoolTimeout().toJava(),
+ TimeUnit.SECONDS, new SynchronousQueue<>(), POOL_NAME);
deviceManager = new DeviceManagerImpl(
config,
notificationPublishService,
hashedWheelTimer,
convertorManager,
- deviceInitializerProvider);
+ deviceInitializerProvider,
+ executorService);
TranslatorLibraryUtil.injectBasicTranslatorLibrary(deviceManager, convertorManager);
((ExtensionConverterProviderKeeper) deviceManager).setExtensionConverterProvider(extensionConverterManager);
convertorManager,
executorService);
- roleManager = new RoleManagerImpl(hashedWheelTimer, config);
+ roleManager = new RoleManagerImpl(hashedWheelTimer, config, executorService);
contextChainHolder = new ContextChainHolderImpl(
executorService,
singletonServicesProvider,
entityOwnershipService,
- mastershipChangeServiceManager);
+ mastershipChangeServiceManager,
+ config);
contextChainHolder.addManager(deviceManager);
contextChainHolder.addManager(statisticsManager);
contextChainHolder.addManager(rpcManager);
contextChainHolder.addManager(roleManager);
- connectionManager = new ConnectionManagerImpl(config, executorService);
+ connectionManager = new ConnectionManagerImpl(config, executorService, dataBroker, notificationPublishService);
connectionManager.setDeviceConnectedHandler(contextChainHolder);
connectionManager.setDeviceDisconnectedHandler(contextChainHolder);
deviceManager.setContextChainHolder(contextChainHolder);
deviceManager.initialize();
+ systemReadyMonitor.registerListener(this);
+ LOG.info("registered onSystemBootReady() listener for OpenFlowPluginProvider");
}
@Override
return extensionConverterManager;
}
+ @Override
+ public Map<NodeId, FlowGroupInfoHistory> getAllFlowGroupHistories() {
+ return deviceManager.getAllFlowGroupHistories();
+ }
+
+ @Override
+ public FlowGroupInfoHistory getFlowGroupHistory(final NodeId nodeId) {
+ return deviceManager.getFlowGroupHistory(nodeId);
+ }
+
@Override
@PreDestroy
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void close() {
try {
shutdownSwitchConnections().get(10, TimeUnit.SECONDS);
}
gracefulShutdown(contextChainHolder);
+ gracefulShutdown(connectionManager);
gracefulShutdown(deviceManager);
gracefulShutdown(rpcManager);
gracefulShutdown(statisticsManager);
gracefulShutdown(hashedWheelTimer);
unregisterMXBean(MESSAGE_INTELLIGENCE_AGENCY_MX_BEAN_NAME);
openflowDiagStatusProvider.reportStatus(ServiceState.UNREGISTERED);
+ try {
+ if (connectionManager != null) {
+ connectionManager.close();
+ connectionManager = null;
+ }
+ } catch (Exception e) {
+ LOG.error("Failed to close ConnectionManager", e);
+ }
}
@SuppressWarnings("checkstyle:IllegalCatch")
Code Review / openflowplugin.git / blobdiff