<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>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-eos-binding-api</artifactId>
</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>
+
</project>
package org.opendaylight.openflowplugin.applications.deviceownershipservice.impl;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.regex.Pattern;
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.inject.Singleton;
+import org.apache.aries.blueprint.annotation.service.Reference;
+import org.apache.aries.blueprint.annotation.service.Service;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListener;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Singleton
+@Service(classes = DeviceOwnershipService.class)
public class DeviceOwnershipServiceImpl implements DeviceOwnershipService, EntityOwnershipListener {
private static final Logger LOG = LoggerFactory.getLogger(DeviceOwnershipServiceImpl.class);
private static final String SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.ServiceEntityType";
private final EntityOwnershipService eos;
private final ConcurrentMap<String, EntityOwnershipState> ownershipStateCache = new ConcurrentHashMap<>();
- public DeviceOwnershipServiceImpl(final EntityOwnershipService entityOwnershipService) {
+ public DeviceOwnershipServiceImpl(@Reference final EntityOwnershipService entityOwnershipService) {
this.eos = entityOwnershipService;
}
+ @PostConstruct
public void start() {
registerEntityOwnershipListener();
LOG.info("DeviceOwnershipService started");
}
+ @PreDestroy
public void close() {
LOG.info("DeviceOwnershipService closed");
}
+++ /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="entityOwnershipService" interface="org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService"/>
-
- <bean id="deviceOwnershipService" class="org.opendaylight.openflowplugin.applications.deviceownershipservice.impl.DeviceOwnershipServiceImpl"
- init-method="start"
- destroy-method="close">
- <argument ref="entityOwnershipService"/>
- </bean>
-
- <service ref="deviceOwnershipService"
- interface="org.opendaylight.openflowplugin.applications.deviceownershipservice.DeviceOwnershipService"
- odl:type="default"/>
-
-</blueprint>
<artifactId>arbitratorreconciliation-api</artifactId>
<version>${project.version}</version>
</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.applications.frm</scanPath>
+ </scanPaths>
+ </configuration>
+ </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.ExecutionException;
import java.util.concurrent.atomic.AtomicLong;
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.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
* provide all RPC services.
*
*/
+@Singleton
public class ForwardingRulesManagerImpl implements ForwardingRulesManager {
private static final Logger LOG = LoggerFactory.getLogger(ForwardingRulesManagerImpl.class);
private final OpenflowServiceRecoveryHandler openflowServiceRecoveryHandler;
private final ServiceRecoveryRegistry serviceRecoveryRegistry;
- public ForwardingRulesManagerImpl(final DataBroker dataBroker, final RpcProviderRegistry rpcRegistry,
+ @Inject
+ public ForwardingRulesManagerImpl(@Reference final DataBroker dataBroker,
+ @Reference final RpcProviderRegistry rpcRegistry,
final ForwardingRulesManagerConfig config,
- final MastershipChangeServiceManager mastershipChangeServiceManager,
- final ClusterSingletonServiceProvider clusterSingletonService,
- final ConfigurationService configurationService,
- final ReconciliationManager reconciliationManager,
+ @Reference final MastershipChangeServiceManager mastershipChangeServiceManager,
+ @Reference final ClusterSingletonServiceProvider clusterSingletonService,
+ @Reference final ConfigurationService configurationService,
+ @Reference final ReconciliationManager reconciliationManager,
final OpenflowServiceRecoveryHandler openflowServiceRecoveryHandler,
- final ServiceRecoveryRegistry serviceRecoveryRegistry) {
+ @Reference final ServiceRecoveryRegistry serviceRecoveryRegistry) {
disableReconciliation = config.isDisableReconciliation();
staleMarkingEnabled = config.isStaleMarkingEnabled();
reconciliationRetryCount = config.getReconciliationRetryCount();
}
@Override
+ @PostConstruct
public void start() {
nodeConfigurator = new NodeConfiguratorImpl();
this.devicesGroupRegistry = new DevicesGroupRegistry();
}
@Override
+ @PreDestroy
public void close() throws Exception {
configurationServiceRegistration.close();
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.apache.aries.blueprint.annotation.service.Service;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Singleton
+@Service(classes = FrmReconciliationService.class)
public class FrmReconciliationServiceImpl implements FrmReconciliationService {
private static final Logger LOG = LoggerFactory.getLogger(FrmReconciliationServiceImpl.class);
private final ForwardingRulesManagerImpl forwardingRulesManagerImpl;
+ @Inject
public FrmReconciliationServiceImpl(ForwardingRulesManagerImpl forwardingRulesManagerImpl) {
this.forwardingRulesManagerImpl = forwardingRulesManagerImpl;
}
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.applications.frm.recovery.OpenflowServiceRecoveryHandler;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryInterface;
import org.slf4j.LoggerFactory;
@Singleton
+@Service(classes = OpenflowServiceRecoveryHandler.class)
public class OpenflowServiceRecoveryHandlerImpl implements ServiceRecoveryInterface,
OpenflowServiceRecoveryHandler {
private final ServiceRecoveryRegistry serviceRecoveryRegistry;
@Inject
- public OpenflowServiceRecoveryHandlerImpl(final ServiceRecoveryRegistry serviceRecoveryRegistry) {
+ public OpenflowServiceRecoveryHandlerImpl(@Reference final ServiceRecoveryRegistry serviceRecoveryRegistry) {
LOG.info("Registering openflowplugin service recovery handlers");
this.serviceRecoveryRegistry = serviceRecoveryRegistry;
serviceRecoveryRegistry.registerServiceRecoveryRegistry(buildServiceRegistryKey(), this);
xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
odl:use-default-for-reference-types="true">
- <service ref="openflowServiceRecoveryHandler"
- interface="org.opendaylight.openflowplugin.applications.frm.recovery.OpenflowServiceRecoveryHandler"
- odl:type="default"/>
- <reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
- <reference id="rpcRegistry" interface="org.opendaylight.controller.sal.binding.api.RpcProviderRegistry"/>
- <reference id="clusterSingletonService" interface="org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider"/>
- <reference id="mastershipChangeServiceManager" interface="org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager"/>
- <reference id="configurationService" interface="org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationService"/>
- <reference id="reconciliationservice" interface="org.opendaylight.openflowplugin.applications.reconciliation.ReconciliationManager"/>
- <reference id="serviceRecoveryRegistry" interface="org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry"/>
-
- <odl:clustered-app-config id="frmConfig"
+ <odl:clustered-app-config id="forwardingRulesManagerConfig"
binding-class="org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.forwardingrules.manager.config.rev160511.ForwardingRulesManagerConfig"/>
- <bean id="openflowServiceRecoveryHandler"
- class="org.opendaylight.openflowplugin.applications.frm.recovery.impl.OpenflowServiceRecoveryHandlerImpl">
- <argument ref="serviceRecoveryRegistry"/>
- </bean>
- <bean id="frmManager" class="org.opendaylight.openflowplugin.applications.frm.impl.ForwardingRulesManagerImpl"
- init-method="start" destroy-method="close">
- <argument ref="dataBroker"/>
- <argument ref="rpcRegistry"/>
- <argument ref="frmConfig"/>
- <argument ref="mastershipChangeServiceManager"/>
- <argument ref="clusterSingletonService"/>
- <argument ref="configurationService"/>
- <argument ref="reconciliationservice"/>
- <argument ref="openflowServiceRecoveryHandler"/>
- <argument ref="serviceRecoveryRegistry"/>
- </bean>
-
- <bean id="frmReconciliationService"
- class="org.opendaylight.openflowplugin.applications.frm.impl.FrmReconciliationServiceImpl">
- <argument ref="frmManager"/>
- </bean>
- <service ref="frmReconciliationService"
- interface="org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.frm.reconciliation.service.rev180227.FrmReconciliationService"
- odl:type="default"/>
-
</blueprint>
//resultVehicle = updateTableFeatures(nodeIdent, configTree);
resultVehicle = Futures.transformAsync(resultVehicle, input -> {
- if (!input.isSuccessful()) {
+ // if (!input.isSuccessful()) {
//TODO chain errors but not skip processing on first error return Futures.immediateFuture(input);
//final ListenableFuture<RpcResult<Void>> singleVoidUpdateResult = Futures.transform(
// Futures.asList Arrays.asList(input, output),
// ReconcileUtil.<UpdateFlowOutput>createRpcResultCondenser("TODO"));
- }
+ // }
return addMissingGroups(nodeId, nodeIdent, diffInput.getGroupsToAddOrUpdate(), counters);
}, MoreExecutors.directExecutor());
Futures.addCallback(resultVehicle, FxChainUtil.logResultCallback(nodeId, "addMissingGroups"),
MoreExecutors.directExecutor());
resultVehicle = Futures.transformAsync(resultVehicle, input -> {
- if (!input.isSuccessful()) {
+ // if (!input.isSuccessful()) {
//TODO chain errors but not skip processing on first error return Futures.immediateFuture(input);
- }
+ // }
return addMissingMeters(nodeId, nodeIdent, diffInput.getMetersToAddOrUpdate(), counters);
}, MoreExecutors.directExecutor());
Futures.addCallback(resultVehicle, FxChainUtil.logResultCallback(nodeId, "addMissingMeters"),
MoreExecutors.directExecutor());
resultVehicle = Futures.transformAsync(resultVehicle, input -> {
- if (!input.isSuccessful()) {
+ // if (!input.isSuccessful()) {
//TODO chain errors but not skip processing on first error return Futures.immediateFuture(input);
- }
+ // }
return addMissingFlows(nodeId, nodeIdent, diffInput.getFlowsToAddOrUpdate(), counters);
}, MoreExecutors.directExecutor());
Futures.addCallback(resultVehicle, FxChainUtil.logResultCallback(nodeId, "addMissingFlows"),
resultVehicle = Futures.transformAsync(resultVehicle, input -> {
- if (!input.isSuccessful()) {
+ // if (!input.isSuccessful()) {
//TODO chain errors but not skip processing on first error return Futures.immediateFuture(input);
- }
+ // }
return removeRedundantFlows(nodeId, nodeIdent, diffInput.getFlowsToRemove(), counters);
}, MoreExecutors.directExecutor());
Futures.addCallback(resultVehicle, FxChainUtil.logResultCallback(nodeId, "removeRedundantFlows"),
MoreExecutors.directExecutor());
resultVehicle = Futures.transformAsync(resultVehicle, input -> {
- if (!input.isSuccessful()) {
+ // if (!input.isSuccessful()) {
//TODO chain errors but not skip processing on first error return Futures.immediateFuture(input);
- }
+ // }
return removeRedundantMeters(nodeId, nodeIdent, diffInput.getMetersToRemove(), counters);
}, MoreExecutors.directExecutor());
Futures.addCallback(resultVehicle, FxChainUtil.logResultCallback(nodeId, "removeRedundantMeters"),
MoreExecutors.directExecutor());
resultVehicle = Futures.transformAsync(resultVehicle, input -> {
- if (!input.isSuccessful()) {
+ // if (!input.isSuccessful()) {
//TODO chain errors but not skip processing on first error return Futures.immediateFuture(input);
- }
+ // }
return removeRedundantGroups(nodeId, nodeIdent, diffInput.getGroupsToRemove(), counters);
}, MoreExecutors.directExecutor());
Futures.addCallback(resultVehicle, FxChainUtil.logResultCallback(nodeId, "removeRedundantGroups"),
package org.opendaylight.openflowplugin.applications.lldpspeaker;
+import static org.opendaylight.infrautils.utils.concurrent.LoggingFutures.addErrorLogging;
+
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.security.NoSuchAlgorithmException;
if (deviceOwnershipService.isEntityOwned(nodeId.getValue())) {
LOG.debug("Node is owned by this controller, sending LLDP packet through port {}",
nodeConnectorId.getValue());
- packetProcessingService.transmitPacket(nodeConnectorMap.get(ncIID));
+ addErrorLogging(packetProcessingService.transmitPacket(nodeConnectorMap.get(ncIID)), LOG,
+ "transmitPacket() failed");
} else {
LOG.debug("Node {} is not owned by this controller, so skip sending LLDP packet on port {}",
nodeId.getValue(), nodeConnectorId.getValue());
* 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.applications.lldpspeaker;
import static org.opendaylight.openflowplugin.applications.topology.lldp.utils.LLDPDiscoveryUtils.getValueForLLDPPacketIntegrityEnsuring;
+import com.google.common.base.Strings;
import java.math.BigInteger;
import java.security.NoSuchAlgorithmException;
import javax.annotation.Nonnull;
-import org.apache.commons.lang3.StringUtils;
import org.opendaylight.openflowplugin.libraries.liblldp.EtherTypes;
import org.opendaylight.openflowplugin.libraries.liblldp.Ethernet;
import org.opendaylight.openflowplugin.libraries.liblldp.HexEncode;
}
private static String bigIntegerToPaddedHex(final BigInteger dataPathId) {
- return StringUtils.leftPad(dataPathId.toString(16), 16, "0");
+ return Strings.padStart(dataPathId.toString(16), 16, '0');
}
}
<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>mockito-core</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>
package org.opendaylight.openflowplugin.applications.topology.lldp;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import javax.annotation.PreDestroy;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.lldp.discovery.config.rev160511.TopologyLldpDiscoveryConfig;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Singleton
public class LLDPActivator implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(LLDPActivator.class);
private final ListenerRegistration<NotificationListener> lldpNotificationRegistration;
@SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
- public LLDPActivator(NotificationProviderService notificationService, LLDPDiscoveryListener lldpDiscoveryListener,
+ @Inject
+ public LLDPActivator(@Reference NotificationProviderService notificationService,
+ LLDPDiscoveryListener lldpDiscoveryListener,
TopologyLldpDiscoveryConfig topologyLldpDiscoveryConfig) {
lldpSecureKey = topologyLldpDiscoveryConfig.getLldpSecureKey();
}
@Override
+ @PreDestroy
public void close() {
lldpNotificationRegistration.close();
*/
package org.opendaylight.openflowplugin.applications.topology.lldp;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.openflowplugin.applications.topology.lldp.utils.LLDPDiscoveryUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Singleton
public class LLDPDiscoveryListener implements PacketProcessingListener {
private static final Logger LOG = LoggerFactory.getLogger(LLDPDiscoveryListener.class);
private final NotificationProviderService notificationService;
private final EntityOwnershipService eos;
-
- public LLDPDiscoveryListener(final NotificationProviderService notificationService, final LLDPLinkAger lldpLinkAger,
- final EntityOwnershipService entityOwnershipService) {
+ @Inject
+ public LLDPDiscoveryListener(@Reference final NotificationProviderService notificationService,
+ final LLDPLinkAger lldpLinkAger, @Reference final EntityOwnershipService entityOwnershipService) {
this.notificationService = notificationService;
this.lldpLinkAger = lldpLinkAger;
this.eos = entityOwnershipService;
import java.util.TimerTask;
import java.util.concurrent.ConcurrentHashMap;
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.sal.binding.api.NotificationProviderService;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Singleton
public class LLDPLinkAger implements ConfigurationListener, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(LLDPLinkAger.class);
private final long linkExpirationTime;
/**
* default ctor - start timer.
*/
+ @Inject
public LLDPLinkAger(final TopologyLldpDiscoveryConfig topologyLldpDiscoveryConfig,
- final NotificationProviderService notificationService,
- final ConfigurationService configurationService, final EntityOwnershipService entityOwnershipService) {
+ @Reference final NotificationProviderService notificationService,
+ @Reference final ConfigurationService configurationService,
+ @Reference final EntityOwnershipService entityOwnershipService) {
this.linkExpirationTime = topologyLldpDiscoveryConfig.getTopologyLldpExpirationInterval().getValue();
this.notificationService = notificationService;
this.configurationServiceRegistration = configurationService.registerListener(this);
}
@Override
+ @PreDestroy
public void close() throws Exception {
timer.cancel();
linkToDate.clear();
Optional.ofNullable(TopologyLLDPDiscoveryProperty.forValue(propertyName)).ifPresent(lldpDiscoveryProperty -> {
switch (lldpDiscoveryProperty) {
case LLDP_SECURE_KEY:
- LOG.warn("Runtime update not supported for property {}", lldpDiscoveryProperty);
- break;
case TOPOLOGY_LLDP_INTERVAL:
- LOG.warn("Runtime update not supported for property {}", lldpDiscoveryProperty);
- break;
case TOPOLOGY_LLDP_EXPIRATION_INTERVAL:
LOG.warn("Runtime update not supported for property {}", lldpDiscoveryProperty);
break;
xmlns:cm="http://aries.apache.org/blueprint/xmlns/blueprint-cm/v1.1.0"
odl:use-default-for-reference-types="true">
- <reference id="notificationService" interface="org.opendaylight.controller.sal.binding.api.NotificationProviderService"/>
- <reference id="configurationService" interface="org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationService"/>
- <reference id="entityOwnershipService" interface="org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService"/>
-
- <odl:clustered-app-config id="topologyLLDPConfig"
+ <odl:clustered-app-config id="topologyLldpDiscoveryConfig"
binding-class="org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.lldp.discovery.config.rev160511.TopologyLldpDiscoveryConfig">
<odl:default-config><![CDATA[
<topology-lldp-discovery-config xmlns="urn:opendaylight:params:xml:ns:yang:topology-lldp-discovery:config">
]]></odl:default-config>
</odl:clustered-app-config>
- <bean id="lldpLinkAger" class="org.opendaylight.openflowplugin.applications.topology.lldp.LLDPLinkAger"
- destroy-method="close">
- <argument ref="topologyLLDPConfig"/>
- <argument ref="notificationService"/>
- <argument ref="configurationService"/>
- <argument ref="entityOwnershipService"/>
- </bean>
-
- <bean id="lldpDiscoveryListener" class="org.opendaylight.openflowplugin.applications.topology.lldp.LLDPDiscoveryListener">
- <argument ref="notificationService"/>
- <argument ref="lldpLinkAger"/>
- <argument ref="entityOwnershipService"/>
- </bean>
-
- <bean id="LLDPActivator" class="org.opendaylight.openflowplugin.applications.topology.lldp.LLDPActivator"
- destroy-method="close">
- <argument ref="notificationService"/>
- <argument ref="lldpDiscoveryListener"/>
- <argument ref="topologyLLDPConfig"/>
- </bean>
</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>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
</parent>
<groupId>org.opendaylight.openflowplugin</groupId>
<artifactId>openflowplugin-karaf</artifactId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
--- /dev/null
+/*
+ * Copyright (c) 2018 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.openflowplugin.extension.api;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.annotations.Beta;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.yang.binding.Augmentable;
+import org.opendaylight.yangtools.yang.binding.Augmentation;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+
+/**
+ * Resolver providing a bridge between a grouping and its various instantiations via augment. This is useful for
+ * extracting the grouping's content from a DataObject's augmentations without knowing from which instantiation it
+ * comes from.
+ *
+ * <p>
+ * Typical use case is, given a base grouping module:
+ * <pre>
+ * module foo;
+ *
+ * grouping foo {
+ * container augmentable {
+ *
+ * }
+ * }
+ * </pre>
+ * and a module independent of it:
+ * <pre>
+ * module bar;
+ *
+ * container bar {
+ * uses foo:foo;
+ * }
+ * </pre>
+ * and
+ * <pre>
+ * module baz;
+ *
+ * container baz {
+ * uses foo:foo;
+ * }
+ * </pre>
+ * an external module can perform:
+ * <pre>
+ * module xyzzy;
+ *
+ * import bar { prefix bar; }
+ * import baz { prefix baz; }
+ *
+ * grouping something {
+ * // ...
+ * }
+ *
+ * augment /bar:bar/bar:augmentable {
+ * uses something;
+ * }
+ *
+ * augment /baz:baz/baz:augmentable {
+ * uses something;
+ * }
+ * </pre>
+ * The augmentations of {@code bar} and {@code baz} instantiations of {@code grouping foo} have an equivalent
+ * augmentation introduced by {@code xyzzy}. This equivalence is not expressed is generated code, in that it is
+ * not apparent given {@code bar} or {@code baz} there is an augmentation which provides {@code something}.
+ *
+ * <p>
+ * This class provides the static knowledge to ask for the contents of {@code something} given an instance of
+ * {@code augmentable}, without knowing which augmentation introduces it.
+ *
+ * @param <G> Grouping type
+ * @param <T> Augmentable type
+ */
+@Beta
+public final class AugmentationGroupingResolver<G extends DataObject, T extends Augmentable<T>> implements Immutable {
+ private final Class<? extends Augmentation<T>>[] augmentations;
+ private final Class<G> grouping;
+
+ AugmentationGroupingResolver(final Class<G> grouping, final Class<? extends Augmentation<T>>[] augmentations) {
+ this.grouping = requireNonNull(grouping);
+ this.augmentations = requireNonNull(augmentations);
+ }
+
+ public @NonNull Optional<G> findExtension(final T data) {
+ requireNonNull(data);
+
+ for (Class<? extends Augmentation<T>> cls : augmentations) {
+ final Augmentation<T> potential = data.augmentation(cls);
+ if (potential != null) {
+ return Optional.of(grouping.cast(potential));
+ }
+ }
+ return Optional.empty();
+ }
+
+ public static <G extends DataObject, T extends Augmentable<T>> @NonNull Builder<G, T> builder(
+ final Class<G> groupingClass) {
+ return new Builder<>(groupingClass);
+ }
+
+ @SuppressWarnings("unchecked")
+ public static <T extends Augmentable<T>> @NonNull Factory<T> factory(final Class<T> augmentableClass,
+ final Set<Class<? extends Augmentation<T>>> augmentationClasses) {
+ // Defensive copy via .clone() to guard against evil Set implementations
+ final Class<?>[] array = augmentationClasses.toArray(new Class<?>[0]).clone();
+
+ // Defensive check of all array elements
+ for (Class<?> clazz : array) {
+ checkArgument(Augmentation.class.isAssignableFrom(clazz), "Class %s is not an Augmentation", clazz);
+ }
+
+ return new Factory<>((Class<? extends Augmentation<T>>[]) array);
+ }
+
+ public static final class Builder<G extends DataObject, T extends Augmentable<T>>
+ implements org.opendaylight.yangtools.concepts.Builder<AugmentationGroupingResolver<G, T>> {
+ private final Set<Class<? extends Augmentation<T>>> augmentations = new HashSet<>();
+ private final Class<G> grouping;
+
+ Builder(final Class<G> groupingClass) {
+ grouping = requireNonNull(groupingClass);
+ }
+
+ public <X extends Augmentation<T>> @NonNull Builder<G, T> addAugmentationClass(
+ final Class<X> augmentationClass) {
+ checkAssignable(grouping, augmentationClass);
+ augmentations.add(augmentationClass);
+ return this;
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public @NonNull AugmentationGroupingResolver<G, T> build() {
+ return new AugmentationGroupingResolver<>(grouping,
+ (Class<? extends Augmentation<T>>[]) augmentations.toArray(new Class<?>[0]));
+ }
+ }
+
+ public static final class Factory<T extends Augmentable<T>> implements Immutable {
+ private final Class<? extends Augmentation<T>>[] augmentations;
+
+ Factory(final Class<? extends Augmentation<T>>[] augmentations) {
+ this.augmentations = requireNonNull(augmentations);
+ }
+
+ public <G extends DataObject> @NonNull AugmentationGroupingResolver<G, T> createResolver(
+ final Class<G> groupingClass) {
+ for (Class<? extends Augmentation<T>> cls : augmentations) {
+ checkAssignable(groupingClass, cls);
+ }
+
+ return new AugmentationGroupingResolver<>(groupingClass, augmentations);
+ }
+ }
+
+ static void checkAssignable(final Class<?> groupingClass, final Class<?> augmentationClass) {
+ checkArgument(groupingClass.isAssignableFrom(augmentationClass), "%s is not compatible with grouping %s",
+ augmentationClass, groupingClass);
+ }
+}
*
* @param <G> grouping
* @param <T> Augmentable
+ * @deprecated Use {@link AugmentationGroupingResolver} instead.
*/
+@Deprecated
public class GroupingResolver<G, T extends Augmentable<T>> {
Class<G> commonInterface;
Set<Class<? extends Augmentation<T>>> classes;
- public GroupingResolver(Class<G> commonInterface) {
+ public GroupingResolver(final Class<G> commonInterface) {
this.commonInterface = commonInterface;
classes = new HashSet<>();
}
* @param cls equivalent augmentation class
* @return this for chaining
*/
- public <X extends Augmentation<T>> GroupingResolver<G, T> add(Class<X> cls) {
+ public <X extends Augmentation<T>> GroupingResolver<G, T> add(final Class<X> cls) {
Preconditions.checkArgument(commonInterface.isAssignableFrom(cls));
classes.add(cls);
return this;
*
* @param clses set of equivalent augmentation classes
*/
- public void setAugmentations(Set<Class<? extends Augmentation<T>>> clses) {
+ public void setAugmentations(final Set<Class<? extends Augmentation<T>>> clses) {
for (Class<? extends Augmentation<T>> cls : clses) {
Preconditions.checkArgument(commonInterface.isAssignableFrom(cls));
}
* @return shared grouping
*/
@SuppressWarnings("unchecked")
- public Optional<G> getExtension(T data) {
+ public Optional<G> getExtension(final T data) {
for (Class<? extends Augmentation<T>> cls : classes) {
Augmentation<T> potential = data.augmentation(cls);
if (potential != null) {
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfArpOpGrouping> matchGrouping = MatchUtil.ARP_OP_RESOLVER.getExtension(extension);
+ Optional<NxmOfArpOpGrouping> matchGrouping = MatchUtil.ARP_OP_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxArpShaGrouping> matchGrouping = MatchUtil.ARP_SHA_RESOLVER.getExtension(extension);
+ Optional<NxmNxArpShaGrouping> matchGrouping = MatchUtil.ARP_SHA_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfArpSpaGrouping> matchGrouping = MatchUtil.ARP_SPA_RESOLVER.getExtension(extension);
+ Optional<NxmOfArpSpaGrouping> matchGrouping = MatchUtil.ARP_SPA_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxArpThaGrouping> matchGrouping = MatchUtil.ARP_THA_RESOLVER.getExtension(extension);
+ Optional<NxmNxArpThaGrouping> matchGrouping = MatchUtil.ARP_THA_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfArpTpaGrouping> matchGrouping = MatchUtil.ARP_TPA_RESOLVER.getExtension(extension);
+ Optional<NxmOfArpTpaGrouping> matchGrouping = MatchUtil.ARP_TPA_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
*/
@Override
public ExtensionAugment<? extends Augmentation<Extension>> convert(MatchEntry input, MatchPath path) {
- CtMarkCaseValue ctMarkCaseValue = ((CtMarkCaseValue) input.getMatchEntryValue());
+ CtMarkCaseValue ctMarkCaseValue = (CtMarkCaseValue) input.getMatchEntryValue();
NxmNxCtMarkBuilder ctMarkBuilder = new NxmNxCtMarkBuilder();
ctMarkBuilder.setCtMark(ctMarkCaseValue.getCtMarkValues().getCtMark());
ctMarkBuilder.setMask(ctMarkCaseValue.getCtMarkValues().getMask());
*/
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxCtMarkGrouping> matchGrouping = MatchUtil.CT_MARK_RESOLVER.getExtension(extension);
+ Optional<NxmNxCtMarkGrouping> matchGrouping = MatchUtil.CT_MARK_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxCtStateGrouping> matchGrouping = MatchUtil.CT_STATE_RESOLVER.getExtension(extension);
+ Optional<NxmNxCtStateGrouping> matchGrouping = MatchUtil.CT_STATE_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxCtTpDstGrouping> matchGrouping = MatchUtil.CT_TP_DST_RESOLVER.getExtension(extension);
+ Optional<NxmNxCtTpDstGrouping> matchGrouping = MatchUtil.CT_TP_DST_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxCtTpSrcGrouping> matchGrouping = MatchUtil.CT_TP_SRC_RESOLVER.getExtension(extension);
+ Optional<NxmNxCtTpSrcGrouping> matchGrouping = MatchUtil.CT_TP_SRC_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxCtZoneGrouping> matchGrouping = MatchUtil.CT_ZONE_RESOLVER.getExtension(extension);
+ Optional<NxmNxCtZoneGrouping> matchGrouping = MatchUtil.CT_ZONE_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfEthDstGrouping> matchGrouping = MatchUtil.ETH_DST_RESOLVER.getExtension(extension);
+ Optional<NxmOfEthDstGrouping> matchGrouping = MatchUtil.ETH_DST_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfEthSrcGrouping> matchGrouping = MatchUtil.ETH_SRC_RESOLVER.getExtension(extension);
+ Optional<NxmOfEthSrcGrouping> matchGrouping = MatchUtil.ETH_SRC_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfEthTypeGrouping> matchGrouping = MatchUtil.ETH_TYPE_RESOLVER.getExtension(extension);
+ Optional<NxmOfEthTypeGrouping> matchGrouping = MatchUtil.ETH_TYPE_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014, 2017 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableSet;
import com.google.common.primitives.Longs;
import com.google.common.primitives.UnsignedBytes;
-import java.util.HashSet;
import java.util.Iterator;
-import java.util.Set;
-import org.opendaylight.openflowplugin.extension.api.GroupingResolver;
+import org.opendaylight.openflowplugin.extension.api.AugmentationGroupingResolver;
+import org.opendaylight.openflowplugin.extension.api.AugmentationGroupingResolver.Factory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev150225.oxm.container.match.entry.value.ExperimenterIdCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev150225.oxm.container.match.entry.value.ExperimenterIdCaseBuilder;
private static final Splitter SPLITTER = Splitter.on('.');
private static final Joiner JOINER = Joiner.on('.');
- private static final Set<Class<? extends Augmentation<Extension>>> AUGMENTATIONS_OF_EXTENSION = new HashSet<>();
- public static final GroupingResolver<NxmNxRegGrouping, Extension> REG_RESOLVER = new GroupingResolver<>(
- NxmNxRegGrouping.class);
- public static final GroupingResolver<NxmNxTunIdGrouping, Extension> TUN_ID_RESOLVER = new GroupingResolver<>(
- NxmNxTunIdGrouping.class);
- public static final GroupingResolver<NxmNxArpShaGrouping, Extension> ARP_SHA_RESOLVER = new GroupingResolver<>(
- NxmNxArpShaGrouping.class);
- public static final GroupingResolver<NxmNxArpThaGrouping, Extension> ARP_THA_RESOLVER = new GroupingResolver<>(
- NxmNxArpThaGrouping.class);
- public static final GroupingResolver<NxmOfArpOpGrouping, Extension> ARP_OP_RESOLVER = new GroupingResolver<>(
- NxmOfArpOpGrouping.class);
- public static final GroupingResolver<NxmOfArpSpaGrouping, Extension> ARP_SPA_RESOLVER = new GroupingResolver<>(
- NxmOfArpSpaGrouping.class);
- public static final GroupingResolver<NxmOfArpTpaGrouping, Extension> ARP_TPA_RESOLVER = new GroupingResolver<>(
- NxmOfArpTpaGrouping.class);
- public static final GroupingResolver<NxmNxTunIpv4DstGrouping, Extension> TUN_IPV4_DST_RESOLVER =
- new GroupingResolver<>(NxmNxTunIpv4DstGrouping.class);
- public static final GroupingResolver<NxmNxTunIpv4SrcGrouping, Extension> TUN_IPV4_SRC_RESOLVER =
- new GroupingResolver<>(NxmNxTunIpv4SrcGrouping.class);
- public static final GroupingResolver<NxmOfEthDstGrouping, Extension> ETH_DST_RESOLVER = new GroupingResolver<>(
- NxmOfEthDstGrouping.class);
- public static final GroupingResolver<NxmOfEthSrcGrouping, Extension> ETH_SRC_RESOLVER = new GroupingResolver<>(
- NxmOfEthSrcGrouping.class);
- public static final GroupingResolver<NxmOfEthTypeGrouping, Extension> ETH_TYPE_RESOLVER = new GroupingResolver<>(
- NxmOfEthTypeGrouping.class);
- public static final GroupingResolver<NxmNxNsiGrouping, Extension> NSI_RESOLVER = new GroupingResolver<>(
- NxmNxNsiGrouping.class);
- public static final GroupingResolver<NxmNxNspGrouping, Extension> NSP_RESOLVER = new GroupingResolver<>(
- NxmNxNspGrouping.class);
- public static final GroupingResolver<NxmNxNshc1Grouping, Extension> NSC1_RESOLVER = new GroupingResolver<>(
- NxmNxNshc1Grouping.class);
- public static final GroupingResolver<NxmNxNshc2Grouping, Extension> NSC2_RESOLVER = new GroupingResolver<>(
- NxmNxNshc2Grouping.class);
- public static final GroupingResolver<NxmNxNshc3Grouping, Extension> NSC3_RESOLVER = new GroupingResolver<>(
- NxmNxNshc3Grouping.class);
- public static final GroupingResolver<NxmNxNshc4Grouping, Extension> NSC4_RESOLVER = new GroupingResolver<>(
- NxmNxNshc4Grouping.class);
- public static final GroupingResolver<NxmNxNshFlagsGrouping, Extension> NSH_FLAGS_RESOLVER =
- new GroupingResolver<>(NxmNxNshFlagsGrouping.class);
- public static final GroupingResolver<NxmNxNshMdtypeGrouping, Extension> NSH_MDTYPE_RESOLVER =
- new GroupingResolver<>(NxmNxNshMdtypeGrouping.class);
- public static final GroupingResolver<NxmNxNshNpGrouping, Extension> NSH_NP_RESOLVER = new GroupingResolver<>(
- NxmNxNshNpGrouping.class);
- public static final GroupingResolver<NxmNxNshTtlGrouping, Extension> NSH_TTL_RESOLVER =
- new GroupingResolver<>(NxmNxNshTtlGrouping.class);
- public static final GroupingResolver<NxmOfTcpSrcGrouping, Extension> TCP_SRC_RESOLVER = new GroupingResolver<>(
- NxmOfTcpSrcGrouping.class);
- public static final GroupingResolver<NxmOfTcpDstGrouping, Extension> TCP_DST_RESOLVER = new GroupingResolver<>(
- NxmOfTcpDstGrouping.class);
- public static final GroupingResolver<NxmOfUdpSrcGrouping, Extension> UDP_SRC_RESOLVER = new GroupingResolver<>(
- NxmOfUdpSrcGrouping.class);
- public static final GroupingResolver<NxmOfUdpDstGrouping, Extension> UDP_DST_RESOLVER = new GroupingResolver<>(
- NxmOfUdpDstGrouping.class);
- public static final GroupingResolver<NxmNxCtMarkGrouping, Extension> CT_MARK_RESOLVER = new GroupingResolver<>(
- NxmNxCtMarkGrouping.class);
- public static final GroupingResolver<NxmNxCtStateGrouping, Extension> CT_STATE_RESOLVER = new GroupingResolver<>(
- NxmNxCtStateGrouping.class);
- public static final GroupingResolver<NxmNxCtZoneGrouping, Extension> CT_ZONE_RESOLVER = new GroupingResolver<>(
- NxmNxCtZoneGrouping.class);
- public static final GroupingResolver<NxmNxCtTpSrcGrouping, Extension> CT_TP_SRC_RESOLVER = new GroupingResolver<>(
- NxmNxCtTpSrcGrouping.class);
- public static final GroupingResolver<NxmNxCtTpDstGrouping, Extension> CT_TP_DST_RESOLVER = new GroupingResolver<>(
- NxmNxCtTpDstGrouping.class);
- public static final GroupingResolver<NxmNxPktMarkGrouping, Extension> PKT_MARK_RESOLVER = new GroupingResolver<>(
- NxmNxPktMarkGrouping.class);
- public static final GroupingResolver<NxmOfInPortGrouping, Extension> NXM_OF_INPORT_RESOLVER =
- new GroupingResolver<>(NxmOfInPortGrouping.class);
+ public static final AugmentationGroupingResolver<NxmNxRegGrouping, Extension> REG_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxTunIdGrouping, Extension> TUN_ID_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxArpShaGrouping, Extension> ARP_SHA_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxArpThaGrouping, Extension> ARP_THA_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfArpOpGrouping, Extension> ARP_OP_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfArpSpaGrouping, Extension> ARP_SPA_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfArpTpaGrouping, Extension> ARP_TPA_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxTunIpv4DstGrouping, Extension> TUN_IPV4_DST_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxTunIpv4SrcGrouping, Extension> TUN_IPV4_SRC_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfEthDstGrouping, Extension> ETH_DST_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfEthSrcGrouping, Extension> ETH_SRC_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfEthTypeGrouping, Extension> ETH_TYPE_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNsiGrouping, Extension> NSI_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNspGrouping, Extension> NSP_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshc1Grouping, Extension> NSC1_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshc2Grouping, Extension> NSC2_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshc3Grouping, Extension> NSC3_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshc4Grouping, Extension> NSC4_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshFlagsGrouping, Extension> NSH_FLAGS_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshMdtypeGrouping, Extension> NSH_MDTYPE_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshNpGrouping, Extension> NSH_NP_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshTtlGrouping, Extension> NSH_TTL_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfTcpSrcGrouping, Extension> TCP_SRC_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfTcpDstGrouping, Extension> TCP_DST_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfUdpSrcGrouping, Extension> UDP_SRC_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfUdpDstGrouping, Extension> UDP_DST_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxCtMarkGrouping, Extension> CT_MARK_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxCtStateGrouping, Extension> CT_STATE_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxCtZoneGrouping, Extension> CT_ZONE_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxCtTpSrcGrouping, Extension> CT_TP_SRC_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxCtTpDstGrouping, Extension> CT_TP_DST_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxPktMarkGrouping, Extension> PKT_MARK_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfInPortGrouping, Extension> NXM_OF_INPORT_RESOLVER;
static {
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchRpcAddFlow.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchRpcRemoveFlow.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchRpcUpdateFlowOriginal.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchRpcUpdateFlowUpdated.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchNodesNodeTableFlow.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchNotifSwitchFlowRemoved.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchNotifPacketIn.class);
- //augmentationsOfExtension.add(NxAugMatchNotifUpdateFlowStats.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchPacketInMessage.class);
- REG_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- TUN_ID_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ARP_SHA_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ARP_THA_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ARP_OP_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ARP_SPA_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ARP_TPA_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- TUN_IPV4_DST_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- TUN_IPV4_SRC_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ETH_DST_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ETH_SRC_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ETH_TYPE_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSP_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSI_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSC1_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSC2_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSC3_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSC4_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSH_FLAGS_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSH_MDTYPE_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSH_NP_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSH_TTL_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- TCP_SRC_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- TCP_DST_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- UDP_SRC_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- UDP_DST_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- CT_STATE_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- CT_ZONE_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NXM_OF_INPORT_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- CT_MARK_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- CT_TP_SRC_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- CT_TP_DST_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- PKT_MARK_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
+ final Factory<Extension> factory = AugmentationGroupingResolver.factory(Extension.class, ImmutableSet.of(
+ NxAugMatchRpcAddFlow.class,
+ NxAugMatchRpcRemoveFlow.class,
+ NxAugMatchRpcUpdateFlowOriginal.class,
+ NxAugMatchRpcUpdateFlowUpdated.class,
+ NxAugMatchNodesNodeTableFlow.class,
+ NxAugMatchNotifSwitchFlowRemoved.class,
+ NxAugMatchNotifPacketIn.class,
+ // NxAugMatchNotifUpdateFlowStats.class,
+ NxAugMatchPacketInMessage.class));
+
+ REG_RESOLVER = factory.createResolver(NxmNxRegGrouping.class);
+ TUN_ID_RESOLVER = factory.createResolver(NxmNxTunIdGrouping.class);
+ ARP_SHA_RESOLVER = factory.createResolver(NxmNxArpShaGrouping.class);
+ ARP_THA_RESOLVER = factory.createResolver(NxmNxArpThaGrouping.class);
+ ARP_OP_RESOLVER = factory.createResolver(NxmOfArpOpGrouping.class);
+ ARP_SPA_RESOLVER = factory.createResolver(NxmOfArpSpaGrouping.class);
+ ARP_TPA_RESOLVER = factory.createResolver(NxmOfArpTpaGrouping.class);
+ TUN_IPV4_DST_RESOLVER = factory.createResolver(NxmNxTunIpv4DstGrouping.class);
+ TUN_IPV4_SRC_RESOLVER = factory.createResolver(NxmNxTunIpv4SrcGrouping.class);
+ ETH_DST_RESOLVER = factory.createResolver(NxmOfEthDstGrouping.class);
+ ETH_SRC_RESOLVER = factory.createResolver(NxmOfEthSrcGrouping.class);
+ ETH_TYPE_RESOLVER = factory.createResolver(NxmOfEthTypeGrouping.class);
+ NSP_RESOLVER = factory.createResolver(NxmNxNspGrouping.class);
+ NSI_RESOLVER = factory.createResolver(NxmNxNsiGrouping.class);
+ NSC1_RESOLVER = factory.createResolver(NxmNxNshc1Grouping.class);
+ NSC2_RESOLVER = factory.createResolver(NxmNxNshc2Grouping.class);
+ NSC3_RESOLVER = factory.createResolver(NxmNxNshc3Grouping.class);
+ NSC4_RESOLVER = factory.createResolver(NxmNxNshc4Grouping.class);
+ NSH_FLAGS_RESOLVER = factory.createResolver(NxmNxNshFlagsGrouping.class);
+ NSH_MDTYPE_RESOLVER = factory.createResolver(NxmNxNshMdtypeGrouping.class);
+ NSH_NP_RESOLVER = factory.createResolver(NxmNxNshNpGrouping.class);
+ NSH_TTL_RESOLVER = factory.createResolver(NxmNxNshTtlGrouping.class);
+ TCP_SRC_RESOLVER = factory.createResolver(NxmOfTcpSrcGrouping.class);
+ TCP_DST_RESOLVER = factory.createResolver(NxmOfTcpDstGrouping.class);
+ UDP_SRC_RESOLVER = factory.createResolver(NxmOfUdpSrcGrouping.class);
+ UDP_DST_RESOLVER = factory.createResolver(NxmOfUdpDstGrouping.class);
+ CT_STATE_RESOLVER = factory.createResolver(NxmNxCtStateGrouping.class);
+ CT_ZONE_RESOLVER = factory.createResolver(NxmNxCtZoneGrouping.class);
+ NXM_OF_INPORT_RESOLVER = factory.createResolver(NxmOfInPortGrouping.class);
+ CT_MARK_RESOLVER = factory.createResolver(NxmNxCtMarkGrouping.class);
+ CT_TP_SRC_RESOLVER = factory.createResolver(NxmNxCtTpSrcGrouping.class);
+ CT_TP_DST_RESOLVER = factory.createResolver(NxmNxCtTpDstGrouping.class);
+ PKT_MARK_RESOLVER = factory.createResolver(NxmNxPktMarkGrouping.class);
}
private MatchUtil() {
}
- public static MatchEntryBuilder createDefaultMatchEntryBuilder(Class<? extends MatchField> matchField,
- Class<? extends OxmClassBase> oxmClass,
- MatchEntryValue matchEntryValue) {
+ public static MatchEntryBuilder createDefaultMatchEntryBuilder(final Class<? extends MatchField> matchField,
+ final Class<? extends OxmClassBase> oxmClass,
+ final MatchEntryValue matchEntryValue) {
MatchEntryBuilder matchEntryBuilder = new MatchEntryBuilder();
matchEntryBuilder.setHasMask(false);
matchEntryBuilder.setOxmMatchField(matchField);
}
public static <V extends Augmentation<ExperimenterIdCase>> MatchEntryBuilder createExperimenterMatchEntryBuilder(
- Class<? extends MatchField> matchField,
- long experimenterId,
- NxExpMatchEntryValue value) {
+ final Class<? extends MatchField> matchField,
+ final long experimenterId,
+ final NxExpMatchEntryValue value) {
ExperimenterBuilder experimenterBuilder = new ExperimenterBuilder();
experimenterBuilder.setExperimenter(new ExperimenterId(experimenterId));
ExperimenterIdCaseBuilder expCaseBuilder = new ExperimenterIdCaseBuilder();
return createDefaultMatchEntryBuilder(matchField, ExperimenterClass.class, expCaseBuilder.build());
}
- public static Long ipv4ToLong(Ipv4Address ipv4) {
+ public static Long ipv4ToLong(final Ipv4Address ipv4) {
Iterator<String> iterator = SPLITTER.split(ipv4.getValue()).iterator();
byte[] bytes = new byte[8];
for (int i = 0; i < bytes.length; i++) {
return result;
}
- public static Ipv4Address longToIpv4Address(Long value) {
+ public static Ipv4Address longToIpv4Address(final Long value) {
byte[] bytes = Longs.toByteArray(value);
String[] strArray = new String[4];
for (int i = 4; i < bytes.length; i++) {
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshFlagsGrouping> matchGrouping = MatchUtil.NSH_FLAGS_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshFlagsGrouping> matchGrouping = MatchUtil.NSH_FLAGS_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshMdtypeGrouping> matchGrouping = MatchUtil.NSH_MDTYPE_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshMdtypeGrouping> matchGrouping = MatchUtil.NSH_MDTYPE_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshNpGrouping> matchGrouping = MatchUtil.NSH_NP_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshNpGrouping> matchGrouping = MatchUtil.NSH_NP_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshTtlGrouping> matchGrouping = MatchUtil.NSH_TTL_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshTtlGrouping> matchGrouping = MatchUtil.NSH_TTL_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshc1Grouping> matchGrouping = MatchUtil.NSC1_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshc1Grouping> matchGrouping = MatchUtil.NSC1_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshc2Grouping> matchGrouping = MatchUtil.NSC2_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshc2Grouping> matchGrouping = MatchUtil.NSC2_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshc3Grouping> matchGrouping = MatchUtil.NSC3_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshc3Grouping> matchGrouping = MatchUtil.NSC3_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshc4Grouping> matchGrouping = MatchUtil.NSC4_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshc4Grouping> matchGrouping = MatchUtil.NSC4_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNsiGrouping> matchGrouping = MatchUtil.NSI_RESOLVER.getExtension(extension);
+ Optional<NxmNxNsiGrouping> matchGrouping = MatchUtil.NSI_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNspGrouping> matchGrouping = MatchUtil.NSP_RESOLVER.getExtension(extension);
+ Optional<NxmNxNspGrouping> matchGrouping = MatchUtil.NSP_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfInPortGrouping> matchGrouping = MatchUtil.NXM_OF_INPORT_RESOLVER
- .getExtension(extension);
+ Optional<NxmOfInPortGrouping> matchGrouping = MatchUtil.NXM_OF_INPORT_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxPktMarkGrouping> matchGrouping = MatchUtil.PKT_MARK_RESOLVER.getExtension(extension);
+ Optional<NxmNxPktMarkGrouping> matchGrouping = MatchUtil.PKT_MARK_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.codec.match.NiciraMatchCodecs;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxRegGrouping> matchGrouping = MatchUtil.REG_RESOLVER.getExtension(extension);
+ Optional<NxmNxRegGrouping> matchGrouping = MatchUtil.REG_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfTcpDstGrouping> matchGrouping = MatchUtil.TCP_DST_RESOLVER.getExtension(extension);
+ Optional<NxmOfTcpDstGrouping> matchGrouping = MatchUtil.TCP_DST_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfTcpSrcGrouping> matchGrouping = MatchUtil.TCP_SRC_RESOLVER.getExtension(extension);
+ Optional<NxmOfTcpSrcGrouping> matchGrouping = MatchUtil.TCP_SRC_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxTunIpv4DstGrouping> matchGrouping = MatchUtil.TUN_IPV4_DST_RESOLVER.getExtension(extension);
+ Optional<NxmNxTunIpv4DstGrouping> matchGrouping = MatchUtil.TUN_IPV4_DST_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxTunIpv4SrcGrouping> matchGrouping = MatchUtil.TUN_IPV4_SRC_RESOLVER.getExtension(extension);
+ Optional<NxmNxTunIpv4SrcGrouping> matchGrouping = MatchUtil.TUN_IPV4_SRC_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
import java.math.BigInteger;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxTunIdGrouping> matchGrouping = MatchUtil.TUN_ID_RESOLVER.getExtension(extension);
+ Optional<NxmNxTunIdGrouping> matchGrouping = MatchUtil.TUN_ID_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfUdpDstGrouping> matchGrouping = MatchUtil.UDP_DST_RESOLVER.getExtension(extension);
+ Optional<NxmOfUdpDstGrouping> matchGrouping = MatchUtil.UDP_DST_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* 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.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfUdpSrcGrouping> matchGrouping = MatchUtil.UDP_SRC_RESOLVER.getExtension(extension);
+ Optional<NxmOfUdpSrcGrouping> matchGrouping = MatchUtil.UDP_SRC_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>3.0.1</version>
+ <version>3.0.3</version>
<scope>import</scope>
<type>pom</type>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>3.0.1</version>
+ <version>3.0.3</version>
<scope>import</scope>
<type>pom</type>
</dependency>
<type>xml</type>
<classifier>features</classifier>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.infrautils</groupId>
+ <artifactId>odl-infrautils-diagstatus</artifactId>
+ <version>1.5.0-SNAPSHOT</version>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </dependency>
<!-- bundle dependencies -->
<dependency>
<groupId>${project.groupId}</groupId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>4.0.2</version>
+ <version>4.0.5</version>
<relativePath/>
</parent>
<artifactId>slf4j-log4j12</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.infrautils</groupId>
+ <artifactId>infrautils-util</artifactId>
+ <version>${infrautils.version}</version>
+ </dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.infrautils</groupId>
+ <artifactId>diagstatus-api</artifactId>
+ <version>${infrautils.version}</version>
+ </dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
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.ThreadConfiguration;
import org.opendaylight.openflowjava.protocol.api.connection.TlsConfiguration;
@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));
+ return new SwitchConnectionProviderImpl(new ConnectionConfigurationImpl(config), diagStatusService);
}
private static InetAddress getInetAddress(final IpAddress address) throws UnknownHostException {
package org.opendaylight.openflowjava.protocol.impl.core;
+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.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.SwitchConnectionHandler;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
*/
public class SwitchConnectionProviderImpl implements SwitchConnectionProvider, ConnectionInitializer {
- private static final Logger LOG = LoggerFactory
- .getLogger(SwitchConnectionProviderImpl.class);
+ private static final Logger LOG = LoggerFactory.getLogger(SwitchConnectionProviderImpl.class);
+ private static final String THREAD_NAME_PREFIX = "OFP-SwitchConnectionProvider-Udp/TcpHandler";
+ private static final String OPENFLOW_JAVA_SERVICE_NAME_PREFIX = "OPENFLOW_SERVER";
+
private SwitchConnectionHandler switchConnectionHandler;
private ServerFacade serverFacade;
private final ConnectionConfiguration connConfig;
private final SerializerRegistry serializerRegistry;
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;
- public SwitchConnectionProviderImpl(ConnectionConfiguration connConfig) {
+ public SwitchConnectionProviderImpl(
+ @Nullable ConnectionConfiguration connConfig, DiagStatusService diagStatusService) {
this.connConfig = connConfig;
+ String connectionSuffix = createConnectionSuffix(connConfig);
+
+ this.diagStatusService = diagStatusService;
+ this.diagStatusIdentifier = OPENFLOW_JAVA_SERVICE_NAME_PREFIX + connectionSuffix;
+ diagStatusService.register(diagStatusIdentifier);
+
+ this.threadName = THREAD_NAME_PREFIX + connectionSuffix;
+ this.listeningExecutorService = Executors.newListeningSingleThreadExecutor(threadName, LOG);
+
serializerRegistry = new SerializerRegistryImpl();
if (connConfig != null) {
serializerRegistry.setGroupAddModConfig(connConfig.isGroupAddModEnabled());
deserializationFactory = new DeserializationFactory(deserializerRegistry);
}
+ // ID based, on configuration, used for diagstatus serviceIdentifier (ServiceDescriptor moduleServiceName)
+ private static String createConnectionSuffix(@Nullable ConnectionConfiguration config) {
+ if (config != null && config.getAddress() != null) {
+ return "-" + config.getAddress().toString() + "_" + config.getPort();
+ } else if (config != null) {
+ return "_" + config.getPort();
+ } else {
+ return "-null-config";
+ }
+ }
+
@Override
public void setSwitchConnectionHandler(final SwitchConnectionHandler switchConnectionHandler) {
LOG.debug("setSwitchConnectionHandler");
LOG.warn("Can not shutdown - not configured or started");
throw new IllegalStateException("SwitchConnectionProvider is not started or not configured.");
}
- return serverFacade.shutdown();
+ ListenableFuture<Boolean> serverFacadeShutdownFuture = serverFacade.shutdown();
+ Executors.shutdownAndAwaitTermination(listeningExecutorService);
+ return serverFacadeShutdownFuture;
}
@Override
if (switchConnectionHandler == null) {
throw new IllegalStateException("SwitchConnectionHandler is not set");
}
- new Thread(serverFacade).start();
+ Futures.addCallback(listeningExecutorService.submit(serverFacade), new FutureCallback<Object>() {
+
+ @Override
+ public void onFailure(Throwable throwable) {
+ diagStatusService.report(new ServiceDescriptor(diagStatusIdentifier, throwable));
+ }
+
+ @Override
+ public void onSuccess(@Nullable Object nullResult) {
+ diagStatusService.report(new ServiceDescriptor(
+ diagStatusIdentifier, ServiceState.ERROR, threadName + " terminated"));
+ }
+ } , MoreExecutors.directExecutor());
result = serverFacade.getIsOnlineFuture();
} catch (RuntimeException e) {
final SettableFuture<Boolean> exResult = SettableFuture.create();
private ServerFacade createAndConfigureServer() {
LOG.debug("Configuring ..");
- ServerFacade server = null;
+ ServerFacade server;
final ChannelInitializerFactory factory = new ChannelInitializerFactory();
factory.setSwitchConnectionHandler(switchConnectionHandler);
factory.setSwitchIdleTimeout(connConfig.getSwitchIdleTimeout());
boolean isEpollEnabled = Epoll.isAvailable();
if (TransportProtocol.TCP.equals(transportProtocol) || TransportProtocol.TLS.equals(transportProtocol)) {
- server = new TcpHandler(connConfig.getAddress(), connConfig.getPort());
+ server = new TcpHandler(connConfig.getAddress(), connConfig.getPort(), () -> diagStatusService
+ .report(new ServiceDescriptor(diagStatusIdentifier, ServiceState.OPERATIONAL)));
final TcpChannelInitializer channelInitializer = factory.createPublishingChannelInitializer();
((TcpHandler) server).setChannelInitializer(channelInitializer);
((TcpHandler) server).initiateEventLoopGroups(connConfig.getThreadConfiguration(), isEpollEnabled);
connectionInitializer.setChannelInitializer(channelInitializer);
connectionInitializer.run();
} else if (TransportProtocol.UDP.equals(transportProtocol)) {
- server = new UdpHandler(connConfig.getAddress(), connConfig.getPort());
+ server = new UdpHandler(connConfig.getAddress(), connConfig.getPort(), () -> diagStatusService
+ .report(new ServiceDescriptor(diagStatusIdentifier, ServiceState.OPERATIONAL)));
((UdpHandler) server).initiateEventLoopGroups(connConfig.getThreadConfiguration(), isEpollEnabled);
((UdpHandler) server).setChannelInitializer(factory.createUdpChannelInitializer());
} else {
LOG.debug("Calling OF plugin: {}", getSwitchConnectionHandler());
getSwitchConnectionHandler().onSwitchConnected(connectionFacade);
connectionFacade.checkListeners();
- ch.pipeline().addLast(PipelineHandlers.IDLE_HANDLER.name(),
- new IdleHandler(getSwitchIdleTimeout(), TimeUnit.MILLISECONDS));
boolean tlsPresent = false;
// If this channel is configured to support SSL it will only support SSL
ch.pipeline().addLast(PipelineHandlers.OF_ENCODER.name(), ofEncoder);
ch.pipeline().addLast(PipelineHandlers.DELEGATING_INBOUND_HANDLER.name(),
new DelegatingInboundHandler(connectionFacade));
+ ch.pipeline().addLast(PipelineHandlers.IDLE_HANDLER.name(),
+ new IdleHandler(getSwitchIdleTimeout(), TimeUnit.MILLISECONDS));
if (!tlsPresent) {
connectionFacade.fireConnectionReadyNotification();
}
private int port;
private String address;
private final InetAddress startupAddress;
+ private final Runnable readyRunnable;
private EventLoopGroup workerGroup;
private EventLoopGroup bossGroup;
private final SettableFuture<Boolean> isOnlineFuture;
*
* @param port listening port of TCPHandler server
*/
- public TcpHandler(final int port) {
- this(null, port);
+ public TcpHandler(final int port, Runnable readyRunnable) {
+ this(null, port, readyRunnable);
}
/**
* @param address listening address of TCPHandler server
* @param port listening port of TCPHandler server
*/
- public TcpHandler(final InetAddress address, final int port) {
+ public TcpHandler(final InetAddress address, final int port, Runnable readyRunnable) {
this.port = port;
this.startupAddress = address;
isOnlineFuture = SettableFuture.create();
+ this.readyRunnable = readyRunnable;
}
/**
LOG.debug("address from tcphandler: {}", address);
isOnlineFuture.set(true);
LOG.info("Switch listener started and ready to accept incoming tcp/tls connections on port: {}", port);
+
+ readyRunnable.run();
+
+ // This waits until this channel is closed, and rethrows the cause of the failure if this future failed.
f.channel().closeFuture().sync();
} catch (InterruptedException e) {
LOG.error("Interrupted while waiting for port {} shutdown", port, e);
*/
public final class UdpHandler implements ServerFacade {
- private static final Logger LOG = LoggerFactory
- .getLogger(UdpHandler.class);
+ private static final Logger LOG = LoggerFactory.getLogger(UdpHandler.class);
+
private int port;
private EventLoopGroup group;
private final InetAddress startupAddress;
+ private final Runnable readyRunnable;
private final SettableFuture<Boolean> isOnlineFuture;
private UdpChannelInitializer channelInitializer;
private ThreadConfiguration threadConfig;
*
* @param port listening port of UdpHandler server
*/
- public UdpHandler(final int port) {
- this(null, port);
+ public UdpHandler(final int port, Runnable readyRunnable) {
+ this(null, port, readyRunnable);
}
/**
* @param address listening address of UdpHandler server
* @param port listening port of UdpHandler server
*/
- public UdpHandler(final InetAddress address, final int port) {
+ public UdpHandler(final InetAddress address, final int port, Runnable readyRunnable) {
this.port = port;
this.startupAddress = address;
isOnlineFuture = SettableFuture.create();
+ this.readyRunnable = readyRunnable;
}
@Override
LOG.debug("Address from udpHandler: {}", address);
isOnlineFuture.set(true);
LOG.info("Switch listener started and ready to accept incoming udp connections on port: {}", port);
+ readyRunnable.run();
+ // This waits until this channel is closed, and rethrows the cause of the failure if this future failed.
f.channel().closeFuture().sync();
} catch (InterruptedException e) {
LOG.error("Interrupted while waiting for port {} shutdown", port, e);
responseCache = CacheBuilder.newBuilder().concurrencyLevel(1)
.expireAfterWrite(RPC_RESPONSE_EXPIRATION, TimeUnit.MINUTES).removalListener(REMOVAL_LISTENER).build();
- LOG.info("The channel outbound queue size:{}", channelOutboundQueueSize);
+ LOG.debug("The channel outbound queue size:{}", channelOutboundQueueSize);
this.output = new ChannelOutboundQueue(channel, channelOutboundQueueSize, address);
channel.pipeline().addLast(output);
}
*/
@Test
public void testRunWithNullAddress() throws IOException, InterruptedException, ExecutionException {
-
- tcpHandler = new TcpHandler(null, 0);
+ tcpHandler = new TcpHandler(null, 0, () -> { });
tcpHandler.setChannelInitializer(mockChannelInitializer);
assertEquals("failed to start server", true, startupServer(false)) ;
*/
@Test
public void testRunWithNullAddressOnEpoll() throws IOException, InterruptedException, ExecutionException {
-
- tcpHandler = new TcpHandler(null, 0);
+ tcpHandler = new TcpHandler(null, 0, () -> { });
tcpHandler.setChannelInitializer(mockChannelInitializer);
//Use Epoll native transport
*/
@Test
public void testRunWithAddress() throws IOException, InterruptedException, ExecutionException {
-
- tcpHandler = new TcpHandler(serverAddress, 0);
+ tcpHandler = new TcpHandler(serverAddress, 0, () -> { });
tcpHandler.setChannelInitializer(mockChannelInitializer);
assertEquals("failed to start server", true, startupServer(false)) ;
*/
@Test
public void testRunWithAddressOnEpoll() throws IOException, InterruptedException, ExecutionException {
-
- tcpHandler = new TcpHandler(serverAddress, 0);
+ tcpHandler = new TcpHandler(serverAddress, 0, () -> { });
tcpHandler.setChannelInitializer(mockChannelInitializer);
//Use Epoll native transport
@Test
public void testRunWithEncryption() throws InterruptedException, IOException, ExecutionException {
int serverPort = 28001;
- tcpHandler = new TcpHandler(serverAddress, serverPort);
+ tcpHandler = new TcpHandler(serverAddress, serverPort, () -> { });
tcpHandler.setChannelInitializer(mockChannelInitializer);
assertEquals("failed to start server", true, startupServer(false));
@Test
public void testRunWithEncryptionOnEpoll() throws InterruptedException, IOException, ExecutionException {
int serverPort = 28001;
- tcpHandler = new TcpHandler(serverAddress, serverPort);
+ tcpHandler = new TcpHandler(serverAddress, serverPort, () -> { });
tcpHandler.setChannelInitializer(mockChannelInitializer);
//Use Epoll native transport
try {
firstBinder.bind(new InetSocketAddress(serverAddress, serverPort));
- tcpHandler = new TcpHandler(serverAddress, serverPort);
+ tcpHandler = new TcpHandler(serverAddress, serverPort, () -> { });
tcpHandler.setChannelInitializer(mockChannelInitializer);
tcpHandler.initiateEventLoopGroups(null, false);
tcpHandler.run();
try {
firstBinder.bind(new InetSocketAddress(serverAddress, serverPort));
- tcpHandler = new TcpHandler(serverAddress, serverPort);
+ tcpHandler = new TcpHandler(serverAddress, serverPort, () -> { });
tcpHandler.setChannelInitializer(mockChannelInitializer);
//Use Epoll native transport
tcpHandler.initiateEventLoopGroups(null, true);
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.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;
if (protocol != null) {
createConfig(protocol);
}
- provider = new SwitchConnectionProviderImpl(config);
+ provider = new SwitchConnectionProviderImpl(config, diagStatusService);
}
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.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;
private static final int SWITCH_IDLE_TIMEOUT = 2000;
private static final int WAIT_TIMEOUT = 2000;
if (protocol != null) {
createConfig(protocol);
}
- provider = new SwitchConnectionProviderImpl(config);
+ provider = new SwitchConnectionProviderImpl(config, diagStatusService);
}
private void createConfig(final TransportProtocol protocol) throws UnknownHostException {
* Tests provider startup - without configuration and {@link SwitchConnectionHandler}.
*/
@Test
- public void testStartup1() {
- provider = new SwitchConnectionProviderImpl(config);
+ public void testStartup1() throws UnknownHostException {
+ startUp(null);
final ListenableFuture<Boolean> future = provider.startup();
try {
future.get(WAIT_TIMEOUT, TimeUnit.MILLISECONDS);
*/
@Test
public void testWithEmptyAddress() throws Exception {
- udpHandler = new UdpHandler(null, 0);
+ udpHandler = new UdpHandler(null, 0, () -> { });
udpHandler.setChannelInitializer(udpChannelInitializerMock);
Assert.assertTrue("Wrong - start server", startupServer(false));
try {
*/
@Test
public void testWithEmptyAddressOnEpoll() throws Exception {
- udpHandler = new UdpHandler(null, 0);
+ udpHandler = new UdpHandler(null, 0, () -> { });
udpHandler.setChannelInitializer(udpChannelInitializerMock);
Assert.assertTrue("Wrong - start server", startupServer(true));
try {
@Test
public void testWithAddressAndPort() throws Exception {
int port = 9874;
- udpHandler = new UdpHandler(InetAddress.getLocalHost(), port);
+ udpHandler = new UdpHandler(InetAddress.getLocalHost(), port, () -> { });
udpHandler.setChannelInitializer(udpChannelInitializerMock);
Assert.assertTrue("Wrong - start server", startupServer(false));
try {
@Test
public void testWithAddressAndPortOnEpoll() throws Exception {
int port = 9874;
- udpHandler = new UdpHandler(InetAddress.getLocalHost(), port);
+ udpHandler = new UdpHandler(InetAddress.getLocalHost(), port, () -> { });
udpHandler.setChannelInitializer(udpChannelInitializerMock);
Assert.assertTrue("Wrong - start server", startupServer(true));
try {
import java.util.concurrent.TimeoutException;
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.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);
+ switchConnectionProvider = new SwitchConnectionProviderImpl(connConfig, Mockito.mock(DiagStatusService.class));
switchConnectionProvider.setSwitchConnectionHandler(mockPlugin);
switchConnectionProvider.startup().get(CONNECTION_TIMEOUT, TimeUnit.MILLISECONDS);
if (protocol.equals(TransportProtocol.TCP) || protocol.equals(TransportProtocol.TLS)) {
<plugin>
<groupId>org.apache.aries.blueprint</groupId>
<artifactId>blueprint-maven-plugin</artifactId>
+ <configuration>
+ <scanPaths>
+ <scanPath>org.opendaylight.openflowplugin.impl</scanPath>
+ </scanPaths>
+ </configuration>
</plugin>
<plugin>
<groupId>org.apache.felix</groupId>
*/
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);
- }
- }
- }
}
@Override
public void onDisconnectEvent(final DisconnectEvent notification) {
- LOG.debug("ConnectionEvent: Connection closed by device, Device:{}, NodeId:{}",
+ LOG.info("ConnectionEvent: Connection closed by device, Device:{}, NodeId:{}",
connectionContext.getConnectionAdapter().getRemoteAddress(), connectionContext.getSafeNodeIdForLOG());
connectionContext.onConnectionClosed();
}
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
</dependency>
- <dependency>
- <groupId>org.apache.commons</groupId>
- <artifactId>commons-lang3</artifactId>
- </dependency>
<dependency>
<groupId>junit</groupId>
-/**
+/*
* Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
package org.opendaylight.openflowplugin.openflow.md.util;
import com.google.common.base.Splitter;
+import com.google.common.base.Strings;
import java.math.BigInteger;
import java.util.List;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.apache.commons.lang3.StringUtils;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
* @return string of size 16, padded with '0'
*/
public static String bigIntegerToPaddedHex(final BigInteger dataPathId) {
- return StringUtils.leftPad(dataPathId.toString(16), 16, "0");
+ return Strings.padStart(dataPathId.toString(16), 16, '0');
}
public static BigInteger extractDatapathId(final NodeRef ref) {
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>3.0.1</version>
+ <version>3.0.3</version>
<relativePath/>
</parent>
</configuration>
</plugin>
<plugin>
- <groupId>org.codehaus.mojo</groupId>
- <artifactId>findbugs-maven-plugin</artifactId>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-maven-plugin</artifactId>
<configuration>
<failOnError>true</failOnError>
</configuration>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-pmd-plugin</artifactId>
- <version>3.0.1</version>
+ <version>3.0.3</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
</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>
<artifactId>maven-bundle-plugin</artifactId>
<extensions>true</extensions>
</plugin>
+ <plugin>
+ <groupId>org.apache.aries.blueprint</groupId>
+ <artifactId>blueprint-maven-plugin</artifactId>
+ </plugin>
</plugins>
</build>
</project>
package org.opendaylight.openflowplugin.test;
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+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.sal.binding.api.NotificationProviderService;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Singleton
public class OpenflowpluginTestActivator implements AutoCloseable {
private static final Logger LOG = LoggerFactory
.getLogger(OpenflowpluginTestActivator.class);
public static final String NODE_ID = "foo:node:1";
- public OpenflowpluginTestActivator(DataBroker dataBroker, NotificationProviderService notificationService,
- BundleContext ctx) {
+ public OpenflowpluginTestActivator(@Reference DataBroker dataBroker,
+ @Reference NotificationProviderService notificationService, BundleContext ctx) {
provider = new OpenflowpluginTestServiceProvider(dataBroker, notificationService);
OpenflowpluginTestCommandProvider openflowpluginTestCommandProvider = new OpenflowpluginTestCommandProvider(
dataBroker, notificationService, ctx);
this.groupCmdProvider = openflowPluginBulkGroupTransactionProvider;
}
+ @PostConstruct
public void init() {
provider.register(rpcRegistry);
}
@Override
+ @PreDestroy
@SuppressWarnings("checkstyle:IllegalCatch")
public void close() {
try {
+++ /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"/>
-
- <bean id="activator" class="org.opendaylight.openflowplugin.test.OpenflowpluginTestActivator"
- init-method="init" destroy-method="close">
- <argument ref="dataBroker"/>
- <argument ref="notificationService"/>
- <argument ref="blueprintBundleContext"/>
- </bean>
-</blueprint>
Code Review / openflowplugin.git / commitdiff