<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.infrautils</groupId>
+ <artifactId>diagstatus-api</artifactId>
+ <version>${infrautils.version}</version>
+ <scope>compile</scope>
+ </dependency>
</dependencies>
</project>
--- /dev/null
+/*
+ * Copyright (c) 2019 Ericsson India Global Services Pvt Ltd. 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.api.connection;
+
+import org.opendaylight.infrautils.diagstatus.ServiceState;
+
+public interface OpenflowDiagStatusProvider {
+
+ void reportStatus(ServiceState serviceState);
+
+ void reportStatus(String diagStatusService, Throwable throwable);
+
+ void reportStatus(String diagStatusIdentifier, ServiceState serviceState, String description);
+
+ void reportStatus(String diagStatusIdentifier, ServiceState serviceState);
+}
+
+
--- /dev/null
+/*
+ * Copyright (c) 2019 Ericsson India Global Services Pvt Ltd. 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.core;
+
+import static org.opendaylight.infrautils.diagstatus.ServiceState.ERROR;
+import static org.opendaylight.infrautils.diagstatus.ServiceState.OPERATIONAL;
+import static org.opendaylight.infrautils.diagstatus.ServiceState.STARTING;
+
+import java.util.HashMap;
+import java.util.Map;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.apache.aries.blueprint.annotation.service.Reference;
+import org.apache.aries.blueprint.annotation.service.Service;
+import org.opendaylight.infrautils.diagstatus.DiagStatusService;
+import org.opendaylight.infrautils.diagstatus.ServiceDescriptor;
+import org.opendaylight.infrautils.diagstatus.ServiceState;
+import org.opendaylight.openflowjava.protocol.api.connection.OpenflowDiagStatusProvider;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Singleton
+@Service(classes = OpenflowDiagStatusProvider.class)
+public class OpenflowDiagStatusProviderImpl implements OpenflowDiagStatusProvider {
+ private static final Logger LOG = LoggerFactory.getLogger(OpenflowDiagStatusProviderImpl.class);
+ private static final String OPENFLOW_SERVICE = "OPENFLOW";
+ private static final String OPENFLOW_SERVER_6633 = "OPENFLOW_SERVER_6633";
+ private static final String OPENFLOW_SERVER_6653 = "OPENFLOW_SERVER_6653";
+ private static final String OPENFLOW_SERVICE_AGGREGATE = OPENFLOW_SERVICE;
+
+ private final DiagStatusService diagStatusService;
+ private volatile Map<String, ServiceState> statusMap = new HashMap<String, ServiceState>() {{
+ put(OPENFLOW_SERVICE, STARTING);
+ put(OPENFLOW_SERVER_6633, STARTING);
+ put(OPENFLOW_SERVER_6653, STARTING);
+ }
+ };
+
+ @Inject
+ public OpenflowDiagStatusProviderImpl(final @Reference DiagStatusService diagStatusService) {
+ this.diagStatusService = diagStatusService;
+ diagStatusService.register(OPENFLOW_SERVICE_AGGREGATE);
+ }
+
+ @Override
+ public void reportStatus(final ServiceState serviceState) {
+ LOG.debug("reporting status as {} for {}", serviceState,OPENFLOW_SERVICE_AGGREGATE);
+ diagStatusService.report(new ServiceDescriptor(OPENFLOW_SERVICE_AGGREGATE, serviceState));
+ }
+
+ @Override
+ public void reportStatus(final String diagStatusIdentifier, final Throwable throwable) {
+ LOG.debug("Reporting error for {} as {}", diagStatusIdentifier, throwable.toString());
+ statusMap.replace(diagStatusIdentifier, ERROR);
+ diagStatusService.report(new ServiceDescriptor(OPENFLOW_SERVICE_AGGREGATE, throwable));
+ }
+
+ @Override
+ public void reportStatus(final String diagStatusIdentifier, final ServiceState serviceState,
+ final String description) {
+ LOG.debug("Reporting status {} for {} and desc {}", serviceState, diagStatusIdentifier, description);
+ diagStatusService.report(new ServiceDescriptor(OPENFLOW_SERVICE_AGGREGATE, serviceState, description));
+ }
+
+ @Override
+ public void reportStatus(final String diagStatusIdentifier, final ServiceState serviceState) {
+ statusMap.replace(diagStatusIdentifier, serviceState);
+ LOG.info("The report status is {} for {}", serviceState, diagStatusIdentifier);
+ reportStatus();
+ }
+
+ public void reportStatus() {
+ boolean state = statusMap.values().stream().allMatch(serviceState -> serviceState.equals(OPERATIONAL));
+ if (state) {
+ reportStatus(OPERATIONAL);
+ }
+ }
+}
\ No newline at end of file
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.List;
-import javax.inject.Inject;
import javax.inject.Singleton;
-import org.apache.aries.blueprint.annotation.service.Reference;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.infrautils.diagstatus.DiagStatusService;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionConfiguration;
+import org.opendaylight.openflowjava.protocol.api.connection.OpenflowDiagStatusProvider;
import org.opendaylight.openflowjava.protocol.api.connection.ThreadConfiguration;
import org.opendaylight.openflowjava.protocol.api.connection.TlsConfiguration;
import org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProvider;
@Service(classes = SwitchConnectionProviderFactory.class)
public class SwitchConnectionProviderFactoryImpl implements SwitchConnectionProviderFactory {
- private final DiagStatusService diagStatusService;
-
- @Inject
- public SwitchConnectionProviderFactoryImpl(@Reference DiagStatusService diagStatusService) {
- this.diagStatusService = diagStatusService;
- }
-
@Override
- public SwitchConnectionProvider newInstance(SwitchConnectionConfig config) {
- return new SwitchConnectionProviderImpl(new ConnectionConfigurationImpl(config), diagStatusService);
+ public SwitchConnectionProvider newInstance(SwitchConnectionConfig config,
+ OpenflowDiagStatusProvider openflowPluginDiagStatusProvider) {
+ return new SwitchConnectionProviderImpl(new ConnectionConfigurationImpl(config),
+ openflowPluginDiagStatusProvider);
}
private static InetAddress getInetAddress(final IpAddress address) throws UnknownHostException {
import io.netty.channel.EventLoopGroup;
import io.netty.channel.epoll.Epoll;
import org.checkerframework.checker.nullness.qual.Nullable;
-import org.opendaylight.infrautils.diagstatus.DiagStatusService;
-import org.opendaylight.infrautils.diagstatus.ServiceDescriptor;
import org.opendaylight.infrautils.diagstatus.ServiceState;
import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionConfiguration;
+import org.opendaylight.openflowjava.protocol.api.connection.OpenflowDiagStatusProvider;
import org.opendaylight.openflowjava.protocol.api.connection.SwitchConnectionHandler;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
private final DeserializerRegistry deserializerRegistry;
private final DeserializationFactory deserializationFactory;
private final ListeningExecutorService listeningExecutorService;
- private final DiagStatusService diagStatusService;
private final String diagStatusIdentifier;
private final String threadName;
private TcpConnectionInitializer connectionInitializer;
+ private OpenflowDiagStatusProvider openflowDiagStatusProvider;
public SwitchConnectionProviderImpl(
- @Nullable ConnectionConfiguration connConfig, DiagStatusService diagStatusService) {
+ @Nullable ConnectionConfiguration connConfig, OpenflowDiagStatusProvider openflowDiagStatusProvider) {
this.connConfig = connConfig;
String connectionSuffix = createConnectionSuffix(connConfig);
-
- this.diagStatusService = diagStatusService;
this.diagStatusIdentifier = OPENFLOW_JAVA_SERVICE_NAME_PREFIX + connectionSuffix;
- diagStatusService.register(diagStatusIdentifier);
-
+ this.openflowDiagStatusProvider = openflowDiagStatusProvider;
this.threadName = THREAD_NAME_PREFIX + connectionSuffix;
this.listeningExecutorService = Executors.newListeningSingleThreadExecutor(threadName, LOG);
-
serializerRegistry = new SerializerRegistryImpl();
if (connConfig != null) {
serializerRegistry.setGroupAddModConfig(connConfig.isGroupAddModEnabled());
@Override
public void onFailure(Throwable throwable) {
- diagStatusService.report(new ServiceDescriptor(diagStatusIdentifier, throwable));
+ openflowDiagStatusProvider.reportStatus(diagStatusIdentifier, throwable);
}
@Override
public void onSuccess(@Nullable Object nullResult) {
- diagStatusService.report(new ServiceDescriptor(
- diagStatusIdentifier, ServiceState.ERROR, threadName + " terminated"));
+ openflowDiagStatusProvider.reportStatus(diagStatusIdentifier, ServiceState.ERROR,
+ threadName + " terminated");
}
} , MoreExecutors.directExecutor());
return serverFacade.getIsOnlineFuture();
factory.setUseBarrier(connConfig.useBarrier());
factory.setChannelOutboundQueueSize(connConfig.getChannelOutboundQueueSize());
final TransportProtocol transportProtocol = (TransportProtocol) connConfig.getTransferProtocol();
-
// Check if Epoll native transport is available.
// TODO : Add option to disable Epoll.
boolean isEpollEnabled = Epoll.isAvailable();
if (TransportProtocol.TCP.equals(transportProtocol) || TransportProtocol.TLS.equals(transportProtocol)) {
- server = new TcpHandler(connConfig.getAddress(), connConfig.getPort(), () -> diagStatusService
- .report(new ServiceDescriptor(diagStatusIdentifier, ServiceState.OPERATIONAL)));
+ server = new TcpHandler(connConfig.getAddress(), connConfig.getPort(), () ->
+ openflowDiagStatusProvider.reportStatus(diagStatusIdentifier, ServiceState.OPERATIONAL));
final TcpChannelInitializer channelInitializer = factory.createPublishingChannelInitializer();
((TcpHandler) server).setChannelInitializer(channelInitializer);
((TcpHandler) server).initiateEventLoopGroups(connConfig.getThreadConfiguration(), isEpollEnabled);
-
final EventLoopGroup workerGroupFromTcpHandler = ((TcpHandler) server).getWorkerGroup();
connectionInitializer = new TcpConnectionInitializer(workerGroupFromTcpHandler, isEpollEnabled);
connectionInitializer.setChannelInitializer(channelInitializer);
connectionInitializer.run();
} else if (TransportProtocol.UDP.equals(transportProtocol)) {
- server = new UdpHandler(connConfig.getAddress(), connConfig.getPort(), () -> diagStatusService
- .report(new ServiceDescriptor(diagStatusIdentifier, ServiceState.OPERATIONAL)));
+ server = new UdpHandler(connConfig.getAddress(), connConfig.getPort(), () ->
+ openflowDiagStatusProvider.reportStatus(diagStatusIdentifier, ServiceState.OPERATIONAL));
((UdpHandler) server).initiateEventLoopGroups(connConfig.getThreadConfiguration(), isEpollEnabled);
((UdpHandler) server).setChannelInitializer(factory.createUdpChannelInitializer());
} else {
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.infrautils.diagstatus.DiagStatusService;
+import org.opendaylight.openflowjava.protocol.api.connection.OpenflowDiagStatusProvider;
import org.opendaylight.openflowjava.protocol.api.connection.SwitchConnectionHandler;
import org.opendaylight.openflowjava.protocol.api.connection.TlsConfiguration;
import org.opendaylight.openflowjava.protocol.api.connection.TlsConfigurationImpl;
* @author michal.polkorab
*/
public class SwitchConnectionProviderImpl02Test {
- @Mock DiagStatusService diagStatusService;
@Mock SwitchConnectionHandler handler;
@Mock OFGeneralSerializer serializer;
@Mock OFGeneralDeserializer deserializer;
@Mock OFSerializer<ExperimenterDataOfChoice> serializerMultipartRequestExpCase;
@Mock OFSerializer<MeterBandExperimenterCase> serializerMeterBandExpCase;
@Mock ConnectionConfigurationImpl config;
+ @Mock OpenflowDiagStatusProvider openflowPluginDiagStatusProvider;
private static final int CHANNEL_OUTBOUND_QUEUE_SIZE = 1024;
private static final int SWITCH_IDLE_TIMEOUT = 2000;
private TlsConfiguration tlsConfiguration;
if (protocol != null) {
createConfig(protocol);
}
- provider = new SwitchConnectionProviderImpl(config, diagStatusService);
+ provider = new SwitchConnectionProviderImpl(config,openflowPluginDiagStatusProvider);
}
private void createConfig(final TransportProtocol protocol) throws UnknownHostException {
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.infrautils.diagstatus.DiagStatusService;
+import org.opendaylight.openflowjava.protocol.api.connection.OpenflowDiagStatusProvider;
import org.opendaylight.openflowjava.protocol.api.connection.SwitchConnectionHandler;
import org.opendaylight.openflowjava.protocol.api.connection.TlsConfiguration;
import org.opendaylight.openflowjava.protocol.api.connection.TlsConfigurationImpl;
public class SwitchConnectionProviderImplTest {
@Mock SwitchConnectionHandler handler;
- @Mock DiagStatusService diagStatusService;
+ @Mock OpenflowDiagStatusProvider openflowPluginDiagStatusProvider;
private static final int SWITCH_IDLE_TIMEOUT = 2000;
private static final int WAIT_TIMEOUT = 2000;
* Creates new {@link SwitchConnectionProvider} instance for each test.
* @param protocol communication protocol
*/
+
public void startUp(final TransportProtocol protocol) throws UnknownHostException {
MockitoAnnotations.initMocks(this);
config = null;
if (protocol != null) {
createConfig(protocol);
}
- provider = new SwitchConnectionProviderImpl(config, diagStatusService);
+ provider = new SwitchConnectionProviderImpl(config, openflowPluginDiagStatusProvider);
}
private void createConfig(final TransportProtocol protocol) throws UnknownHostException {
import org.junit.After;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.infrautils.diagstatus.DiagStatusService;
+import org.opendaylight.openflowjava.protocol.api.connection.OpenflowDiagStatusProvider;
import org.opendaylight.openflowjava.protocol.api.connection.TlsConfiguration;
import org.opendaylight.openflowjava.protocol.api.connection.TlsConfigurationImpl;
import org.opendaylight.openflowjava.protocol.impl.clients.ClientEvent;
connConfig.setTransferProtocol(protocol);
mockPlugin = new MockPlugin();
- switchConnectionProvider = new SwitchConnectionProviderImpl(connConfig, Mockito.mock(DiagStatusService.class));
+ switchConnectionProvider = new SwitchConnectionProviderImpl(connConfig,
+ Mockito.mock(OpenflowDiagStatusProvider.class));
switchConnectionProvider.setSwitchConnectionHandler(mockPlugin);
switchConnectionProvider.startup().get(CONNECTION_TIMEOUT, TimeUnit.MILLISECONDS);
if (protocol.equals(TransportProtocol.TCP) || protocol.equals(TransportProtocol.TLS)) {
*/
package org.opendaylight.openflowjava.protocol.spi.connection;
+import org.opendaylight.openflowjava.protocol.api.connection.OpenflowDiagStatusProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow._switch.connection.config.rev160506.SwitchConnectionConfig;
/**
* @param config the SwitchConnectionConfig
* @return a SwitchConnectionProvider instance
*/
- SwitchConnectionProvider newInstance(SwitchConnectionConfig config);
+ SwitchConnectionProvider newInstance(SwitchConnectionConfig config,
+ OpenflowDiagStatusProvider openflowPluginDiagStatusProvider);
}
<?xml version="1.0" encoding="UTF-8"?>
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0">
-
+ <reference id="openflowPluginDiagStatusProvider" interface="org.opendaylight.openflowjava.protocol.api.connection.OpenflowDiagStatusProvider"/>
<reference id="switchConnectionProviderFactory" interface="org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProviderFactory"/>
-
<!-- Create OF switch connection provider on port 6653 (default) -->
<odl:clustered-app-config id="defaultSwitchConnConfig" default-config-file-name="default-openflow-connection-config.xml"
binding-class="org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow._switch.connection.config.rev160506.SwitchConnectionConfig"
</odl:clustered-app-config>
<bean id="defaultSwitchConnProvider" factory-ref="switchConnectionProviderFactory" factory-method="newInstance">
<argument ref="defaultSwitchConnConfig"/>
+ <argument ref="openflowPluginDiagStatusProvider"/>
</bean>
<service ref="defaultSwitchConnProvider" interface="org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProvider"
odl:type="openflow-switch-connection-provider-default-impl"/>
</odl:clustered-app-config>
<bean id="legacySwitchConnProvider" factory-ref="switchConnectionProviderFactory" factory-method="newInstance">
<argument ref="legacySwitchConnConfig"/>
+ <argument ref="openflowPluginDiagStatusProvider"/>
</bean>
<service ref="legacySwitchConnProvider" interface="org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProvider"
odl:type="openflow-switch-connection-provider-legacy-impl"/>
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+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.OpenFlowPluginProvider;
private ConnectionManager connectionManager;
private ListeningExecutorService executorService;
private ContextChainHolderImpl contextChainHolder;
- private final OpenflowPluginDiagStatusProvider openflowPluginStatusMonitor;
+ private final OpenflowDiagStatusProvider openflowDiagStatusProvider;
private final SettableFuture<Void> fullyStarted = SettableFuture.create();
+ private static final String OPENFLOW_SERVICE_NAME = "OPENFLOW";
public static MessageIntelligenceAgency getMessageIntelligenceAgency() {
return MESSAGE_INTELLIGENCE_AGENCY;
final @Reference ClusterSingletonServiceProvider singletonServiceProvider,
final @Reference EntityOwnershipService entityOwnershipService,
final MastershipChangeServiceManager mastershipChangeServiceManager,
- final OpenflowPluginDiagStatusProvider openflowPluginStatusMonitor,
+ final @Reference OpenflowDiagStatusProvider openflowDiagStatusProvider,
final @Reference SystemReadyMonitor systemReadyMonitor) {
this.switchConnectionProviders = switchConnectionProviders;
this.dataBroker = pingPongDataBroker;
deviceInitializerProvider = DeviceInitializerProviderFactory.createDefaultProvider();
config = new OpenFlowProviderConfigImpl(configurationService);
this.mastershipChangeServiceManager = mastershipChangeServiceManager;
- this.openflowPluginStatusMonitor = openflowPluginStatusMonitor;
+ this.openflowDiagStatusProvider = openflowDiagStatusProvider;
systemReadyMonitor.registerListener(this);
LOG.info("registered onSystemBootReady() listener for deferred startSwitchConnections()");
}
@Override
public void onSuccess(@Nonnull final List<Boolean> result) {
LOG.info("All switchConnectionProviders are up and running ({}).", result.size());
- openflowPluginStatusMonitor.reportStatus(ServiceState.OPERATIONAL);
+ openflowDiagStatusProvider.reportStatus(OPENFLOW_SERVICE_NAME, ServiceState.OPERATIONAL);
fullyStarted.set(null);
}
@Override
public void onFailure(@Nonnull final Throwable throwable) {
LOG.warn("Some switchConnectionProviders failed to start.", throwable);
- openflowPluginStatusMonitor.reportStatus(ServiceState.ERROR, throwable);
+ openflowDiagStatusProvider.reportStatus(OPENFLOW_SERVICE_NAME, throwable);
fullyStarted.setException(throwable);
}
}, MoreExecutors.directExecutor());
gracefulShutdown(executorService);
gracefulShutdown(hashedWheelTimer);
unregisterMXBean(MESSAGE_INTELLIGENCE_AGENCY_MX_BEAN_NAME);
- openflowPluginStatusMonitor.reportStatus(ServiceState.UNREGISTERED);
+ openflowDiagStatusProvider.reportStatus(ServiceState.UNREGISTERED);
}
@SuppressWarnings("checkstyle:IllegalCatch")
+++ /dev/null
-/*
- * Copyright (c) 2017 Ericsson India Global Services Pvt Ltd. 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.openflowplugin.impl;
-
-import javax.inject.Inject;
-import javax.inject.Singleton;
-import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.infrautils.diagstatus.DiagStatusService;
-import org.opendaylight.infrautils.diagstatus.ServiceDescriptor;
-import org.opendaylight.infrautils.diagstatus.ServiceState;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@Singleton
-public class OpenflowPluginDiagStatusProvider {
-
- private static final Logger LOG = LoggerFactory.getLogger(OpenflowPluginDiagStatusProvider.class);
- private static final String OPENFLOW_SERVICE_NAME = "OPENFLOW";
-
- private final DiagStatusService diagStatusService;
-
- @Inject
- public OpenflowPluginDiagStatusProvider(final @Reference DiagStatusService diagStatusService) {
- this.diagStatusService = diagStatusService;
- diagStatusService.register(OPENFLOW_SERVICE_NAME);
- }
-
- public void reportStatus(ServiceState serviceState) {
- LOG.debug("reporting status as {} for {}", serviceState, OPENFLOW_SERVICE_NAME);
- diagStatusService.report(new ServiceDescriptor(OPENFLOW_SERVICE_NAME, serviceState));
- }
-
- public void reportStatus(ServiceState serviceState, Throwable throwable) {
- LOG.debug("reporting status as {} for {}", serviceState, OPENFLOW_SERVICE_NAME);
- diagStatusService.report(new ServiceDescriptor(OPENFLOW_SERVICE_NAME, throwable));
- }
-
- public void reportStatus(ServiceState serviceState, String description) {
- LOG.debug("reporting status as {} for {}", serviceState, OPENFLOW_SERVICE_NAME);
- diagStatusService.report(new ServiceDescriptor(OPENFLOW_SERVICE_NAME, serviceState, description));
- }
-}
<reference id="switchConnectionProviderList" interface="org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProviderList" ext:proxy-method="classes"/>
+ <reference id="openflowPluginDiagStatusProviderImpl" interface="org.opendaylight.openflowjava.protocol.api.connection.OpenflowDiagStatusProvider" ext:proxy-method="classes"/>
+
<odl:action-provider interface="org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService"/>
</blueprint>
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListenerRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+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.configuration.ConfigurationProperty;
NotificationPublishService notificationPublishService;
@Mock
- OpenflowPluginDiagStatusProvider ofPluginDiagstatusProvider;
+ OpenflowDiagStatusProvider ofPluginDiagstatusProvider;
@Mock
SystemReadyMonitor systemReadyMonitor;