<groupId>org.opendaylight.openflowplugin.model</groupId>
<artifactId>model-flow-base</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.infrautils</groupId>
+ <artifactId>infrautils-util</artifactId>
+ <version>${infrautils.version}</version>
+ </dependency>
<!-- Test dependencies -->
<dependency>
.append(number & 0xFF).append("/32").toString();
}
- public static Match getMatch(final Integer sourceIp) {
+ public static Match getMatch(final int sourceIp) {
Ipv4Match ipv4Match = new Ipv4MatchBuilder().setIpv4Source(new Ipv4Prefix(ipIntToStr(sourceIp))).build();
MatchBuilder matchBuilder = new MatchBuilder();
matchBuilder.setLayer3Match(ipv4Match);
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
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;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowTableRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
AddFlowInput addFlowInput = builder.build();
LOG.debug("RPC invocation for adding flow-id {} with input {}", flowId, addFlowInput.toString());
- flowService.addFlow(addFlowInput);
+ final Future<RpcResult<AddFlowOutput>> resultFuture = flowService.addFlow(addFlowInput);
+ JdkFutures.addErrorLogging(resultFuture, LOG, "addFlow");
if (i % batchSize == 0) {
try {
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
-
import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
writeOpStatus.set(FlowCounter.OperationStatus.IN_PROGRESS.status());
Short tableId = startTableId;
- Integer sourceIp = 1;
WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
short calculatedTableId = tableId;
+ int sourceIp = 1;
for (; sourceIp <= batchSize; sourceIp++) {
String flowId = "Flow-" + dpId + "." + calculatedTableId + "." + sourceIp;
LOG.debug("Adding flow with id: {}", flowId);
}
}
- private class DsCallBack implements FutureCallback {
+ private class DsCallBack implements FutureCallback<Void> {
private final String dpId;
- private Integer sourceIp;
+ private int sourceIp;
private final Short tableId;
- DsCallBack(String dpId, Integer sourceIp, Short tableId) {
+ DsCallBack(String dpId, int sourceIp, Short tableId) {
this.dpId = dpId;
this.sourceIp = sourceIp;
short numberA = 1;
}
@Override
- public void onSuccess(Object object) {
+ public void onSuccess(Void notUsed) {
if (sourceIp > flowsPerDpn) {
long dur = System.nanoTime() - startTime;
LOG.info("Completed all flows installation for: dpid: {}, tableId: {}, sourceIp: {} in {}ns", dpId,
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
-
import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
private final boolean isCreateParents;
private final AtomicInteger remainingTxReturn = new AtomicInteger(0);
- BindingTransactionChain txChain;
+ private BindingTransactionChain txChain;
FlowHandlerTask(final String dpId,
final int flowsPerDpn,
LOG.debug("Submitting Txn for dpId: {}, begin tableId: {}, end tableId: {}, sourceIp: {}", dpId,
tableId, calculatedTableId, sourceIp - 1);
Futures.addCallback(writeTransaction.submit(),
- new DsCallBack(dpId, tableId, calculatedTableId, sourceIp), MoreExecutors.directExecutor());
+ new DsCallBack(dpId, tableId, calculatedTableId, sourceIp, txChain),
+ MoreExecutors.directExecutor());
// Wrap around
tableId = (short) ((calculatedTableId + 1) % (short) (endTableId - startTableId + 1) + startTableId);
newBatchSize += batchSize;
}
}
- private class DsCallBack implements FutureCallback {
+ private class DsCallBack implements FutureCallback<Void> {
private final String dpId;
private final int sourceIp;
private final short endTableId;
private final short beginTableId;
+ private final BindingTransactionChain txChain;
- DsCallBack(String dpId, Short beginTableId, Short endTableId, Integer sourceIp) {
+ DsCallBack(String dpId, Short beginTableId, Short endTableId, Integer sourceIp,
+ BindingTransactionChain txChain) {
this.dpId = dpId;
this.sourceIp = sourceIp;
this.endTableId = endTableId;
this.beginTableId = beginTableId;
+ this.txChain = txChain;
}
@Override
- public void onSuccess(Object object) {
+ public void onSuccess(Void notUsed) {
if (remainingTxReturn.decrementAndGet() <= 0) {
long dur = System.nanoTime() - startTime;
LOG.info("Completed all flows installation for: dpid: {} in {}ns", dpId, dur);
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
import org.opendaylight.yang.gen.v1.urn.opendaylight.bulk.flow.service.rev150608.AddFlowsDsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.bulk.flow.service.rev150608.AddFlowsRpcInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.bulk.flow.service.rev150608.BulkFlowBaseContentGrouping;
public SalBulkFlowServiceImpl(SalFlowService flowService, DataBroker dataBroker) {
this.flowService = Preconditions.checkNotNull(flowService);
this.dataBroker = Preconditions.checkNotNull(dataBroker);
- register();
+
+ JdkFutures.addErrorLogging(register(), LOG, "register");
}
@Override
package org.opendaylight.openflowplugin.applications.bulk.o.matic;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
import com.google.common.base.Optional;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Before
public void setUp() throws Exception {
+ doReturn(RpcResultBuilder.success().buildFuture()).when(mockSalFlowService).addFlow(any());
+
when(mockDataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
NodeBuilder nodeBuilder = new NodeBuilder()
.setId(new NodeId("1"));
<artifactId>reconciliation-framework</artifactId>
<version>0.7.0-SNAPSHOT</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.infrautils</groupId>
+ <artifactId>infrautils-util</artifactId>
+ <version>${infrautils.version}</version>
+ </dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
package org.opendaylight.openflowplugin.applications.frm;
import com.google.common.collect.ImmutableMap;
+import java.util.Locale;
import java.util.Map;
public enum ForwardingRulesProperty {
*/
@Override
public String toString() {
- return this.name().toLowerCase().replace('_', '-');
+ return this.name().toLowerCase(Locale.ROOT).replace('_', '-');
}
}
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.openflowplugin.applications.frm.FlowCapableNodeConnectorCommitter;
-import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public abstract class AbstractNodeConnectorCommitter<T extends DataObject>
implements FlowCapableNodeConnectorCommitter<T> {
- private final ForwardingRulesManager provider;
-
- public AbstractNodeConnectorCommitter(ForwardingRulesManager provider) {
- this.provider = Preconditions.checkNotNull(provider, "ForwardingRulesManager can not be null!");
- }
@Override
public void onDataTreeChanged(Collection<DataTreeModification<T>> changes) {
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.RemoveFlowInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.RemoveFlowOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.UpdateFlowInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.UpdateFlowOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.flow.update.OriginalFlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.flow.update.UpdatedFlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowRef;
// into remove-flow input so that only a flow entry associated with
// a given flow object is removed.
builder.setTransactionUri(new Uri(provider.getNewTransactionId())).setStrict(Boolean.TRUE);
- provider.getSalFlowService().removeFlow(builder.build());
+ final Future<RpcResult<RemoveFlowOutput>> resultFuture =
+ provider.getSalFlowService().removeFlow(builder.build());
+ JdkFutures.addErrorLogging(resultFuture, LOG, "removeFlow");
}
}
builder.setUpdatedFlow(new UpdatedFlowBuilder(update).setStrict(Boolean.TRUE).build());
builder.setOriginalFlow(new OriginalFlowBuilder(original).setStrict(Boolean.TRUE).build());
- provider.getSalFlowService().updateFlow(builder.build());
+ final Future<RpcResult<UpdateFlowOutput>> resultFuture =
+ provider.getSalFlowService().updateFlow(builder.build());
+ JdkFutures.addErrorLogging(resultFuture, LOG, "updateFlow");
}
}
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frm.FlowNodeConnectorInventoryTranslator;
-import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
.synchronizedListMultimap(ArrayListMultimap.<BigInteger, String>create());
@SuppressWarnings("IllegalCatch")
- public FlowNodeConnectorInventoryTranslatorImpl(final ForwardingRulesManager manager, final DataBroker dataBroker) {
- super(manager);
+ public FlowNodeConnectorInventoryTranslatorImpl(final DataBroker dataBroker) {
Preconditions.checkNotNull(dataBroker, "DataBroker can not be null!");
final DataTreeIdentifier<FlowCapableNodeConnector> treeId =
BigInteger dpnId = getDpnIdFromNodeName(node);
ReadOnlyTransaction trans = provider.getReadTranaction();
- Optional<FlowCapableNode> flowNode = Optional.absent();
+ Optional<FlowCapableNode> flowNode;
// initialize the counter
int counter = 0;
try {
import java.util.Optional;
import java.util.concurrent.atomic.AtomicLong;
import javax.annotation.Nonnull;
-
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;
}
this.deviceMastershipManager = new DeviceMastershipManager(clusterSingletonServiceProvider, notificationService,
this.nodeListener, dataService);
- flowNodeConnectorInventoryTranslatorImpl = new FlowNodeConnectorInventoryTranslatorImpl(this, dataService);
+ flowNodeConnectorInventoryTranslatorImpl = new FlowNodeConnectorInventoryTranslatorImpl(dataService);
this.flowListener = new FlowForwarder(this, dataService);
this.groupListener = new GroupForwarder(this, dataService);
staleMarkingEnabled = Boolean.valueOf(propertyValue);
break;
case RECONCILIATION_RETRY_COUNT:
- reconciliationRetryCount = Integer.valueOf(propertyValue);
+ reconciliationRetryCount = Integer.parseInt(propertyValue);
break;
case BUNDLE_BASED_RECONCILIATION_ENABLED:
isBundleBasedReconciliationEnabled = Boolean.valueOf(propertyValue);
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.RemoveGroupInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.RemoveGroupOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.UpdateGroupInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.UpdateGroupOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.group.update.OriginalGroupBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.group.update.UpdatedGroupBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
builder.setNode(new NodeRef(nodeIdent.firstIdentifierOf(Node.class)));
builder.setGroupRef(new GroupRef(identifier));
builder.setTransactionUri(new Uri(provider.getNewTransactionId()));
- this.provider.getSalGroupService().removeGroup(builder.build());
+
+ final Future<RpcResult<RemoveGroupOutput>> resultFuture =
+ this.provider.getSalGroupService().removeGroup(builder.build());
+ JdkFutures.addErrorLogging(resultFuture, LOG, "removeGroup");
}
// TODO: Pull this into ForwardingRulesCommiter and override it here
builder.setUpdatedGroup(new UpdatedGroupBuilder(updatedGroup).build());
builder.setOriginalGroup(new OriginalGroupBuilder(originalGroup).build());
- this.provider.getSalGroupService().updateGroup(builder.build());
+ final Future<RpcResult<UpdateGroupOutput>> resultFuture =
+ this.provider.getSalGroupService().updateGroup(builder.build());
+ JdkFutures.addErrorLogging(resultFuture, LOG, "updateGroup");
}
@Override
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.RemoveMeterInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.RemoveMeterOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.UpdateMeterInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.UpdateMeterOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.meter.update.OriginalMeterBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.meter.update.UpdatedMeterBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
builder.setNode(new NodeRef(nodeIdent.firstIdentifierOf(Node.class)));
builder.setMeterRef(new MeterRef(identifier));
builder.setTransactionUri(new Uri(provider.getNewTransactionId()));
- this.provider.getSalMeterService().removeMeter(builder.build());
+
+ final Future<RpcResult<RemoveMeterOutput>> resultFuture =
+ this.provider.getSalMeterService().removeMeter(builder.build());
+ JdkFutures.addErrorLogging(resultFuture, LOG, "removeMeter");
}
@Override
builder.setUpdatedMeter(new UpdatedMeterBuilder(update).build());
builder.setOriginalMeter(new OriginalMeterBuilder(original).build());
- this.provider.getSalMeterService().updateMeter(builder.build());
+ final Future<RpcResult<UpdateMeterOutput>> resultFuture =
+ this.provider.getSalMeterService().updateMeter(builder.build());
+ JdkFutures.addErrorLogging(resultFuture, LOG, "updateMeter");
}
@Override
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.UpdateTableInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.UpdateTableOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.table.update.OriginalTableBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.table.update.UpdatedTableBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.TableRef;
if (this.provider.getSalTableService() != null) {
LOG.debug(" Handle to SalTableServices" + this.provider.getSalTableService());
}
- this.provider.getSalTableService().updateTable(builder.build());
+
+ final Future<RpcResult<UpdateTableOutput>> resultFuture =
+ this.provider.getSalTableService().updateTable(builder.build());
+ JdkFutures.addErrorLogging(resultFuture, LOG, "updateTable");
}
package org.opendaylight.openflowplugin.applications.frsync.impl;
-import com.google.common.base.Function;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
this.reconciliationRegistry = reconciliationRegistry;
}
+ @Override
public ListenableFuture<Boolean> syncup(final InstanceIdentifier<FlowCapableNode> flowcapableNodePath,
final SyncupEntry syncupEntry) {
ListenableFuture<Boolean> syncupResult = delegate.syncup(flowcapableNodePath,syncupEntry);
- return Futures.transform(syncupResult, new Function<Boolean, Boolean>() {
- @Override
- public Boolean apply(Boolean result) {
- if (result) {
- reconciliationRegistry.unregisterIfRegistered(nodeId);
- } else {
- reconciliationRegistry.register(nodeId);
- }
- return result;
+ return Futures.transform(syncupResult, result -> {
+ if (result) {
+ reconciliationRegistry.unregisterIfRegistered(nodeId);
+ } else {
+ reconciliationRegistry.register(nodeId);
}
+
+ return result;
}, MoreExecutors.directExecutor());
}
}
import java.util.List;
import java.util.Map;
import java.util.concurrent.Future;
-import javax.annotation.Nullable;
+import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.applications.frsync.SyncPlanPushStrategy;
import org.opendaylight.openflowplugin.applications.frsync.util.ItemSyncBox;
import org.opendaylight.openflowplugin.applications.frsync.util.PathUtil;
final SyncCrudCounters counters) {
return new FutureCallback<RpcResult<ProcessFlatBatchOutput>>() {
@Override
- public void onSuccess(@N
ullable final RpcResult<ProcessFlatBatchOutput> result) {
+ public void onSuccess(@N
onnull final RpcResult<ProcessFlatBatchOutput> result) {
if (!result.isSuccessful() && result.getResult() != null
&& !result.getResult().getBatchFailure().isEmpty()) {
Map<Range<Integer>, Batch> batchMap = mapBatchesToRanges(inputBatchBag, failureIndexLimit);
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.RemoveMeterOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.UpdateMeterOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.UpdateTableOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeatures;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeaturesKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcError;
ListenableFuture<RpcResult<Void>> updateTableFeatures(final InstanceIdentifier<FlowCapableNode> nodeIdent,
final FlowCapableNode flowCapableNodeConfigured) {
// CHECK if while pushing the update, updateTableInput can be null to emulate a table add
- final List<Table> tableList = ReconcileUtil.safeTables(flowCapableNodeConfigured);
+
//final List<Table> tableList = ReconcileUtil.safeTables(flowCapableNodeConfigured);
final List<ListenableFuture<RpcResult<UpdateTableOutput>>> allResults = new ArrayList<>();
- for (Table table : tableList) {
- TableKey tableKey = table.getKey();
- KeyedInstanceIdentifier<TableFeatures, TableFeaturesKey> tableFeaturesII = nodeIdent
- .child(TableFeatures.class, new TableFeaturesKey(tableKey.getId()));
- List<TableFeatures> tableFeatures = flowCapableNodeConfigured.getTableFeatures();
- if (tableFeatures != null) {
- for (TableFeatures tableFeaturesItem : tableFeatures) {
- // TODO uncomment java.lang.NullPointerException
- // at
- // org.opendaylight.openflowjava.protocol.impl.serialization.match.AbstractOxmMatchEntrySerializer
- // .serializeHeader(AbstractOxmMatchEntrySerializer.java:31
- // allResults.add(JdkFutureAdapters.listenInPoolThread(
- // tableForwarder.update(tableFeaturesII, null, tableFeaturesItem, nodeIdent)));
- }
- }
- }
+// for (Table table : tableList) {
+// List<TableFeatures> tableFeatures = flowCapableNodeConfigured.getTableFeatures();
+// if (tableFeatures != null) {
+// for (TableFeatures tableFeaturesItem : tableFeatures) {
+// // TODO uncomment java.lang.NullPointerException
+// // at
+// // org.opendaylight.openflowjava.protocol.impl.serialization.match.AbstractOxmMatchEntrySerializer
+// // .serializeHeader(AbstractOxmMatchEntrySerializer.java:31
+// // allResults.add(JdkFutureAdapters.listenInPoolThread(
+// // tableForwarder.update(tableFeaturesII, null, tableFeaturesItem, nodeIdent)));
+// }
+// }
+// }
final ListenableFuture<RpcResult<Void>> singleVoidResult = Futures.transform(
Futures.allAsList(allResults),
.build(new CacheLoader<K, Semaphore>() {
@Override
public Semaphore load(final K key) throws Exception {
- return new Semaphore(permits, fair) {
- private static final long serialVersionUID = 1L;
- };
+ return new Semaphore(permits, fair);
}
});
}
<groupId>org.opendaylight.openflowplugin.applications</groupId>
<artifactId>topology-lldp-discovery</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.infrautils</groupId>
+ <artifactId>infrautils-util</artifactId>
+ <version>${infrautils.version}</version>
+ </dependency>
<!-- Test dependencies -->
<dependency>
package org.opendaylight.openflowplugin.applications.lldpspeaker;
import com.google.common.base.Optional;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
}
@Override
+ @SuppressFBWarnings("BC_UNCONFIRMED_CAST_OF_RETURN_VALUE")
public void ownershipChanged(final EntityOwnershipChange ownershipChange) {
final String entityName = ownershipChange.getEntity().getIdentifier().firstKeyOf(Entity.class).getName();
if (entityName != null && isOpenFlowEntity(entityName)) {
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
+import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
+import org.opendaylight.openflowplugin.libraries.liblldp.PacketException;
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.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.applications.lldp.speaker.rev141023.OperStatus;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
}
- /**
- * {@inheritDoc}
- */
@Override
public void nodeConnectorAdded(final InstanceIdentifier<NodeConnector> nodeConnectorInstanceId,
final FlowCapableNodeConnector flowConnector) {
}
// Generate packet with destination switch and port
- TransmitPacketInput packet = new TransmitPacketInputBuilder()
- .setEgress(new NodeConnectorRef(nodeConnectorInstanceId))
- .setNode(new NodeRef(nodeInstanceId)).setPayload(LLDPUtil.buildLldpFrame(nodeId,
- nodeConnectorId, srcMacAddress, outputPortNo, addressDestionation)).build();
+ TransmitPacketInput packet;
+ try {
+ packet = new TransmitPacketInputBuilder()
+ .setEgress(new NodeConnectorRef(nodeConnectorInstanceId))
+ .setNode(new NodeRef(nodeInstanceId)).setPayload(LLDPUtil.buildLldpFrame(nodeId,
+ nodeConnectorId, srcMacAddress, outputPortNo, addressDestionation)).build();
+ } catch (NoSuchAlgorithmException | PacketException e) {
+ LOG.error("Error building LLDP frame", e);
+ return;
+ }
// Save packet to node connector id -> packet map to transmit it periodically on the configured interval.
nodeConnectorMap.put(nodeConnectorInstanceId, packet);
LOG.debug("Port {} added to LLDPSpeaker.nodeConnectorMap", nodeConnectorId.getValue());
// Transmit packet for first time immediately
- packetProcessingService.transmitPacket(packet);
+ final Future<RpcResult<Void>> resultFuture = packetProcessingService.transmitPacket(packet);
+ JdkFutures.addErrorLogging(resultFuture, LOG, "transmitPacket");
}
@Override
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;
private LLDPUtil() {
}
+ @Nonnull
static byte[] buildLldpFrame(final NodeId nodeId, final NodeConnectorId nodeConnectorId, final MacAddress src,
- final Long outPortNo, final MacAddress destinationAddress) {
+ final Long outPortNo, final MacAddress destinationAddress)
+ throws NoSuchAlgorithmException, PacketException {
// Create discovery pkt
LLDP discoveryPkt = new LLDP();
discoveryPkt.addCustomTLV(customTlv);
//Create LLDP CustomSec TLV
- byte[] pureValue = new byte[1];
- try {
- pureValue = getValueForLLDPPacketIntegrityEnsuring(nodeConnectorId);
- byte[] customSecValue = LLDPTLV.createCustomTLVValue(CUSTOM_TLV_SUB_TYPE_CUSTOM_SEC, pureValue);
- LLDPTLV customSecTlv = new LLDPTLV();
- customSecTlv.setType(LLDPTLV.TLVType.Custom.getValue()).setLength((short) customSecValue.length)
- .setValue(customSecValue);
- discoveryPkt.addCustomTLV(customSecTlv);
- } catch (NoSuchAlgorithmException e) {
- LOG.warn("LLDP extra authenticator creation failed.", e);
- }
-
+ byte[] pureValue = getValueForLLDPPacketIntegrityEnsuring(nodeConnectorId);
+ byte[] customSecValue = LLDPTLV.createCustomTLVValue(CUSTOM_TLV_SUB_TYPE_CUSTOM_SEC, pureValue);
+ LLDPTLV customSecTlv = new LLDPTLV();
+ customSecTlv.setType(LLDPTLV.TLVType.Custom.getValue()).setLength((short) customSecValue.length)
+ .setValue(customSecValue);
+ discoveryPkt.addCustomTLV(customSecTlv);
// Create ethernet pkt
byte[] sourceMac = HexEncode.bytesFromHexString(src.getValue());
ethPkt.setDestinationMACAddress(HexEncode.bytesFromHexString(destinationAddress.getValue()));
}
- try {
- return ethPkt.serialize();
- } catch (PacketException e) {
- LOG.warn("Error creating LLDP packet.", e);
- }
- return null;
+ return ethPkt.serialize();
}
+ @Nonnull
static byte[] buildLldpFrame(final NodeId nodeId, final NodeConnectorId nodeConnectorId,
- final MacAddress srcMacAddress, final Long outputPortNo) {
+ final MacAddress srcMacAddress, final Long outputPortNo) throws NoSuchAlgorithmException, PacketException {
return buildLldpFrame(nodeId, nodeConnectorId, srcMacAddress, outputPortNo, null);
}
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.google.common.base.Optional;
+import java.security.NoSuchAlgorithmException;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
+import org.opendaylight.openflowplugin.libraries.liblldp.PacketException;
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.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortNumberUni;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.applications.lldp.speaker.rev141023.OperStatus;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
/**
* Tests for {@link LLDPSpeaker}.
private static final MacAddress MAC_ADDRESS = new MacAddress("01:23:45:67:89:AB");
private static final FlowCapableNodeConnector FLOW_CAPABLE_NODE_CONNECTOR =
TestUtils.createFlowCapableNodeConnector(MAC_ADDRESS, 1L).build();
- private static final byte[] LLDP_FRAME = LLDPUtil.buildLldpFrame(new NodeId("openflow:1"),
- new NodeConnectorId("openflow:1:1"), MAC_ADDRESS, 1L);
- private static final TransmitPacketInput PACKET_INPUT = new TransmitPacketInputBuilder()
- .setEgress(new NodeConnectorRef(ID))
- .setNode(new NodeRef(ID.firstIdentifierOf(Node.class)))
- .setPayload(LLDP_FRAME).build();
+ private TransmitPacketInput packetInput;
@Mock
private PacketProcessingService packetProcessingService;
@Mock
private EntityOwnershipService entityOwnershipService;
- private final MacAddress destinationMACAddress = null;
private LLDPSpeaker lldpSpeaker;
@Before
- public void setUp() {
- when(
- scheduledExecutorService.scheduleAtFixedRate(
- any(Runnable.class), anyLong(), anyLong(),
- any(TimeUnit.class))).thenReturn(scheduledSpeakerTask);
+ public void setUp() throws NoSuchAlgorithmException, PacketException {
+ byte[] lldpFrame = LLDPUtil.buildLldpFrame(new NodeId("openflow:1"),
+ new NodeConnectorId("openflow:1:1"), MAC_ADDRESS, 1L);
+ packetInput = new TransmitPacketInputBuilder().setEgress(new NodeConnectorRef(ID))
+ .setNode(new NodeRef(ID.firstIdentifierOf(Node.class))).setPayload(lldpFrame).build();
+
+ when(scheduledExecutorService.scheduleAtFixedRate(any(Runnable.class), anyLong(), anyLong(),
+ any(TimeUnit.class))).thenReturn(scheduledSpeakerTask);
lldpSpeaker = new LLDPSpeaker(packetProcessingService,
- scheduledExecutorService, destinationMACAddress, entityOwnershipService);
+ scheduledExecutorService, null, entityOwnershipService);
when(entityOwnershipService.getOwnershipState(any())).thenReturn(Optional.of(EntityOwnershipState.IS_OWNER));
lldpSpeaker.setOperationalStatus(OperStatus.RUN);
+
+ doReturn(RpcResultBuilder.success().buildFuture()).when(packetProcessingService).transmitPacket(any());
}
/**
lldpSpeaker.run();
// Check packet transmission
- verify(packetProcessingService, times(1)).transmitPacket(PACKET_INPUT);
+ verify(packetProcessingService, times(1)).transmitPacket(packetInput);
verifyNoMoreInteractions(packetProcessingService);
}
lldpSpeaker.run();
// Check packet transmission
- verify(packetProcessingService, times(1)).transmitPacket(PACKET_INPUT);
+ verify(packetProcessingService, times(1)).transmitPacket(packetInput);
verifyNoMoreInteractions(packetProcessingService);
}
// Verify that LLDP frame sent only once (by nodeConnectorAdded),
// e.g. no flood after removal
- verify(packetProcessingService, times(1)).transmitPacket(PACKET_INPUT);
+ verify(packetProcessingService, times(1)).transmitPacket(packetInput);
verifyNoMoreInteractions(packetProcessingService);
}
}
// Check packet transmission
- verify(packetProcessingService, times(1)).transmitPacket(PACKET_INPUT);
+ verify(packetProcessingService, times(1)).transmitPacket(packetInput);
verifyNoMoreInteractions(packetProcessingService);
}
<groupId>org.opendaylight.openflowplugin</groupId>
<artifactId>openflowplugin-common</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.infrautils</groupId>
+ <artifactId>infrautils-util</artifactId>
+ <version>${infrautils.version}</version>
+ </dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
package org.opendaylight.openflowplugin.openflow.ofswitch.config;
import java.util.Collection;
+import java.util.concurrent.Future;
import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.module.config.rev141015.NodeConfigService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.module.config.rev141015.SetConfigInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.module.config.rev141015.SetConfigOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.SwitchConfigFlag;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final int STARTUP_LOOP_MAX_RETRIES = 8;
private final NodeConfigService nodeConfigService;
private final DataBroker dataBroker;
- private ListenerRegistration<DataTreeChangeListener> listenerRegistration;
+ private ListenerRegistration<?> listenerRegistration;
public DefaultConfigPusher(NodeConfigService nodeConfigService, DataBroker dataBroker) {
this.nodeConfigService = nodeConfigService;
setConfigInputBuilder.setMissSearchLength(OFConstants.OFPCML_NO_BUFFER);
setConfigInputBuilder.setNode(new NodeRef(modification.getRootPath()
.getRootIdentifier().firstIdentifierOf(Node.class)));
- nodeConfigService.setConfig(setConfigInputBuilder.build());
+ final Future<RpcResult<SetConfigOutput>> resultFuture =
+ nodeConfigService.setConfig(setConfigInputBuilder.build());
+ JdkFutures.addErrorLogging(resultFuture, LOG, "addFlow");
}
}
}
package org.opendaylight.openflowplugin.openflow.ofswitch.config;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
+
import java.util.Collections;
import org.junit.After;
import org.junit.Assert;
import org.opendaylight.yang.gen.v1.urn.opendaylight.module.config.rev141015.SetConfigInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.SwitchConfigFlag;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
/**
* Test for {@link DefaultConfigPusher}.
@Before
public void setUp() throws Exception {
+ doReturn(RpcResultBuilder.success().buildFuture()).when(nodeConfigService).setConfig(any());
defaultConfigPusher = new DefaultConfigPusher(nodeConfigService, Mockito.mock(DataBroker.class));
final DataTreeIdentifier<FlowCapableNode> identifier =
new DataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, NODE_IID);
List<OFNode> ofNodeList = ShellUtil.getAllNodes(dataBroker);
if (ofNodeList.isEmpty()) {
session.getConsole().println("No node is connected yet");
- } else if (ofNodeList != null && ofNodeList.size() > 0) {
+ } else {
StringBuilder stringBuilder = new StringBuilder();
Formatter formatter = new Formatter(stringBuilder);
session.getConsole().println("Number of nodes: " + ofNodeList.size());
package org.opendaylight.openflowplugin.applications.southboundcli.cli;
import java.util.Formatter;
-import java.util.HashSet;
-import java.util.Set;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.apache.karaf.shell.console.OsgiCommandSupport;
}
private void printNodeOutput(final OFNode ofNode) {
- Set<String> portNames = new HashSet<>();
String ofNodeId = ofNode.getNodeId().toString();
String ofNodeName = ofNode.getNodeName();
for (String port : ofNode.getPorts()) {
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
+import javax.annotation.Nonnull;
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;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-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.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
private ShellUtil() {
}
+ @Nonnull
public static List<OFNode> getAllNodes(final DataBroker broker) {
List<Node> nodes = null;
ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
name = node.<FlowCapableNode>getAugmentation(FlowCapableNode.class).getDescription();
} else {
LOG.error("Error while converting OFNode: {} to FlowCapableNode", node.getId());
- return null;
+ return Collections.emptyList();
}
OFNode ofNode = new OFNode(Long.parseLong(nodeId[1]), name);
- if (ofNode != null) {
- LOG.trace("Added OFNode: {} to the list", ofNode.getNodeId());
- nodeList.add(ofNode);
- }
+ LOG.trace("Added OFNode: {} to the list", ofNode.getNodeId());
+ nodeList.add(ofNode);
}
Collections.sort(nodeList);
return nodeList;
LOG.error("Error for OFNode:{} while reading nodeConnectors {}", node.getId());
return null;
} else {
- MacAddress hardwareAddress = flowCapableNodeConnector.getHardwareAddress();
String portName = flowCapableNodeConnector.getName();
portList.add(portName);
}
<groupId>org.opendaylight.openflowplugin.model</groupId>
<artifactId>model-flow-service</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.infrautils</groupId>
+ <artifactId>infrautils-util</artifactId>
+ <version>${infrautils.version}</version>
+ </dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
-import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
import javax.annotation.Nonnull;
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.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowModFlags;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class LLDPPacketPuntEnforcer implements AutoCloseable, ClusteredDataTreeChangeListener<FlowCapableNode> {
+ private static final Logger LOG = LoggerFactory.getLogger(LLDPPacketPuntEnforcer.class);
private static final long STARTUP_LOOP_TICK = 500L;
private static final int STARTUP_LOOP_MAX_RETRIES = 8;
private static final short TABLE_ID = (short) 0;
private static final String DEFAULT_FLOW_ID = "42";
private final SalFlowService flowService;
private final DataBroker dataBroker;
- private ListenerRegistration<DataTreeChangeListener> listenerRegistration;
+ private ListenerRegistration<?> listenerRegistration;
public LLDPPacketPuntEnforcer(SalFlowService flowService, DataBroker dataBroker) {
this.flowService = flowService;
public void start() {
final InstanceIdentifier<FlowCapableNode> path = InstanceIdentifier.create(Nodes.class).child(Node.class)
.augmentation(FlowCapableNode.class);
- final DataTreeIdentifier<FlowCapableNode> identifier = new DataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
- path);
+ final DataTreeIdentifier<FlowCapableNode> identifier = new DataTreeIdentifier<>(
+ LogicalDatastoreType.OPERATIONAL, path);
SimpleTaskRetryLooper looper = new SimpleTaskRetryLooper(STARTUP_LOOP_TICK, STARTUP_LOOP_MAX_RETRIES);
try {
- listenerRegistration = looper
- .loopUntilNoException(new Callable<ListenerRegistration<DataTreeChangeListener>>() {
- @Override
- public ListenerRegistration<DataTreeChangeListener> call() throws Exception {
- return dataBroker.registerDataTreeChangeListener(identifier, LLDPPacketPuntEnforcer.this);
- }
- });
+ listenerRegistration = looper.loopUntilNoException(() ->
+ dataBroker.registerDataTreeChangeListener(identifier, LLDPPacketPuntEnforcer.this));
} catch (Exception e) {
throw new IllegalStateException("registerDataTreeChangeListener failed", e);
}
@Override
public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<FlowCapableNode>> modifications) {
- for (DataTreeModification modification : modifications) {
+ for (DataTreeModification<FlowCapableNode> modification : modifications) {
if (modification.getRootNode().getModificationType() == ModificationType.WRITE) {
AddFlowInputBuilder addFlowInput = new AddFlowInputBuilder(createFlow());
addFlowInput.setNode(
new NodeRef(modification.getRootPath().getRootIdentifier().firstIdentifierOf(Node.class)));
- this.flowService.addFlow(addFlowInput.build());
+ final Future<RpcResult<AddFlowOutput>> resultFuture = this.flowService.addFlow(addFlowInput.build());
+ JdkFutures.addErrorLogging(resultFuture, LOG, "addFlow");
}
}
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
import java.util.Collections;
import org.junit.After;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
/**
* Test for {@link LLDPPacketPuntEnforcer}.
@Before
public void setUp() {
+ doReturn(RpcResultBuilder.success().buildFuture()).when(flowService).addFlow(any());
lldpPacketPuntEnforcer = new LLDPPacketPuntEnforcer(flowService, Mockito.mock(DataBroker.class));
final DataTreeIdentifier<FlowCapableNode> identifier = new DataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
NODE_IID);
*/
package org.opendaylight.openflowplugin.applications.topology.lldp;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
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;
private final ListenerRegistration<NotificationListener> lldpNotificationRegistration;
+ @SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
public LLDPActivator(NotificationProviderService notificationService, LLDPDiscoveryListener lldpDiscoveryListener,
TopologyLldpDiscoveryConfig topologyLldpDiscoveryConfig) {
lldpSecureKey = topologyLldpDiscoveryConfig.getLldpSecureKey();
package org.opendaylight.openflowplugin.applications.topology.lldp;
import com.google.common.collect.ImmutableMap;
-
+import java.util.Locale;
import java.util.Map;
public enum TopologyLLDPDiscoveryProperty {
*/
@Override
public String toString() {
- return this.name().toLowerCase().replace('_', '-');
+ return this.name().toLowerCase(Locale.ROOT).replace('_', '-');
}
}
import java.lang.management.ManagementFactory;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Objects;
}
final String pureValue = nodeConnectorId + finalKey;
- final byte[] pureBytes = pureValue.getBytes();
+ final byte[] pureBytes = pureValue.getBytes(StandardCharsets.UTF_8);
HashFunction hashFunction = Hashing.md5();
Hasher hasher = hashFunction.newHasher();
HashCode hashedValue = hasher.putBytes(pureBytes).hash();
Code Review / openflowplugin.git / commitdiff