maven-eclipse.xml\r
.DS_Store\r
.checkstyle\r
+.fbExcludeFilterFile\r
import java.util.HashSet;
import java.util.List;
import java.util.Set;
+import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.address.tracker.config.rev160621.AddressTrackerConfig;
addressObservationWriter.setTimestampUpdateInterval(timestampUpdateInterval);
Set<String> packetTypes = processObserveAddressesFrom(observerAddressesFrom);
- if (packetTypes == null || packetTypes.isEmpty()) { // set default to
- // arp
+ if (packetTypes.isEmpty()) { // set default to arp
packetTypes = new HashSet<>();
packetTypes.add(ARP_PACKET_TYPE);
}
LOG.info("AddressTracker torn down.", this);
}
+ @Nonnull
private Set<String> processObserveAddressesFrom(String observeAddressesFrom) {
Set<String> packetTypes = new HashSet<>();
if (observeAddressesFrom == null || observeAddressesFrom.isEmpty()) {
return packetTypes;
}
String[] observeAddressFromSplit = observeAddressesFrom.split(",");
- if (observeAddressFromSplit == null || observeAddressFromSplit.length == 0) {
+ if (observeAddressFromSplit.length == 0) {
packetTypes.add(ARP_PACKET_TYPE);
return packetTypes;
}
package org.opendaylight.l2switch.arphandler.core;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.JdkFutureAdapters;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.List;
import org.opendaylight.l2switch.arphandler.inventory.InventoryReader;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInputBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
.setEgress(egress) //
.setIngress(ingress) //
.build();
- packetProcessingService.transmitPacket(input);
+
+ Futures.addCallback(JdkFutureAdapters.listenInPoolThread(packetProcessingService.transmitPacket(input)),
+ new FutureCallback<RpcResult<Void>>() {
+ @Override
+ public void onSuccess(RpcResult<Void> result) {
+ LOG.debug("transmitPacket was successful");
+ }
+
+ @Override
+ public void onFailure(Throwable failure) {
+ LOG.debug("transmitPacket for {} failed", input, failure);
+ }
+ }, MoreExecutors.directExecutor());
}
private void refreshInventoryReader() {
}
if (!nodeIds.isEmpty()) {
- initialFlowExecutor.submit(new InitialFlowWriterProcessor(nodeIds));
+ initialFlowExecutor.execute(new InitialFlowWriterProcessor(nodeIds));
}
}
*/
package org.opendaylight.l2switch.arphandler.core;
-import static org.mockito.Mockito.any;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.opendaylight.l2switch.arphandler.inventory.InventoryReader;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
public class PacketDispatcherTest {
- @MockitoAnnotations.Mock
+ @Mock
private PacketProcessingService packetProcessingService;
- @MockitoAnnotations.Mock
+ @Mock
private InventoryReader inventoryReader;
private PacketDispatcher packetDispatcher;
packetDispatcher = new PacketDispatcher();
packetDispatcher.setPacketProcessingService(packetProcessingService);
packetDispatcher.setInventoryReader(inventoryReader);
+
+ doReturn(RpcResultBuilder.success().buildFuture()).when(packetProcessingService).transmitPacket(any());
}
@Test
@Test
public void testFloodPacket() throws Exception {
- List<NodeConnectorRef> nodeConnectors = new ArrayList<NodeConnectorRef>();
+ List<NodeConnectorRef> nodeConnectors = new ArrayList<>();
InstanceIdentifier<NodeConnector> ncInsId1 = InstanceIdentifier.builder(Nodes.class).child(Node.class)
.child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId("1"))).build();
InstanceIdentifier<NodeConnector> ncInsId2 = InstanceIdentifier.builder(Nodes.class).child(Node.class)
when(inventoryReader.getControllerSwitchConnectors()).thenReturn(controllerSwitchConnectors);
when(inventoryReader.getNodeConnector(any(InstanceIdentifier.class), any(MacAddress.class))).thenReturn(null);
- List<NodeConnectorRef> nodeConnectors = new ArrayList<NodeConnectorRef>();
+ List<NodeConnectorRef> nodeConnectors = new ArrayList<>();
InstanceIdentifier<NodeConnector> ncInsId2 = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(new NodeId("2")))
.child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId("2"))).build();
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
+import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
private final ConcurrentClusterAwareHostHashMap hosts;
private final ConcurrentClusterAwareLinkHashMap links;
private final OperationProcessor opProcessor;
+ private final Thread processorThread;
private ListenerRegistration<DataTreeChangeListener> addrsNodeListenerRegistration;
private ListenerRegistration<DataTreeChangeListener> hostNodeListenerRegistration;
private ListenerRegistration<DataTreeChangeListener> linkNodeListenerRegistration;
this.hostPurgeAge = config.getHostPurgeAge();
this.hostPurgeInterval = config.getHostPurgeInterval();
this.opProcessor = new OperationProcessor(dataService);
- Thread processorThread = new Thread(opProcessor);
- processorThread.start();
+ processorThread = new Thread(opProcessor);
final String maybeTopologyId = config.getTopologyId();
if (maybeTopologyId == null || maybeTopologyId.isEmpty()) {
this.topologyId = TOPOLOGY_NAME;
@SuppressWarnings("unchecked")
public void init() {
+ processorThread.start();
+
InstanceIdentifier<Addresses> addrCapableNodeConnectors = //
InstanceIdentifier.builder(Nodes.class) //
.child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class)
for (Host h : hosts.values()) {
final HostNode hn = h.getHostNode().getAugmentation(HostNode.class);
if (hn == null) {
- LOG.warn("Encountered non-host node {} in hosts during purge", hn);
+ LOG.warn("Encountered non-host node {} in hosts during purge", h);
} else if (hn.getAddresses() != null) {
boolean purgeHosts = false;
// if the node is a host and has addresses, check to see if it's been seen recently
*
* @param host reference to Host node
*/
- private int removeHosts(final Host host, int numHostsPurged) {
+ private int removeHosts(@Nonnull final Host host, int numHostsPurged) {
// remove associated links with the host before removing hosts
removeAssociatedLinksFromHosts(host);
// purge hosts from local & MD-SAL database
*
* @param host reference to Host node
*/
- private void removeAssociatedLinksFromHosts(final Host host) {
- if (host != null) {
- if (host.getId() != null) {
- List<Link> linksToRemove = new ArrayList<>();
- for (Link link: links.values()) {
- if (link.toString().contains(host.getId().getValue())) {
- linksToRemove.add(link);
- }
+ private void removeAssociatedLinksFromHosts(@Nonnull final Host host) {
+ if (host.getId() != null) {
+ List<Link> linksToRemove = new ArrayList<>();
+ for (Link link: links.values()) {
+ if (link.toString().contains(host.getId().getValue())) {
+ linksToRemove.add(link);
}
- links.removeAll(linksToRemove);
- } else {
- LOG.warn("Encountered host with no id , Unexpected host id {}. ", host);
}
+ links.removeAll(linksToRemove);
} else {
- LOG.warn("Encountered Host with no value, Unexpected host {}. ", host);
+ LOG.warn("Encountered host with no id , Unexpected host id {}. ", host);
}
}
public void close() {
+ processorThread.interrupt();
this.addrsNodeListenerRegistration.close();
this.hostNodeListenerRegistration.close();
this.linkNodeListenerRegistration.close();
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.atomic.AtomicReference;
import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
private static final Logger LOG = LoggerFactory.getLogger(OperationProcessor.class);
private final DataBroker dataBroker;
private final BlockingQueue<HostTrackerOperation> queue;
- private BindingTransactionChain transactionChain;
+ private final AtomicReference<BindingTransactionChain> transactionChain = new AtomicReference<>();
OperationProcessor(final DataBroker dataBroker) {
this.dataBroker = Preconditions.checkNotNull(dataBroker);
this.queue = new LinkedBlockingQueue<>(QUEUE_DEPTH);
- this.transactionChain = dataBroker.createTransactionChain(this);
+ this.transactionChain.set(dataBroker.createTransactionChain(this));
}
@Override
while (!done) {
try {
HostTrackerOperation op = queue.take();
- ReadWriteTransaction tx = transactionChain.newReadWriteTransaction();
+ final BindingTransactionChain txChain = transactionChain.get();
+ if (txChain == null) {
+ break;
+ }
+
+ ReadWriteTransaction tx = txChain.newReadWriteTransaction();
int ops = 0;
while (op != null && ops < OPS_PER_CHAIN) {
}
@Override
- public void close() throws Exception {
- if (transactionChain != null) {
- transactionChain.close();
+ public void close() {
+ final BindingTransactionChain txChain = transactionChain.getAndSet(null);
+ if (txChain != null) {
+ txChain.close();
}
}
private void chainFailure() {
try {
- transactionChain.close();
- transactionChain = dataBroker.createTransactionChain(this);
+ final BindingTransactionChain prevChain = transactionChain.getAndSet(
+ dataBroker.createTransactionChain(this));
+ if (prevChain != null) {
+ prevChain.close();
+ }
clearQueue();
} catch (IllegalStateException e) {
LOG.warn(e.getLocalizedMessage());
}
if (!nodeIds.isEmpty()) {
- initialFlowExecutor.submit(new InitialFlowWriterProcessor(nodeIds));
+ initialFlowExecutor.execute(new InitialFlowWriterProcessor(nodeIds));
}
}
}
if (!nodeIds.isEmpty()) {
- initialFlowExecutor.submit(new InitialFlowWriterProcessor(nodeIds));
+ initialFlowExecutor.execute(new InitialFlowWriterProcessor(nodeIds));
}
}
* necessary and publishes corresponding event on successful decoding.
*/
public void decodeAndPublish(final C consumedPacketNotification) {
- decodeAndPublishExecutor.submit(() -> {
+ decodeAndPublishExecutor.execute(() -> {
P packetNotification = null;
if (consumedPacketNotification != null && canDecode(consumedPacketNotification)) {
packetNotification = decode(consumedPacketNotification);
/**
* Decodes the payload in given Packet further and returns a extension of
* Packet. e.g. ARP, IPV4, LLDP etc.
- *
- * @return
*/
public abstract P decode(C consumedPacketNotification);
package org.opendaylight.l2switch.packethandler.decoders.utils;
import java.util.Arrays;
+import javax.annotation.Nonnull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
int startOffset = data.length * NetUtils.NUM_BITS_IN_A_BYTE - numBits;
byte[] bits = null;
try {
- bits = BitBufferHelper.getBits(data, startOffset, numBits);
+ bits = getBits(data, startOffset, numBits);
} catch (BufferException e) {
- LOG.error("", e);
+ LOG.error("getBits failed", e);
+ return 0;
}
return (short) toNumber(bits, numBits);
}
try {
bits = BitBufferHelper.getBits(data, startOffset, numBits);
} catch (BufferException e) {
- LOG.error("", e);
+ LOG.error("getBits failed", e);
+ return 0;
}
return (int) toNumber(bits, numBits);
}
try {
bits = BitBufferHelper.getBits(data, startOffset, numBits);
} catch (BufferException e) {
- LOG.error("", e);
+ LOG.error("getBits failed", e);
+ return 0;
}
return toNumber(bits, numBits);
}
* @param numBits the number of bits
* @return numerical value of byte array passed
*/
- public static long toNumber(byte[] array, int numBits) {
+ public static long toNumber(@Nonnull byte[] array, int numBits) {
int length = numBits / NetUtils.NUM_BITS_IN_A_BYTE;
int bitsRest = numBits % NetUtils.NUM_BITS_IN_A_BYTE;
int startOffset = array.length - length;
* integer representing the length of the prefix network mask
* @param isV6
* boolean representing the IP version of the returned address
- * @return
*/
public static InetAddress getInetNetworkMask(int prefixMaskLength, boolean isV6) {
if (prefixMaskLength < 0 || !isV6 && prefixMaskLength > 32 || isV6 && prefixMaskLength > 128) {
return false;
}
if (values.length >= 2) {
- int prefix = Integer.valueOf(values[1]);
+ int prefix = Integer.parseInt(values[1]);
if (prefix < 0 || prefix > 32) {
return false;
}
}
if (values.length >= 2) {
- int prefix = Integer.valueOf(values[1]);
+ int prefix = Integer.parseInt(values[1]);
if (prefix < 0 || prefix > 128) {
return false;
}
<configuration>
<propertyExpansion>checkstyle.violationSeverity=error</propertyExpansion>
</configuration>
-
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>findbugs-maven-plugin</artifactId>
+ <configuration>
+ <failOnError>true</failOnError>
+ </configuration>
</plugin>
</plugins>
</build>