<plugin>
<groupId>org.apache.aries.blueprint</groupId>
<artifactId>blueprint-maven-plugin</artifactId>
+ <configuration>
+ <scanPaths>
+ <scanPath>org.opendaylight.openflowplugin.applications.arbitratorreconciliation</scanPath>
+ </scanPaths>
+ </configuration>
</plugin>
</plugins>
</build>
<plugin>
<groupId>org.apache.aries.blueprint</groupId>
<artifactId>blueprint-maven-plugin</artifactId>
+ <configuration>
+ <scanPaths>
+ <scanPath>org.opendaylight.openflowplugin.applications.frm</scanPath>
+ </scanPaths>
+ </configuration>
</plugin>
</plugins>
</build>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>javax.inject</groupId>
+ <artifactId>javax.inject</artifactId>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.aries.blueprint</groupId>
+ <artifactId>blueprint-maven-plugin-annotation</artifactId>
+ <optional>true</optional>
+ </dependency>
</dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.aries.blueprint</groupId>
+ <artifactId>blueprint-maven-plugin</artifactId>
+ <configuration>
+ <scanPaths>
+ <scanPath>org.opendaylight.openflowplugin.openflow.ofswitch.config</scanPath>
+ </scanPaths>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
</project>
import java.util.Collection;
import java.util.concurrent.Future;
import javax.annotation.Nonnull;
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Singleton
public class DefaultConfigPusher implements AutoCloseable, ClusteredDataTreeChangeListener<FlowCapableNode> {
private static final Logger LOG = LoggerFactory.getLogger(DefaultConfigPusher.class);
private static final long STARTUP_LOOP_TICK = 500L;
private final DeviceOwnershipService deviceOwnershipService;
private ListenerRegistration<?> listenerRegistration;
- public DefaultConfigPusher(NodeConfigService nodeConfigService, DataBroker dataBroker,
- DeviceOwnershipService deviceOwnershipService) {
+ @Inject
+ public DefaultConfigPusher(NodeConfigService nodeConfigService, @Reference DataBroker dataBroker,
+ @Reference DeviceOwnershipService deviceOwnershipService) {
this.nodeConfigService = nodeConfigService;
this.dataBroker = dataBroker;
this.deviceOwnershipService = Preconditions.checkNotNull(deviceOwnershipService,
}
@SuppressWarnings("checkstyle:IllegalCatch")
+ @PostConstruct
public void start() {
try {
final InstanceIdentifier<FlowCapableNode> path = InstanceIdentifier.create(Nodes.class).child(Node.class)
}
@Override
+ @PreDestroy
public void close() {
if (listenerRegistration != null) {
listenerRegistration.close();
xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
odl:use-default-for-reference-types="true">
- <reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
- <reference id="deviceOwnershipService" interface="org.opendaylight.openflowplugin.applications.deviceownershipservice.DeviceOwnershipService"/>
-
<odl:rpc-service id="nodeConfigService" interface="org.opendaylight.yang.gen.v1.urn.opendaylight.module.config.rev141015.NodeConfigService"/>
- <bean id="LLDPPacketPuntEnforcer" class="org.opendaylight.openflowplugin.openflow.ofswitch.config.DefaultConfigPusher"
- init-method="start" destroy-method="close">
- <argument ref="nodeConfigService"/>
- <argument ref="dataBroker"/>
- <argument ref="deviceOwnershipService"/>
- </bean>
</blueprint>
\ No newline at end of file
<artifactId>org.apache.karaf.shell.console</artifactId>
<scope>provided</scope>
</dependency>
+ <dependency>
+ <groupId>javax.inject</groupId>
+ <artifactId>javax.inject</artifactId>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.aries.blueprint</groupId>
+ <artifactId>blueprint-maven-plugin-annotation</artifactId>
+ <optional>true</optional>
+ </dependency>
</dependencies>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.aries.blueprint</groupId>
+ <artifactId>blueprint-maven-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </build>
<scm>
<connection>scm:git:ssh://git.opendaylight.org:29418/openflowplugin.git</connection>
<developerConnection>scm:git:ssh://git.opendaylight.org:29418/openflowplugin.git</developerConnection>
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+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.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeException;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Singleton
+@Service(classes = ReconciliationManager.class)
public class ReconciliationManagerImpl implements ReconciliationManager, ReconciliationFrameworkEvent {
private static final Logger LOG = LoggerFactory.getLogger(ReconciliationManagerImpl.class);
private final Map<ResultState, Integer> resultStateMap = new ConcurrentHashMap<>();
private final AtomicReference<ResultState> decidedResultState = new AtomicReference<>(ResultState.DONOTHING);
- public ReconciliationManagerImpl(MastershipChangeServiceManager mastershipChangeServiceManager) {
+ @Inject
+ public ReconciliationManagerImpl(@Reference MastershipChangeServiceManager mastershipChangeServiceManager) {
this.mastershipChangeServiceManager = Preconditions
.checkNotNull(mastershipChangeServiceManager, "MastershipChangeServiceManager can not be null!");
}
+ @PostConstruct
public void start() throws MastershipChangeException {
mastershipChangeServiceManager.reconciliationFrameworkRegistration(this);
LOG.info("ReconciliationManager has started successfully.");
}
@Override
+ @PreDestroy
public void close() throws Exception {
}
xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
odl:use-default-for-reference-types="true">
- <reference id="reconciliationManagerRef"
- interface="org.opendaylight.openflowplugin.applications.reconciliation.ReconciliationManager"
- availability="optional"/>
<command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
<command>
<action class="org.opendaylight.openflowplugin.applications.reconciliation.cli.GetRegisteredServices">
<property name="reconciliationManager"
- ref="reconciliationManagerRef"/>
+ ref="reconciliationManagerImpl"/>
</action>
</command>
</command-bundle>
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
- xmlns:cm="http://aries.apache.org/blueprint/xmlns/blueprint-cm/v1.1.0"
- xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
- odl:use-default-for-reference-types="true">
-
- <reference id="mastershipChangeServiceManager"
- interface="org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager"/>
- <bean id="reconciliationManagerImpl"
- class="org.opendaylight.openflowplugin.applications.reconciliation.impl.ReconciliationManagerImpl"
- init-method="start"
- destroy-method="close">
- <argument ref="mastershipChangeServiceManager"/>
- </bean>
- <service ref="reconciliationManagerImpl"
- interface="org.opendaylight.openflowplugin.applications.reconciliation.ReconciliationManager"
- odl:type="default"/>
-
-</blueprint>
\ No newline at end of file
<artifactId>slf4j-log4j12</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>javax.inject</groupId>
+ <artifactId>javax.inject</artifactId>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.aries.blueprint</groupId>
+ <artifactId>blueprint-maven-plugin-annotation</artifactId>
+ <optional>true</optional>
+ </dependency>
</dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.aries.blueprint</groupId>
+ <artifactId>blueprint-maven-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </build>
<scm>
<connection>scm:git:ssh://git.opendaylight.org:29418/openflowplugin.git</connection>
<developerConnection>scm:git:ssh://git.opendaylight.org:29418/openflowplugin.git</developerConnection>
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Singleton
public class FlowCapableTopologyProvider implements ClusterSingletonService, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(FlowCapableTopologyProvider.class);
private static final String TOPOLOGY_PROVIDER = "ofp-topology-manager";
private ListenerRegistration<NotificationListener> listenerRegistration;
private ClusterSingletonServiceRegistration singletonServiceRegistration;
- public FlowCapableTopologyProvider(final DataBroker dataBroker,
- final NotificationProviderService notificationService,
+ @Inject
+ public FlowCapableTopologyProvider(@Reference final DataBroker dataBroker,
+ @Reference final NotificationProviderService notificationService,
final OperationProcessor processor,
- final ClusterSingletonServiceProvider clusterSingletonServiceProvider) {
+ @Reference final ClusterSingletonServiceProvider
+ clusterSingletonServiceProvider) {
this.dataBroker = dataBroker;
this.notificationService = notificationService;
this.processor = processor;
/**
* Gets called on start of a bundle.
*/
+ @PostConstruct
public void start() {
final TopologyKey key = new TopologyKey(new TopologyId(TOPOLOGY_ID));
this.topologyPathIID = InstanceIdentifier.create(NetworkTopology.class).child(Topology.class, key);
}
@Override
+ @PreDestroy
public void close() {
this.transactionChainManager.close();
if (this.listenerRegistration != null) {
import java.util.Collection;
import javax.annotation.Nonnull;
+import javax.annotation.PreDestroy;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Singleton
public class NodeChangeListenerImpl extends DataTreeChangeListenerImpl<FlowCapableNode> {
private static final Logger LOG = LoggerFactory.getLogger(NodeChangeListenerImpl.class);
- public NodeChangeListenerImpl(final DataBroker dataBroker, final OperationProcessor operationProcessor) {
+ @Inject
+ public NodeChangeListenerImpl(@Reference final DataBroker dataBroker, final OperationProcessor operationProcessor) {
// TODO: listener on FlowCapableNode. what if node id in Node.class is changed (it won't be caught by this
// listener)
super(operationProcessor, dataBroker,
}
}
+ @Override
+ @PreDestroy
+ public void close() throws Exception {
+ super.close();
+ }
+
private void processRemovedNode(final DataTreeModification<FlowCapableNode> modification) {
final InstanceIdentifier<FlowCapableNode> iiToNodeInInventory = modification.getRootPath().getRootIdentifier();
final NodeId nodeId = provideTopologyNodeId(iiToNodeInInventory);
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.openflowplugin.common.txchain.TransactionChainManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Singleton
public final class OperationProcessor implements AutoCloseable, Runnable {
private static final Logger LOG = LoggerFactory.getLogger(OperationProcessor.class);
private static final int MAX_TRANSACTION_OPERATIONS = 100;
private TransactionChainManager transactionChainManager;
private volatile boolean finishing = false;
- public OperationProcessor(final DataBroker dataBroker) {
+ @Inject
+ public OperationProcessor(@Reference final DataBroker dataBroker) {
transactionChainManager = new TransactionChainManager(dataBroker, TOPOLOGY_MANAGER);
transactionChainManager.activateTransactionManager();
transactionChainManager.initialSubmitWriteTransaction();
}
}
+ @PostConstruct
public void start() {
thread.start();
}
}
@Override
+ @PreDestroy
public void close() {
thread.interrupt();
try {
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
+import javax.annotation.PreDestroy;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Singleton
public class TerminationPointChangeListenerImpl extends DataTreeChangeListenerImpl<FlowCapableNodeConnector> {
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointChangeListenerImpl.class);
- public TerminationPointChangeListenerImpl(final DataBroker dataBroker,
+ @Inject
+ public TerminationPointChangeListenerImpl(@Reference final DataBroker dataBroker,
final OperationProcessor operationProcessor) {
super(operationProcessor, dataBroker,
InstanceIdentifier.builder(Nodes.class).child(Node.class).child(NodeConnector.class)
}
}
+ @Override
+ @PreDestroy
+ public void close() throws Exception {
+ super.close();
+ }
+
private void processRemovedTerminationPoints(final DataTreeModification<FlowCapableNodeConnector> modification) {
final InstanceIdentifier<FlowCapableNodeConnector> removedNode = modification.getRootPath().getRootIdentifier();
final TpId terminationPointId = provideTopologyTerminationPointId(removedNode);
+++ /dev/null
-<?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"
- odl:use-default-for-reference-types="true">
-
- <reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
- <reference id="notificationService" interface="org.opendaylight.controller.sal.binding.api.NotificationProviderService"/>
- <reference id="clusterSingletonService" interface="org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider"/>
-
- <bean id="operationProcessor" class="org.opendaylight.openflowplugin.applications.topology.manager.OperationProcessor"
- init-method="start" destroy-method="close">
- <argument ref="dataBroker"/>
- </bean>
-
- <bean id="termPointChangeListener" class="org.opendaylight.openflowplugin.applications.topology.manager.TerminationPointChangeListenerImpl"
- destroy-method="close">
- <argument ref="dataBroker"/>
- <argument ref="operationProcessor"/>
- </bean>
-
- <bean id="nodeChangeListener" class="org.opendaylight.openflowplugin.applications.topology.manager.NodeChangeListenerImpl"
- destroy-method="close">
- <argument ref="dataBroker"/>
- <argument ref="operationProcessor"/>
- </bean>
-
- <bean id="topologyProvider" class="org.opendaylight.openflowplugin.applications.topology.manager.FlowCapableTopologyProvider"
- init-method="start" destroy-method="close">
- <argument ref="dataBroker"/>
- <argument ref="notificationService"/>
- <argument ref="operationProcessor"/>
- <argument ref="clusterSingletonService"/>
- </bean>
-</blueprint>
*/
package org.opendaylight.openflowplugin.impl;
-import java.io.IOException;
-import java.net.InetAddress;
-import java.net.Socket;
-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.infrautils.diagstatus.ServiceDescriptor;
import org.opendaylight.infrautils.diagstatus.ServiceState;
-import org.opendaylight.infrautils.diagstatus.ServiceStatusProvider;
-import org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProvider;
-import org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProviderList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Singleton
-@Service(classes = ServiceStatusProvider.class)
-public class OpenflowPluginDiagStatusProvider implements ServiceStatusProvider {
+public class OpenflowPluginDiagStatusProvider {
private static final Logger LOG = LoggerFactory.getLogger(OpenflowPluginDiagStatusProvider.class);
private static final String OPENFLOW_SERVICE_NAME = "OPENFLOW";
- private static final int OF_PORT_11 = 6633;
- private static final int OF_PORT_13 = 6653;
private final DiagStatusService diagStatusService;
- private InetAddress defaultInetAddres;
- private InetAddress legacyInetAddress;
@Inject
- public OpenflowPluginDiagStatusProvider(final @Reference DiagStatusService diagStatusService,
- final SwitchConnectionProviderList switchConnectionProviders) {
+ public OpenflowPluginDiagStatusProvider(final @Reference DiagStatusService diagStatusService) {
this.diagStatusService = diagStatusService;
- setSwitchConnectionInetAddress(switchConnectionProviders);
diagStatusService.register(OPENFLOW_SERVICE_NAME);
}
- private void setSwitchConnectionInetAddress(final List<SwitchConnectionProvider> switchConnectionProviders) {
- switchConnectionProviders.forEach(switchConnectionProvider -> {
- if (switchConnectionProvider.getConfiguration().getPort() == OF_PORT_11) {
- legacyInetAddress = switchConnectionProvider.getConfiguration().getAddress();
- } else if (switchConnectionProvider.getConfiguration().getPort() == OF_PORT_13) {
- defaultInetAddres = switchConnectionProvider.getConfiguration().getAddress();
- }
- });
- }
-
public void reportStatus(ServiceState serviceState) {
LOG.debug("reporting status as {} for {}", serviceState, OPENFLOW_SERVICE_NAME);
diagStatusService.report(new ServiceDescriptor(OPENFLOW_SERVICE_NAME, serviceState));
LOG.debug("reporting status as {} for {}", serviceState, OPENFLOW_SERVICE_NAME);
diagStatusService.report(new ServiceDescriptor(OPENFLOW_SERVICE_NAME, serviceState, description));
}
-
- @Override
- public ServiceDescriptor getServiceDescriptor() {
- if (getApplicationNetworkState(OF_PORT_13, defaultInetAddres)
- && getApplicationNetworkState(OF_PORT_11, legacyInetAddress)) {
- return new ServiceDescriptor(OPENFLOW_SERVICE_NAME, ServiceState.OPERATIONAL,
- "OF::PORTS:: 6653 and 6633 are up.");
- } else {
- return new ServiceDescriptor(OPENFLOW_SERVICE_NAME, ServiceState.ERROR,
- "OF::PORTS:: 6653 and 6633 are not up yet");
- }
- }
-
- private boolean getApplicationNetworkState(int port, InetAddress inetAddress) {
- Socket socket = null;
- try {
- if (inetAddress == null) {
- socket = new Socket("localhost", port);
- } else {
- socket = new Socket(inetAddress, port);
- }
- LOG.debug("Socket connection established");
- return true;
- } catch (IOException e) {
- return false;
- } finally {
- try {
- if (socket != null) {
- socket.close();
- }
- } catch (IOException ex) {
- LOG.error("Failed to close socket : {}", socket, ex);
- }
- }
- }
}
Code Review / openflowplugin.git / commitdiff