This mass-converts all components to use MD-SAL APIs.
Change-Id: Ied51c12836fc1fc91038557e66f02f4d9f0d6b0d
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
<artifactId>openflowplugin-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
*/
package org.opendaylight.openflowplugin.applications.bulk.o.matic;
-import com.google.common.base.Optional;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
String flowId = "Flow-" + dpId + "." + tableId + "." + sourceIp;
InstanceIdentifier<Flow> flowIid = getFlowInstanceIdentifier(dpId, tableId, flowId);
- try (ReadOnlyTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction()) {
Optional<Flow> flowOptional;
if (isConfigDs) {
- flowOptional = readOnlyTransaction.read(LogicalDatastoreType.CONFIGURATION, flowIid)
- .checkedGet();
+ flowOptional = readOnlyTransaction.read(LogicalDatastoreType.CONFIGURATION, flowIid).get();
} else {
- flowOptional = readOnlyTransaction.read(LogicalDatastoreType.OPERATIONAL, flowIid).checkedGet();
+ flowOptional = readOnlyTransaction.read(LogicalDatastoreType.OPERATIONAL, flowIid).get();
}
if (flowOptional.isPresent()) {
LOG.info("Flow: {} not found", flowIid);
}
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
readOpStatus.set(FlowCounter.OperationStatus.FAILURE.status());
LOG.error("Error {}", e);
}
package org.opendaylight.openflowplugin.applications.bulk.o.matic;
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;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
calculatedTableId = (short) ((calculatedTableId + numberA) % numberB + startTableId);
}
}
- Futures.addCallback(writeTransaction.submit(),
+ writeTransaction.commit().addCallback(
new DsCallBack(dpId, tableId, calculatedTableId, sourceIp), MoreExecutors.directExecutor());
// Wrap around
tableId = (short) ((calculatedTableId + 1) % (short) (endTableId - startTableId + 1) + startTableId);
}
}
- private class DsCallBack implements FutureCallback {
+ private class DsCallBack implements FutureCallback<Object> {
private final String dpId;
private final int sourceIp;
private final short endTableId;
*/
package org.opendaylight.openflowplugin.applications.bulk.o.matic;
-import com.google.common.base.Optional;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
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;
Set<String> nodeIds = new HashSet<>();
InstanceIdentifier<Nodes> nodes = InstanceIdentifier.create(Nodes.class);
- try (ReadOnlyTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction()) {
- Optional<Nodes> nodesDataNode = readOnlyTransaction.read(LogicalDatastoreType.OPERATIONAL, nodes)
- .checkedGet();
+ try (ReadTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction()) {
+ Optional<Nodes> nodesDataNode = readOnlyTransaction.read(LogicalDatastoreType.OPERATIONAL, nodes).get();
if (nodesDataNode.isPresent()) {
List<Node> nodesCollection = nodesDataNode.get().getNode();
if (nodesCollection != null && !nodesCollection.isEmpty()) {
} else {
return Collections.emptySet();
}
- } catch (ReadFailedException rdFailedException) {
- LOG.error("Failed to read connected nodes {}", rdFailedException);
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Failed to read connected nodes {}", e);
}
return nodeIds;
}
package org.opendaylight.openflowplugin.applications.bulk.o.matic;
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;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
LOG.debug("Submitting Txn for dpId: {}, begin tableId: {}, end tableId: {}, sourceIp: {}", dpId, tableId,
calculatedTableId, sourceIp);
- Futures.addCallback(writeTransaction.submit(), new DsCallBack(dpId, sourceIp, calculatedTableId),
+ writeTransaction.commit().addCallback(new DsCallBack(dpId, sourceIp, calculatedTableId),
MoreExecutors.directExecutor());
}
}
}
- private class DsCallBack implements FutureCallback<Void> {
+ private class DsCallBack implements FutureCallback<Object> {
private final String dpId;
private int sourceIp;
private final Short tableId;
}
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
if (sourceIp > flowsPerDpn) {
long dur = System.nanoTime() - startTime;
LOG.info("Completed all flows installation for: dpid: {}, tableId: {}, sourceIp: {} in {}ns", dpId,
}
LOG.debug("OnSuccess: Submitting Txn for dpId: {}, begin tableId: {}, end tableId: {}, sourceIp: {}",
dpId, tableId, calculatedTableId, sourceIp);
- Futures.addCallback(writeTransaction.submit(), new DsCallBack(dpId, sourceIp, calculatedTableId),
+ writeTransaction.commit().addCallback(new DsCallBack(dpId, sourceIp, calculatedTableId),
MoreExecutors.directExecutor());
}
package org.opendaylight.openflowplugin.applications.bulk.o.matic;
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;
-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.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.Transaction;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.TransactionChainListener;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private final boolean isCreateParents;
private final AtomicInteger remainingTxReturn = new AtomicInteger(0);
- private BindingTransactionChain txChain;
+ private TransactionChain 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(),
+ writeTransaction.commit().addCallback(
new DsCallBack(dpId, tableId, calculatedTableId, sourceIp, txChain),
MoreExecutors.directExecutor());
// Wrap around
}
@Override
- public void onTransactionChainFailed(TransactionChain<?, ?> transactionChain,
- AsyncTransaction<?, ?> asyncTransaction, Throwable throwable) {
+ public void onTransactionChainFailed(TransactionChain transactionChain,
+ Transaction asyncTransaction, Throwable throwable) {
LOG.error("Transaction chain: {} FAILED at asyncTransaction: {} due to: ", transactionChain,
asyncTransaction.getIdentifier(), throwable);
transactionChain.close();
}
@Override
- public void onTransactionChainSuccessful(TransactionChain<?, ?> transactionChain) {
+ public void onTransactionChainSuccessful(TransactionChain transactionChain) {
LOG.info("Transaction chain: {} closed successfully.", transactionChain);
}
}
}
- private class DsCallBack implements FutureCallback<Void> {
+ private class DsCallBack implements FutureCallback<Object> {
private final String dpId;
private final int sourceIp;
private final short endTableId;
private final short beginTableId;
- private final BindingTransactionChain txChain;
+ private final TransactionChain txChain;
DsCallBack(String dpId, Short beginTableId, Short endTableId, Integer sourceIp,
- BindingTransactionChain txChain) {
+ TransactionChain txChain) {
this.dpId = dpId;
this.sourceIp = sourceIp;
this.endTableId = endTableId;
}
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
if (remainingTxReturn.decrementAndGet() <= 0) {
long dur = System.nanoTime() - startTime;
LOG.info("Completed all flows installation for: dpid: {} in {}ns", dpId, dur);
import javax.management.MalformedObjectNameException;
import javax.management.NotCompliantMBeanException;
import javax.management.ObjectName;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
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.AddFlowsDsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.bulk.flow.service.rev150608.AddFlowsRpcInput;
flowBuilder.build(), createParents);
createParents = createParentsNextTime;
}
- ListenableFuture<Void> submitFuture = writeTransaction.submit();
+ ListenableFuture<?> submitFuture = writeTransaction.commit();
return Futures.transform(handleResultFuture(Futures.allAsList(submitFuture)), voidRpcResult -> {
if (voidRpcResult.isSuccessful()) {
return RpcResultBuilder.<AddFlowsDsOutput>success().build();
for (BulkFlowDsItem bulkFlow : input.getBulkFlowDsItem()) {
writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, getFlowInstanceIdentifier(bulkFlow));
}
- return Futures.transform(handleResultFuture(Futures.allAsList(writeTransaction.submit())), voidRpcResult -> {
+ return Futures.transform(handleResultFuture(Futures.allAsList(writeTransaction.commit())), voidRpcResult -> {
if (voidRpcResult.isSuccessful()) {
return RpcResultBuilder.<RemoveFlowsDsOutput>success().build();
} else {
package org.opendaylight.openflowplugin.applications.bulk.o.matic;
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;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
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.TableBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
wtx.delete(LogicalDatastoreType.CONFIGURATION, tableIId);
}
- Futures.addCallback(wtx.submit(), new FutureCallback<Void>() {
+ wtx.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void voidParameter) {
+ public void onSuccess(Object voidParameter) {
if (successfulWrites.incrementAndGet() == totalTables) {
if (failedWrites.get() > 0) {
writeOpStatus.set(FlowCounter.OperationStatus.FAILURE.status());
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" odl:type="pingpong"/>
+ <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker" odl:type="pingpong"/>
<odl:rpc-service id="flowService"
interface="org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService"/>
</bean>
<odl:rpc-implementation ref="bulkFlowService"/>
-</blueprint>
\ No newline at end of file
+</blueprint>
* 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.bulk.o.matic;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
+import java.util.Optional;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
/**
* Test for {@link FlowReader}.
@Mock
private DataBroker mockDataBroker;
@Mock
- private ReadOnlyTransaction readOnlyTransaction;
+ private ReadTransaction readOnlyTransaction;
@Mock
private Node node;
@Before
public void setUp() throws Exception {
- when(readOnlyTransaction.read(Mockito.any(LogicalDatastoreType.class), Mockito.<InstanceIdentifier<Node>>any()))
- .thenReturn(Futures.immediateCheckedFuture(Optional.of(node)));
+ doReturn(FluentFutures.immediateFluentFuture(Optional.of(node))).when(readOnlyTransaction)
+ .read(any(LogicalDatastoreType.class), any());
when(mockDataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
flowReader = FlowReader.getNewInstance(mockDataBroker, 2, 5, true, false, (short) 1, (short) 2);
}
-/**
+/*
* Copyright (c) 2016, 2017 Cisco Systems, Inc. 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.applications.bulk.o.matic;
import static org.mockito.Mockito.doReturn;
-import com.google.common.util.concurrent.Futures;
import java.util.concurrent.ExecutorService;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* Test for {@link FlowWriterConcurrent}.
*/
@RunWith(MockitoJUnitRunner.class)
public class FlowWriterConcurrentTest {
-
- private static final Logger LOG = LoggerFactory.getLogger(FlowWriterConcurrentTest.class);
private static final int FLOWS_PER_DPN = 100;
@Mock
public void setUp() throws Exception {
doReturn(writeTransaction).when(mockDataBroker).newWriteOnlyTransaction();
- Mockito.when(writeTransaction.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(CommitInfo.emptyFluentFuture()).when(writeTransaction).commit();
Mockito.doAnswer(invocation -> {
((Runnable) invocation.getArguments()[0]).run();
-/**
+/*
* Copyright (c) 2016, 2017 Cisco Systems, Inc. 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.applications.bulk.o.matic;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutorService;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
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.inventory.rev130819.nodes.NodeBuilder;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Mock
private ExecutorService mockFlowPusher;
@Mock
- private ReadOnlyTransaction readOnlyTransaction;
+ private ReadTransaction readOnlyTransaction;
@Mock
private Nodes mockNodes;
when(mockNodes.getNode()).thenReturn(nodes);
- when(readOnlyTransaction.read(Mockito.any(LogicalDatastoreType.class),
- Mockito.<InstanceIdentifier<Nodes>>any()))
- .thenReturn(Futures.immediateCheckedFuture(Optional.of(mockNodes)));
+ doReturn(FluentFutures.immediateFluentFuture(Optional.of(mockNodes))).when(readOnlyTransaction)
+ .read(any(LogicalDatastoreType.class), any());
Mockito.doAnswer(invocation -> {
((Runnable)invocation.getArguments()[0]).run();
-/**
+/*
* Copyright (c) 2016, 2017 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import static org.mockito.Mockito.doReturn;
-import com.google.common.util.concurrent.Futures;
import java.util.concurrent.ExecutorService;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* Test for {@link FlowWriterSequential}.
*/
@RunWith(MockitoJUnitRunner.class)
public class FlowWriterSequentialTest {
-
- private static final Logger LOG = LoggerFactory.getLogger(FlowWriterSequentialTest.class);
private static final int FLOWS_PER_DPN = 100;
@Mock
public void setUp() throws Exception {
doReturn(writeTransaction).when(mockDataBroker).newWriteOnlyTransaction();
- Mockito.when(writeTransaction.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(CommitInfo.emptyFluentFuture()).when(writeTransaction).commit();
Mockito.doAnswer(invocation -> {
((Runnable) invocation.getArguments()[0]).run();
-/**
+/*
* Copyright (c) 2016, 2017 Cisco Systems, Inc. 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.applications.bulk.o.matic;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import com.google.common.util.concurrent.Futures;
import java.util.concurrent.ExecutorService;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.TransactionChainListener;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
return null;
}).when(mockFlowPusher).execute(ArgumentMatchers.<Runnable>any());
- final BindingTransactionChain mockedTxChain = mock(BindingTransactionChain.class);
+ final TransactionChain mockedTxChain = mock(TransactionChain.class);
when(mockedTxChain.newWriteOnlyTransaction()).thenReturn(writeTransaction);
doReturn(mockedTxChain).when(mockDataBroker)
.createTransactionChain(ArgumentMatchers.<TransactionChainListener>any());
- when(writeTransaction.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(CommitInfo.emptyFluentFuture()).when(writeTransaction).commit();
flowWriterTxChain = new FlowWriterTxChain(mockDataBroker, mockFlowPusher);
}
-/**
+/*
* Copyright (c) 2016, 2017 Cisco Systems, Inc. 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.applications.bulk.o.matic;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.lenient;
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 com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
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.AddFlowsDsInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.bulk.flow.service.rev150608.AddFlowsRpcInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
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.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* Test for {@link SalBulkFlowServiceImpl}.
@RunWith(MockitoJUnitRunner.class)
public class SalBulkFlowServiceImplTest {
- private static final Logger LOG = LoggerFactory.getLogger(SalBulkFlowServiceImplTest.class);
-
@Mock
private DataBroker mockDataBroker;
@Mock
@Mock
private WriteTransaction writeTransaction;
@Mock
- private ReadOnlyTransaction readOnlyTransaction;
+ private ReadTransaction readOnlyTransaction;
@Mock
private Nodes mockNodes;
@Mock
public void setUp() throws Exception {
when(mockDataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
when(mockDataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
- Mockito.lenient().when(readOnlyTransaction.read(Mockito.any(LogicalDatastoreType.class),
- Mockito.<InstanceIdentifier<Node>>any()))
- .thenReturn(Futures.immediateCheckedFuture(Optional.of(mockNode)));
+
+ lenient().doReturn(FluentFutures.immediateFluentFuture(Optional.of(mockNode))).when(readOnlyTransaction)
+ .read(any(LogicalDatastoreType.class), any());
salBulkFlowService = new SalBulkFlowServiceImpl(mockSalFlowService, mockDataBroker);
}
@Test
public void testAddRemoveFlowsDs() throws Exception {
- Mockito.when(writeTransaction.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(CommitInfo.emptyFluentFuture()).when(writeTransaction).commit();
final BulkFlowDsItemBuilder bulkFlowDsItemBuilder = new BulkFlowDsItemBuilder().setFlowId(new FlowId("1"))
.setTableId((short) 2);
final AddFlowsDsInput addFlowsDsInput = addFlowsDsInputBuilder.build();
salBulkFlowService.addFlowsDs(addFlowsDsInput);
- verify(writeTransaction).submit();
+ verify(writeTransaction).commit();
verify(writeTransaction).put(ArgumentMatchers.<LogicalDatastoreType>any(),
ArgumentMatchers.<InstanceIdentifier<Flow>>any(),
flowArgumentCaptor.capture(), Mockito.anyBoolean());
salBulkFlowService.removeFlowsDs(removeFlowsDsInput);
verify(writeTransaction).delete(ArgumentMatchers.<LogicalDatastoreType>any(),
ArgumentMatchers.<InstanceIdentifier<Flow>>any());
- verify(writeTransaction, times(2)).submit();
+ verify(writeTransaction, times(2)).commit();
}
@Test
@Test
public void testFlowRpcAddTest() throws Exception {
- when(readOnlyTransaction.read(Mockito.any(LogicalDatastoreType.class),
- Mockito.<InstanceIdentifier<Nodes>>any()))
- .thenReturn(Futures.immediateCheckedFuture(Optional.of(mockNodes)));
+ doReturn(FluentFutures.immediateFluentFuture(Optional.of(mockNodes))).when(readOnlyTransaction)
+ .read(any(LogicalDatastoreType.class), any());
final FlowRpcAddTestInputBuilder flowRpcAddTestInputBuilder = new FlowRpcAddTestInputBuilder().setFlowCount(1L)
.setDpnId("1").setRpcBatchSize(1L);
@Test
public void testFlowRpcAddMultiple() throws Exception {
- when(readOnlyTransaction.read(Mockito.any(LogicalDatastoreType.class),
- Mockito.<InstanceIdentifier<Nodes>>any()))
- .thenReturn(Futures.immediateCheckedFuture(Optional.of(mockNodes)));
+ doReturn(FluentFutures.immediateFluentFuture(Optional.of(mockNodes))).when(readOnlyTransaction)
+ .read(any(LogicalDatastoreType.class), any());
final FlowRpcAddMultipleInputBuilder flowRpcAddMultipleInputBuilder = new FlowRpcAddMultipleInputBuilder()
.setFlowCount(1L).setRpcBatchSize(1L);
-/**
+/*
* Copyright (c) 2017 Cisco Systems, Inc. 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.applications.bulk.o.matic;
import static org.mockito.Mockito.doReturn;
-import com.google.common.util.concurrent.Futures;
import java.util.concurrent.ExecutorService;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* Test for {@link FlowWriterSequential}.
*/
@RunWith(MockitoJUnitRunner.class)
public class TableWriterTest {
- private static final Logger LOG = LoggerFactory.getLogger(TableWriterTest.class);
-
private static final int TABLES_PER_DPN = 100;
private static final int DPN_COUNT = 1;
private static final short START_TABLE_ID = 0;
public void setUp() throws Exception {
doReturn(writeTransaction).when(mockDataBroker).newWriteOnlyTransaction();
- Mockito.when(writeTransaction.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(CommitInfo.emptyFluentFuture()).when(writeTransaction).commit();
Mockito.doAnswer(invocation -> {
((Runnable) invocation.getArguments()[0]).run();
<optional>true</optional>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.serviceutils</groupId>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-common</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-util</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-singleton-common-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
<type>test-jar</type>
</dependency>
-/**
+/*
* Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.applications.frm;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
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;
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. 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.applications.frm;
import java.util.concurrent.Future;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-/**
+/*
* Copyright (c) 2014, 2017 Cisco Systems, Inc. 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.applications.frm;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationListener;
import org.opendaylight.openflowplugin.applications.frm.impl.DevicesGroupRegistry;
import org.opendaylight.openflowplugin.applications.frm.impl.FlowNodeConnectorInventoryTranslatorImpl;
*
* @return ReadOnlyTransaction
*/
- ReadOnlyTransaction getReadTransaction();
+ ReadTransaction getReadTransaction();
/**
* Flow RPC service.
-/**
+/*
* 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.Preconditions;
import java.util.Collection;
-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.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesCommiter;
import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
import org.opendaylight.openflowplugin.applications.frm.NodeConfigurator;
import org.slf4j.LoggerFactory;
/**
- * AbstractChangeListner implemented basic {@link org.opendaylight.controller.md.sal.binding.api.DataTreeModification}
+ * AbstractChangeListner implemented basic {@link org.opendaylight.mdsal.binding.api.DataTreeModification}
* processing for flow node subDataObject (flows, groups and meters).
*/
public abstract class AbstractListeningCommiter<T extends DataObject> implements ForwardingRulesCommiter<T>,
-/**
+/*
* Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.applications.frm.impl;
import com.google.common.base.Preconditions;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.openflowplugin.applications.frm.FlowCapableNodeConnectorCommitter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yangtools.yang.binding.DataObject;
* 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.frm.impl;
import static org.opendaylight.openflowplugin.applications.frm.util.FrmUtil.buildGroupInstanceIdentifier;
import static org.opendaylight.openflowplugin.applications.frm.util.FrmUtil.isFlowDependentOnGroup;
import static org.opendaylight.openflowplugin.applications.frm.util.FrmUtil.isGroupExistsOnDevice;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
import org.opendaylight.openflowplugin.applications.frm.NodeConfigurator;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
LOG.trace("The dependent group {} isn't programmed yet. Pushing the group", groupId);
InstanceIdentifier<Group> groupIdent = buildGroupInstanceIdentifier(nodeIdent, groupId);
LOG.info("Reading the group from config inventory: {}", groupId);
- try (ReadOnlyTransaction readTransaction = forwardingRulesManager.getReadTransaction()) {
- Optional<Group> group = readTransaction
- .read(LogicalDatastoreType.CONFIGURATION, groupIdent).get();
+ try (ReadTransaction readTransaction = forwardingRulesManager.getReadTransaction()) {
+ Optional<Group> group = readTransaction.read(LogicalDatastoreType.CONFIGURATION, groupIdent).get();
if (group.isPresent()) {
final AddGroupInputBuilder builder = new AddGroupInputBuilder(group.get());
builder.setNode(new NodeRef(nodeIdent.firstIdentifierOf(Node.class)));
package org.opendaylight.openflowplugin.applications.frm.impl;
+import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.atomic.AtomicBoolean;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
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.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.frm.reconciliation.service.rev180227.FrmReconciliationService;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.slf4j.Logger;
private final AtomicBoolean isDeviceInOperDS = new AtomicBoolean(false);
private final InstanceIdentifier<FlowCapableNode> fcnIID;
private final KeyedInstanceIdentifier<Node, NodeKey> path;
- private final RoutedRpcRegistration routedRpcReg;
- public DeviceMastership(final NodeId nodeId, final RoutedRpcRegistration routedRpcReg) {
+ private ObjectRegistration<@NonNull FrmReconciliationService> reg;
+
+ public DeviceMastership(final NodeId nodeId) {
this.nodeId = nodeId;
this.identifier = ServiceGroupIdentifier.create(nodeId.getValue());
fcnIID = InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(nodeId))
.augmentation(FlowCapableNode.class);
path = InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(nodeId));
- this.routedRpcReg = routedRpcReg;
}
@Override
return deviceMastered.get();
}
- public void setDeviceOperationalStatus(boolean inOperDS) {
+ public void setDeviceOperationalStatus(final boolean inOperDS) {
isDeviceInOperDS.set(inOperDS);
}
deviceMastered.set(true);
}
- public void registerReconciliationRpc() {
- LOG.debug("The path is registered : {}", path);
- routedRpcReg.registerPath(NodeContext.class, path);
+ public void registerReconciliationRpc(final RpcProviderService rpcProviderService,
+ final FrmReconciliationService reconcliationService) {
+ if (reg == null) {
+ LOG.debug("The path is registered : {}", path);
+ reg = rpcProviderService.registerRpcImplementation(FrmReconciliationService.class, reconcliationService,
+ ImmutableSet.of(path));
+ } else {
+ LOG.debug("The path is already registered : {}", path);
+ }
}
public void deregisterReconciliationRpc() {
- LOG.debug("The path is unregistered : {}", path);
- routedRpcReg.unregisterPath(NodeContext.class, path);
+ if (reg != null) {
+ reg.close();
+ reg = null;
+ LOG.debug("The path is unregistered : {}", path);
+ } else {
+ LOG.debug("The path is already unregistered : {}", path);
+ }
}
}
-/**
+/*
* Copyright (c) 2016, 2017 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.applications.frm.impl;
import com.google.common.annotations.VisibleForTesting;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
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;
-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.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeRegistration;
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.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.frm.reconciliation.service.rev180227.FrmReconciliationService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
private final ClusterSingletonServiceProvider clusterSingletonService;
private final FlowNodeReconciliation reconcliationAgent;
private final DataBroker dataBroker;
- private final ConcurrentHashMap<NodeId, DeviceMastership> deviceMasterships = new ConcurrentHashMap();
+ private final ConcurrentHashMap<NodeId, DeviceMastership> deviceMasterships = new ConcurrentHashMap<>();
private final Object lockObj = new Object();
+ private final RpcProviderService rpcProviderService;
+ private final FrmReconciliationService reconcliationService;
+
private ListenerRegistration<DeviceMastershipManager> listenerRegistration;
private Set<InstanceIdentifier<FlowCapableNode>> activeNodes = Collections.emptySet();
- private RoutedRpcRegistration routedRpcReg;
private MastershipChangeRegistration mastershipChangeServiceRegistration;
public DeviceMastershipManager(final ClusterSingletonServiceProvider clusterSingletonService,
final FlowNodeReconciliation reconcliationAgent,
final DataBroker dataBroker,
- final MastershipChangeServiceManager mastershipChangeServiceManager) {
+ final MastershipChangeServiceManager mastershipChangeServiceManager,
+ final RpcProviderService rpcProviderService,
+ final FrmReconciliationService reconciliationService) {
this.clusterSingletonService = clusterSingletonService;
this.reconcliationAgent = reconcliationAgent;
+ this.rpcProviderService = rpcProviderService;
+ this.reconcliationService = reconciliationService;
this.dataBroker = dataBroker;
registerNodeListener();
this.mastershipChangeServiceRegistration = mastershipChangeServiceManager.register(this);
}
@Override
- public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<FlowCapableNode>> changes) {
+ public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<FlowCapableNode>> changes) {
Preconditions.checkNotNull(changes, "Changes may not be null!");
for (DataTreeModification<FlowCapableNode> change : changes) {
}
}
- public void remove(InstanceIdentifier<FlowCapableNode> identifier, FlowCapableNode del,
- InstanceIdentifier<FlowCapableNode> nodeIdent) {
+ public void remove(final InstanceIdentifier<FlowCapableNode> identifier, final FlowCapableNode del,
+ final InstanceIdentifier<FlowCapableNode> nodeIdent) {
if (compareInstanceIdentifierTail(identifier, II_TO_FLOW_CAPABLE_NODE)) {
if (LOG.isDebugEnabled()) {
LOG.debug("Node removed: {}", nodeIdent.firstKeyOf(Node.class).getId().getValue());
}
}
- public void add(InstanceIdentifier<FlowCapableNode> identifier, FlowCapableNode add,
- InstanceIdentifier<FlowCapableNode> nodeIdent) {
+ public void add(final InstanceIdentifier<FlowCapableNode> identifier, final FlowCapableNode add,
+ final InstanceIdentifier<FlowCapableNode> nodeIdent) {
if (compareInstanceIdentifierTail(identifier, II_TO_FLOW_CAPABLE_NODE)) {
if (LOG.isDebugEnabled()) {
LOG.debug("Node added: {}", nodeIdent.firstKeyOf(Node.class).getId().getValue());
}
}
- private boolean compareInstanceIdentifierTail(InstanceIdentifier<?> identifier1,
- InstanceIdentifier<?> identifier2) {
+ private boolean compareInstanceIdentifierTail(final InstanceIdentifier<?> identifier1,
+ final InstanceIdentifier<?> identifier2) {
return Iterables.getLast(identifier1.getPathArguments())
.equals(Iterables.getLast(identifier2.getPathArguments()));
}
- private void setNodeOperationalStatus(InstanceIdentifier<FlowCapableNode> nodeIid, boolean status) {
+ private void setNodeOperationalStatus(final InstanceIdentifier<FlowCapableNode> nodeIid, final boolean status) {
NodeId nodeId = nodeIid.firstKeyOf(Node.class).getId();
if (nodeId != null && deviceMasterships.containsKey(nodeId)) {
deviceMasterships.get(nodeId).setDeviceOperationalStatus(status);
}
}
- public void setRoutedRpcReg(RoutedRpcRegistration routedRpcReg) {
- this.routedRpcReg = routedRpcReg;
- }
-
@SuppressWarnings("IllegalCatch")
private void registerNodeListener() {
final InstanceIdentifier<FlowCapableNode> flowNodeWildCardIdentifier = InstanceIdentifier.create(Nodes.class)
.child(Node.class).augmentation(FlowCapableNode.class);
- final DataTreeIdentifier<FlowCapableNode> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ final DataTreeIdentifier<FlowCapableNode> treeId = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
flowNodeWildCardIdentifier);
try {
public void onBecomeOwner(@Nonnull final DeviceInfo deviceInfo) {
LOG.debug("Mastership role notification received for device : {}", deviceInfo.getDatapathId());
DeviceMastership membership = deviceMasterships.computeIfAbsent(deviceInfo.getNodeId(),
- device -> new DeviceMastership(deviceInfo.getNodeId(), routedRpcReg));
+ device -> new DeviceMastership(deviceInfo.getNodeId()));
membership.reconcile();
- membership.registerReconciliationRpc();
+ membership.registerReconciliationRpc(rpcProviderService, reconcliationService);
}
@Override
- public void onLoseOwnership(@Nonnull DeviceInfo deviceInfo) {
+ public void onLoseOwnership(@Nonnull final DeviceInfo deviceInfo) {
final DeviceMastership mastership = deviceMasterships.remove(deviceInfo.getNodeId());
if (mastership != null) {
mastership.deregisterReconciliationRpc();
-/**
+/*
* Copyright (c) 2014, 2017 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import static org.opendaylight.openflowplugin.applications.frm.util.FrmUtil.isFlowDependentOnGroup;
import static org.opendaylight.openflowplugin.applications.frm.util.FrmUtil.isGroupExistsOnDevice;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.FluentFuture;
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.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
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.FlowCapableNode;
/**
* FlowForwarder It implements
- * {@link org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener}
+ * {@link org.opendaylight.mdsal.binding.api.DataTreeChangeListener}
* for WildCardedPath to {@link Flow} and ForwardingRulesCommiter interface for
* methods: add, update and remove {@link Flow} processing for
- * {@link org.opendaylight.controller.md.sal.binding.api.DataTreeModification}.
+ * {@link org.opendaylight.mdsal.binding.api.DataTreeModification}.
*/
public class FlowForwarder extends AbstractListeningCommiter<Flow> {
@Override
@SuppressWarnings("IllegalCatch")
public void registerListener() {
- final DataTreeIdentifier<Flow> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ final DataTreeIdentifier<Flow> treeId = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
getWildCardPath());
try {
listenerRegistration = dataBroker.registerDataTreeChangeListener(treeId, FlowForwarder.this);
writeTransaction.put(LogicalDatastoreType.CONFIGURATION, getStaleFlowInstanceIdentifier(staleFlow, nodeIdent),
staleFlow, false);
- ListenableFuture<Void> submitFuture = writeTransaction.submit();
+ FluentFuture<?> submitFuture = writeTransaction.commit();
handleStaleFlowResultFuture(submitFuture);
}
- private void handleStaleFlowResultFuture(ListenableFuture<Void> submitFuture) {
- Futures.addCallback(submitFuture, new FutureCallback<Void>() {
+ private void handleStaleFlowResultFuture(FluentFuture<?> submitFuture) {
+ submitFuture.addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void result) {
+ public void onSuccess(Object result) {
LOG.debug("Stale Flow creation success");
}
InstanceIdentifier<Group> groupIdent = buildGroupInstanceIdentifier(nodeIdent, groupId);
ListenableFuture<RpcResult<AddGroupOutput>> resultFuture;
LOG.info("Reading the group from config inventory: {}", groupId);
- try (ReadOnlyTransaction readTransaction = provider.getReadTransaction()) {
+ try (ReadTransaction readTransaction = provider.getReadTransaction()) {
Optional<Group> group = readTransaction.read(LogicalDatastoreType.CONFIGURATION, groupIdent).get();
if (group.isPresent()) {
final AddGroupInputBuilder builder = new AddGroupInputBuilder(group.get());
-/**
+/*
* Copyright (c) 2015, 2017 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.applications.frm.impl;
import com.google.common.base.Preconditions;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multimaps;
import java.math.BigInteger;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frm.FlowNodeConnectorInventoryTranslator;
import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
Preconditions.checkNotNull(dataBroker, "DataBroker can not be null!");
final DataTreeIdentifier<FlowCapableNodeConnector> treeId =
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, getWildCardPath());
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, getWildCardPath());
try {
SimpleTaskRetryLooper looper = new SimpleTaskRetryLooper(ForwardingRulesManagerImpl.STARTUP_LOOP_TICK,
ForwardingRulesManagerImpl.STARTUP_LOOP_MAX_RETRIES);
-/**
+/*
* Copyright (c) 2014, 2017 Cisco Systems, Inc. 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.applications.frm.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.JdkFutureAdapters;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicLong;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.applications.frm.FlowNodeReconciliation;
@Override
public Boolean call() {
String node = nodeIdentity.firstKeyOf(Node.class).getId().getValue();
- Optional<FlowCapableNode> flowNode = Optional.absent();
+ Optional<FlowCapableNode> flowNode = Optional.empty();
BundleId bundleIdValue = new BundleId(BUNDLE_ID.getAndIncrement());
BigInteger dpnId = getDpnIdFromNodeName(node);
LOG.info("Triggering bundle based reconciliation for device : {}", dpnId);
- try (ReadOnlyTransaction trans = provider.getReadTransaction()) {
+ try (ReadTransaction trans = provider.getReadTransaction()) {
flowNode = trans.read(LogicalDatastoreType.CONFIGURATION, nodeIdentity).get();
} catch (ExecutionException | InterruptedException e) {
LOG.error("Error occurred while reading the configuration data store for node {}", nodeIdentity, e);
Optional<FlowCapableNode> flowNode;
// initialize the counter
int counter = 0;
- try (ReadOnlyTransaction trans = provider.getReadTransaction()) {
+ try (ReadTransaction trans = provider.getReadTransaction()) {
flowNode = trans.read(LogicalDatastoreType.CONFIGURATION, nodeIdentity).get();
} catch (ExecutionException | InterruptedException e) {
LOG.warn("Fail with read Config/DS for Node {} !", nodeIdentity, e);
List<InstanceIdentifier<StaleGroup>> staleGroupsToBeBulkDeleted = Lists.newArrayList();
List<InstanceIdentifier<StaleMeter>> staleMetersToBeBulkDeleted = Lists.newArrayList();
- Optional<FlowCapableNode> flowNode = Optional.absent();
+ Optional<FlowCapableNode> flowNode = Optional.empty();
- try (ReadOnlyTransaction trans = provider.getReadTransaction()) {
+ try (ReadTransaction trans = provider.getReadTransaction()) {
flowNode = trans.read(LogicalDatastoreType.CONFIGURATION, nodeIdent).get();
} catch (ExecutionException | InterruptedException e) {
LOG.warn("Reconciliation Pre-Processing Fail with read Config/DS for Node {} !", nodeIdent, e);
writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, staleFlowIId);
}
- ListenableFuture<Void> submitFuture = writeTransaction.submit();
+ FluentFuture<?> submitFuture = writeTransaction.commit();
handleStaleEntityDeletionResultFuture(submitFuture);
}
writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, staleGroupIId);
}
- ListenableFuture<Void> submitFuture = writeTransaction.submit();
+ FluentFuture<?> submitFuture = writeTransaction.commit();
handleStaleEntityDeletionResultFuture(submitFuture);
}
writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, staleMeterIId);
}
- ListenableFuture<Void> submitFuture = writeTransaction.submit();
+ FluentFuture<?> submitFuture = writeTransaction.commit();
handleStaleEntityDeletionResultFuture(submitFuture);
}
return nodeIdent.child(StaleMeter.class, new StaleMeterKey(new MeterId(staleMeter.getMeterId())));
}
- private void handleStaleEntityDeletionResultFuture(ListenableFuture<Void> submitFuture) {
- Futures.addCallback(submitFuture, new FutureCallback<Void>() {
+ private void handleStaleEntityDeletionResultFuture(FluentFuture<?> submitFuture) {
+ submitFuture.addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void result) {
+ public void onSuccess(Object result) {
LOG.debug("Stale entity removal success");
}
-/**
+/*
* Copyright (c) 2014, 2017 Cisco Systems, Inc. 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.applications.frm.impl;
import com.google.common.annotations.VisibleForTesting;
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;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationService;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.SalBundleService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.arbitrator.reconcile.service.rev180227.ArbitratorReconcileService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.forwardingrules.manager.config.rev160511.ForwardingRulesManagerConfig;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.frm.reconciliation.service.rev180227.FrmReconciliationService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.rf.state.rev170713.ResultState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.SalTableService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeatures;
private final SalBundleService salBundleService;
private final AutoCloseable configurationServiceRegistration;
private final MastershipChangeServiceManager mastershipChangeServiceManager;
- private final RpcProviderRegistry rpcRegistry;
+ private final RpcProviderService rpcProviderService;
private ForwardingRulesCommiter<Flow> flowListener;
private ForwardingRulesCommiter<Group> groupListener;
private ForwardingRulesCommiter<Meter> meterListener;
private final ReconciliationManager reconciliationManager;
private DevicesGroupRegistry devicesGroupRegistry;
private NodeConfigurator nodeConfigurator;
- private ArbitratorReconcileService arbitratorReconciliationManager;
+ private final ArbitratorReconcileService arbitratorReconciliationManager;
private boolean disableReconciliation;
private boolean staleMarkingEnabled;
private int reconciliationRetryCount;
@Inject
public ForwardingRulesManagerImpl(@Reference final DataBroker dataBroker,
- @Reference final RpcProviderRegistry rpcRegistry,
+ @Reference final RpcConsumerRegistry rpcRegistry,
+ @Reference final RpcProviderService rpcProviderService,
final ForwardingRulesManagerConfig config,
@Reference final MastershipChangeServiceManager mastershipChangeServiceManager,
@Reference final ClusterSingletonServiceProvider clusterSingletonService,
this.clusterSingletonServiceProvider = Preconditions.checkNotNull(clusterSingletonService,
"ClusterSingletonService provider can not be null");
this.reconciliationManager = reconciliationManager;
- this.rpcRegistry = rpcRegistry;
+ this.rpcProviderService = rpcProviderService;
this.mastershipChangeServiceManager = mastershipChangeServiceManager;
Preconditions.checkArgument(rpcRegistry != null, "RpcProviderRegistry can not be null !");
LOG.debug("Reconciliation is enabled by user and successfully registered to the reconciliation framework");
}
this.deviceMastershipManager = new DeviceMastershipManager(clusterSingletonServiceProvider, this.nodeListener,
- dataService, mastershipChangeServiceManager);
- this.deviceMastershipManager.setRoutedRpcReg(rpcRegistry.addRoutedRpcImplementation(
- FrmReconciliationService.class, new FrmReconciliationServiceImpl(this)));
+ dataService, mastershipChangeServiceManager, rpcProviderService,
+ new FrmReconciliationServiceImpl(this));
flowNodeConnectorInventoryTranslatorImpl = new FlowNodeConnectorInventoryTranslatorImpl(dataService);
this.flowListener = new FlowForwarder(this, dataService);
}
@Override
- public ReadOnlyTransaction getReadTransaction() {
+ public ReadTransaction getReadTransaction() {
return dataService.newReadOnlyTransaction();
}
}
@Override
- public boolean isNodeActive(InstanceIdentifier<FlowCapableNode> ident) {
+ public boolean isNodeActive(final InstanceIdentifier<FlowCapableNode> ident) {
return deviceMastershipManager.isNodeActive(ident.firstKeyOf(Node.class).getId());
}
@Override
- public boolean checkNodeInOperationalDataStore(InstanceIdentifier<FlowCapableNode> ident) {
+ public boolean checkNodeInOperationalDataStore(final InstanceIdentifier<FlowCapableNode> ident) {
boolean result = false;
InstanceIdentifier<Node> nodeIid = ident.firstIdentifierOf(Node.class);
- try (ReadOnlyTransaction transaction = dataService.newReadOnlyTransaction()) {
- ListenableFuture<com.google.common.base.Optional<Node>> future = transaction
+ try (ReadTransaction transaction = dataService.newReadOnlyTransaction()) {
+ ListenableFuture<Optional<Node>> future = transaction
.read(LogicalDatastoreType.OPERATIONAL, nodeIid);
- com.google.common.base.Optional<Node> optionalDataObject = future.get();
+ Optional<Node> optionalDataObject = future.get();
if (optionalDataObject.isPresent()) {
result = true;
} else {
}
@Override
- public void addRecoverableListener(RecoverableListener recoverableListener) {
+ public void addRecoverableListener(final RecoverableListener recoverableListener) {
serviceRecoveryRegistry.addRecoverableListener(openflowServiceRecoveryHandler.buildServiceRegistryKey(),
recoverableListener);
}
}
@Override
- public boolean isNodeOwner(InstanceIdentifier<FlowCapableNode> ident) {
+ public boolean isNodeOwner(final InstanceIdentifier<FlowCapableNode> ident) {
return Objects.nonNull(ident) && deviceMastershipManager.isDeviceMastered(ident.firstKeyOf(Node.class).getId());
}
-/**
+/*
* Copyright (c) 2014, 2017 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import static org.opendaylight.openflowplugin.applications.frm.util.FrmUtil.getActiveBundle;
import static org.opendaylight.openflowplugin.applications.frm.util.FrmUtil.getNodeIdFromNodeIdentifier;
+import com.google.common.util.concurrent.FluentFuture;
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.MoreExecutors;
import java.util.concurrent.Future;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
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.FlowCapableNode;
/**
* GroupForwarder It implements
- * {@link org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener}
+ * {@link org.opendaylight.mdsal.binding.api.DataTreeChangeListener}
* for WildCardedPath to {@link Group} and ForwardingRulesCommiter interface for
* methods: add, update and remove {@link Group} processing for
- * {@link org.opendaylight.controller.md.sal.binding.api.DataTreeModification}.
+ * {@link org.opendaylight.mdsal.binding.api.DataTreeModification}.
*/
public class GroupForwarder extends AbstractListeningCommiter<Group> {
@SuppressWarnings("IllegalCatch")
@Override
public void registerListener() {
- final DataTreeIdentifier<Group> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ final DataTreeIdentifier<Group> treeId = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
getWildCardPath());
try {
writeTransaction.put(LogicalDatastoreType.CONFIGURATION, getStaleGroupInstanceIdentifier(staleGroup, nodeIdent),
staleGroup, false);
- ListenableFuture<Void> submitFuture = writeTransaction.submit();
+ FluentFuture<?> submitFuture = writeTransaction.commit();
handleStaleGroupResultFuture(submitFuture);
}
- private void handleStaleGroupResultFuture(ListenableFuture<Void> submitFuture) {
- Futures.addCallback(submitFuture, new FutureCallback<Void>() {
+ private void handleStaleGroupResultFuture(FluentFuture<?> submitFuture) {
+ submitFuture.addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void result) {
+ public void onSuccess(Object result) {
LOG.debug("Stale Group creation success");
}
-/**
+/*
* Copyright (c) 2014, 2017 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.applications.frm.impl;
+import com.google.common.util.concurrent.FluentFuture;
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.MoreExecutors;
import java.util.concurrent.Future;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
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.FlowCapableNode;
/**
* MeterForwarder It implements
- * {@link org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener}
+ * {@link org.opendaylight.mdsal.binding.api.DataTreeChangeListener}
* for WildCardedPath to {@link Meter} and ForwardingRulesCommiter interface for
* methods: add, update and remove {@link Meter} processing for
- * {@link org.opendaylight.controller.md.sal.binding.api.DataTreeModification}.
+ * {@link org.opendaylight.mdsal.binding.api.DataTreeModification}.
*
*/
public class MeterForwarder extends AbstractListeningCommiter<Meter> {
@SuppressWarnings("IllegalCatch")
@Override
public void registerListener() {
- final DataTreeIdentifier<Meter> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ final DataTreeIdentifier<Meter> treeId = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
getWildCardPath());
try {
writeTransaction.put(LogicalDatastoreType.CONFIGURATION, getStaleMeterInstanceIdentifier(staleMeter, nodeIdent),
staleMeter, false);
- ListenableFuture<Void> submitFuture = writeTransaction.submit();
+ FluentFuture<?> submitFuture = writeTransaction.commit();
handleStaleMeterResultFuture(submitFuture);
}
- private void handleStaleMeterResultFuture(ListenableFuture<Void> submitFuture) {
- Futures.addCallback(submitFuture, new FutureCallback<Void>() {
+ private void handleStaleMeterResultFuture(FluentFuture<?> submitFuture) {
+ submitFuture.addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void result) {
+ public void onSuccess(Object result) {
LOG.debug("Stale Meter creation success");
}
* 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.frm.impl;
import com.google.common.util.concurrent.Futures;
import java.util.Collections;
import java.util.concurrent.Future;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
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.FlowCapableNode;
@SuppressWarnings("IllegalCatch")
@Override
public void registerListener() {
- final DataTreeIdentifier<TableFeatures> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ final DataTreeIdentifier<TableFeatures> treeId = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
getWildCardPath());
try {
-/**
+/*
* Copyright (c) 2016, 2017 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.applications.frm.impl;
import org.junit.Assert;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager;
import org.opendaylight.openflowplugin.applications.frm.FlowNodeReconciliation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.frm.reconciliation.service.rev180227.FrmReconciliationService;
/**
* Test for {@link DeviceMastershipManager}.
@Mock
private DataBroker dataBroker;
@Mock
- private RoutedRpcRegistration routedRpcReg;
- @Mock
private MastershipChangeServiceManager mastershipChangeServiceManager;
@Mock
private DeviceInfo deviceInfo;
@Mock
private NodeId nodeId;
+ @Mock
+ private RpcProviderService rpcProviderService;
+ @Mock
+ private FrmReconciliationService reconciliationService;
@Before
public void setUp() throws Exception {
deviceMastershipManager = new DeviceMastershipManager(clusterSingletonService, reconciliationAgent, dataBroker,
- mastershipChangeServiceManager);
- deviceMastershipManager.setRoutedRpcReg(routedRpcReg);
+ mastershipChangeServiceManager, rpcProviderService, reconciliationService);
Mockito.lenient().when(clusterSingletonService
.registerClusterSingletonService(ArgumentMatchers.<ClusterSingletonService>any()))
.thenReturn(registration);
-/**
+/*
* Copyright (c) 2016, 2017 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.applications.frm.impl;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
/**
public class DeviceMastershipTest {
private static final NodeId NODE_ID = new NodeId("testNode");
private DeviceMastership deviceMastership;
- @Mock
- private RoutedRpcRegistration routedRpcRegistration;
@Before
public void setUp() throws Exception {
- deviceMastership = new DeviceMastership(NODE_ID, routedRpcRegistration);
+ deviceMastership = new DeviceMastership(NODE_ID);
}
@Test
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import java.util.Collections;
import java.util.List;
-
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager;
import org.opendaylight.openflowplugin.applications.frm.impl.DeviceMastershipManager;
private ForwardingRulesManagerImpl forwardingRulesManager;
private static final NodeId NODE_ID = new NodeId("testnode:1");
private static final NodeKey NODE_KEY = new NodeKey(NODE_ID);
- RpcProviderRegistry rpcProviderRegistryMock = new RpcProviderRegistryMock();
+ RpcProviderRegistryMock rpcProviderRegistryMock = new RpcProviderRegistryMock();
TableKey tableKey = new TableKey((short) 2);
@Mock
ClusterSingletonServiceProvider clusterSingletonService;
@Before
public void setUp() {
- forwardingRulesManager = new ForwardingRulesManagerImpl(getDataBroker(), rpcProviderRegistryMock, getConfig(),
- mastershipChangeServiceManager, clusterSingletonService, getConfigurationService(),
- reconciliationManager, openflowServiceRecoveryHandler, serviceRecoveryRegistry);
+ forwardingRulesManager = new ForwardingRulesManagerImpl(getDataBroker(), rpcProviderRegistryMock,
+ rpcProviderRegistryMock, getConfig(), mastershipChangeServiceManager, clusterSingletonService,
+ getConfigurationService(), reconciliationManager, openflowServiceRecoveryHandler,
+ serviceRecoveryRegistry);
forwardingRulesManager.start();
// TODO consider tests rewrite (added because of complicated access)
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, tableII, table);
writeTx.put(LogicalDatastoreType.CONFIGURATION, flowII, flow);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
SalFlowServiceMock salFlowService = (SalFlowServiceMock) forwardingRulesManager.getSalFlowService();
await().until(listSize(salFlowService.getAddFlowCalls()), equalTo(1));
List<AddFlowInput> addFlowCalls = salFlowService.getAddFlowCalls();
flow = new FlowBuilder().withKey(flowKey).setTableId((short) 2).build();
writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, flowII, flow);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
salFlowService = (SalFlowServiceMock) forwardingRulesManager.getSalFlowService();
await().until(listSize(salFlowService.getAddFlowCalls()), equalTo(2));
addFlowCalls = salFlowService.getAddFlowCalls();
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, tableII, table);
writeTx.put(LogicalDatastoreType.CONFIGURATION, flowII, flow);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
SalFlowServiceMock salFlowService = (SalFlowServiceMock) forwardingRulesManager.getSalFlowService();
await().until(listSize(salFlowService.getAddFlowCalls()), equalTo(1));
flow = new FlowBuilder().withKey(flowKey).setTableId((short) 2).setOutGroup((long) 5).build();
writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, flowII, flow);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
salFlowService = (SalFlowServiceMock) forwardingRulesManager.getSalFlowService();
await().until(listSize(salFlowService.getUpdateFlowCalls()), equalTo(1));
List<UpdateFlowInput> updateFlowCalls = salFlowService.getUpdateFlowCalls();
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, tableII, table);
writeTx.put(LogicalDatastoreType.CONFIGURATION, flowII, flow);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
SalFlowServiceMock salFlowService = (SalFlowServiceMock) forwardingRulesManager.getSalFlowService();
await().until(listSize(salFlowService.getAddFlowCalls()), equalTo(1));
List<AddFlowInput> addFlowCalls = salFlowService.getAddFlowCalls();
flow = new FlowBuilder().setMatch(match).withKey(flowKey).setTableId((short) 2).build();
writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, flowII, flow);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
salFlowService = (SalFlowServiceMock) forwardingRulesManager.getSalFlowService();
await().until(listSize(salFlowService.getUpdateFlowCalls()), equalTo(1));
List<UpdateFlowInput> updateFlowCalls = salFlowService.getUpdateFlowCalls();
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, tableII, table);
writeTx.put(LogicalDatastoreType.CONFIGURATION, flowII, flow);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
SalFlowServiceMock salFlowService = (SalFlowServiceMock) forwardingRulesManager.getSalFlowService();
await().until(listSize(salFlowService.getAddFlowCalls()), equalTo(1));
List<AddFlowInput> addFlowCalls = salFlowService.getAddFlowCalls();
writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.delete(LogicalDatastoreType.CONFIGURATION, flowII);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
salFlowService = (SalFlowServiceMock) forwardingRulesManager.getSalFlowService();
await().until(listSize(salFlowService.getRemoveFlowCalls()), equalTo(1));
List<RemoveFlowInput> removeFlowCalls = salFlowService.getRemoveFlowCalls();
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, tableII, table);
writeTx.put(LogicalDatastoreType.CONFIGURATION, flowII, flow);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
}
@After
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager;
import org.opendaylight.openflowplugin.applications.frm.impl.DeviceMastershipManager;
private ForwardingRulesManagerImpl forwardingRulesManager;
private static final NodeId NODE_ID = new NodeId("testnode:1");
private static final NodeKey NODE_KEY = new NodeKey(NODE_ID);
- RpcProviderRegistry rpcProviderRegistryMock = new RpcProviderRegistryMock();
+ RpcProviderRegistryMock rpcProviderRegistryMock = new RpcProviderRegistryMock();
@Mock
ClusterSingletonServiceProvider clusterSingletonService;
@Mock
forwardingRulesManager = new ForwardingRulesManagerImpl(
getDataBroker(),
rpcProviderRegistryMock,
+ rpcProviderRegistryMock,
getConfig(),
mastershipChangeServiceManager,
clusterSingletonService,
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, groupII, group);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
SalGroupServiceMock salGroupService = (SalGroupServiceMock) forwardingRulesManager.getSalGroupService();
await().until(listSize(salGroupService.getAddGroupCalls()), equalTo(1));
List<AddGroupInput> addGroupCalls = salGroupService.getAddGroupCalls();
group = new GroupBuilder().withKey(groupKey).setGroupName("Group1").build();
writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, groupII, group);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
salGroupService = (SalGroupServiceMock) forwardingRulesManager.getSalGroupService();
await().until(listSize(salGroupService.getAddGroupCalls()), equalTo(2));
addGroupCalls = salGroupService.getAddGroupCalls();
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, groupII, group);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
SalGroupServiceMock salGroupService = (SalGroupServiceMock) forwardingRulesManager.getSalGroupService();
await().until(listSize(salGroupService.getAddGroupCalls()), equalTo(1));
List<AddGroupInput> addGroupCalls = salGroupService.getAddGroupCalls();
group = new GroupBuilder().withKey(groupKey).setGroupName("Group2").build();
writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, groupII, group);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
salGroupService = (SalGroupServiceMock) forwardingRulesManager.getSalGroupService();
await().until(listSize(salGroupService.getUpdateGroupCalls()), equalTo(1));
List<UpdateGroupInput> updateGroupCalls = salGroupService.getUpdateGroupCalls();
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, groupII, group);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
SalGroupServiceMock salGroupService = (SalGroupServiceMock) forwardingRulesManager.getSalGroupService();
await().until(listSize(salGroupService.getAddGroupCalls()), equalTo(1));
List<AddGroupInput> addGroupCalls = salGroupService.getAddGroupCalls();
writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.delete(LogicalDatastoreType.CONFIGURATION, groupII);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
salGroupService = (SalGroupServiceMock) forwardingRulesManager.getSalGroupService();
await().until(listSize(salGroupService.getRemoveGroupCalls()), equalTo(1));
List<RemoveGroupInput> removeGroupCalls = salGroupService.getRemoveGroupCalls();
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, groupII, group);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
}
@After
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager;
import org.opendaylight.openflowplugin.applications.frm.impl.DeviceMastershipManager;
private ForwardingRulesManagerImpl forwardingRulesManager;
private static final NodeId NODE_ID = new NodeId("testnode:1");
private static final NodeKey NODE_KEY = new NodeKey(NODE_ID);
- RpcProviderRegistry rpcProviderRegistryMock = new RpcProviderRegistryMock();
+ RpcProviderRegistryMock rpcProviderRegistryMock = new RpcProviderRegistryMock();
@Mock
ClusterSingletonServiceProvider clusterSingletonService;
@Mock
forwardingRulesManager = new ForwardingRulesManagerImpl(
getDataBroker(),
rpcProviderRegistryMock,
+ rpcProviderRegistryMock,
getConfig(),
mastershipChangeServiceManager,
clusterSingletonService,
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
SalMeterServiceMock salMeterService = (SalMeterServiceMock) forwardingRulesManager.getSalMeterService();
List<AddMeterInput> addMeterCalls = salMeterService.getAddMeterCalls();
assertEquals(1, addMeterCalls.size());
meter = new MeterBuilder().withKey(meterKey).setMeterName("meter_two").setBarrier(true).build();
writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
salMeterService = (SalMeterServiceMock) forwardingRulesManager.getSalMeterService();
addMeterCalls = salMeterService.getAddMeterCalls();
assertEquals(2, addMeterCalls.size());
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
SalMeterServiceMock salMeterService = (SalMeterServiceMock) forwardingRulesManager.getSalMeterService();
List<AddMeterInput> addMeterCalls = salMeterService.getAddMeterCalls();
assertEquals(1, addMeterCalls.size());
meter = new MeterBuilder().withKey(meterKey).setMeterName("meter_two").setBarrier(true).build();
writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
salMeterService = (SalMeterServiceMock) forwardingRulesManager.getSalMeterService();
List<UpdateMeterInput> updateMeterCalls = salMeterService.getUpdateMeterCalls();
assertEquals(1, updateMeterCalls.size());
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
SalMeterServiceMock salMeterService = (SalMeterServiceMock) forwardingRulesManager.getSalMeterService();
List<AddMeterInput> addMeterCalls = salMeterService.getAddMeterCalls();
assertEquals(1, addMeterCalls.size());
writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.delete(LogicalDatastoreType.CONFIGURATION, meterII);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
salMeterService = (SalMeterServiceMock) forwardingRulesManager.getSalMeterService();
List<RemoveMeterInput> removeMeterCalls = salMeterService.getRemoveMeterCalls();
assertEquals(1, removeMeterCalls.size());
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
}
@After
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager;
import org.opendaylight.openflowplugin.applications.frm.impl.ForwardingRulesManagerImpl;
public class NodeListenerTest extends FRMTest {
private ForwardingRulesManagerImpl forwardingRulesManager;
private static final NodeKey NODE_KEY = new NodeKey(new NodeId("testnode:1"));
- RpcProviderRegistry rpcProviderRegistryMock = new RpcProviderRegistryMock();
+ RpcProviderRegistryMock rpcProviderRegistryMock = new RpcProviderRegistryMock();
@Mock
ClusterSingletonServiceProvider clusterSingletonService;
@Mock
forwardingRulesManager = new ForwardingRulesManagerImpl(
getDataBroker(),
rpcProviderRegistryMock,
+ rpcProviderRegistryMock,
getConfig(),
mastershipChangeServiceManager,
clusterSingletonService,
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager;
import org.opendaylight.openflowplugin.applications.frm.impl.DeviceMastershipManager;
private ForwardingRulesManagerImpl forwardingRulesManager;
private static final NodeId NODE_ID = new NodeId("testnode:1");
private static final NodeKey NODE_KEY = new NodeKey(NODE_ID);
- RpcProviderRegistry rpcProviderRegistryMock = new RpcProviderRegistryMock();
+ RpcProviderRegistryMock rpcProviderRegistryMock = new RpcProviderRegistryMock();
@Mock
ClusterSingletonServiceProvider clusterSingletonService;
@Mock
@Before
public void setUp() {
- forwardingRulesManager = new ForwardingRulesManagerImpl(getDataBroker(), rpcProviderRegistryMock, getConfig(),
- mastershipChangeServiceManager, clusterSingletonService, getConfigurationService(),
- reconciliationManager, openflowServiceRecoveryHandler, serviceRecoveryRegistry);
+ forwardingRulesManager = new ForwardingRulesManagerImpl(getDataBroker(), rpcProviderRegistryMock,
+ rpcProviderRegistryMock, getConfig(), mastershipChangeServiceManager, clusterSingletonService,
+ getConfigurationService(), reconciliationManager, openflowServiceRecoveryHandler,
+ serviceRecoveryRegistry);
forwardingRulesManager.start();
// TODO consider tests rewrite (added because of complicated access)
.child(TableFeatures.class, tableFeaturesKey);
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, tableFeaturesII, tableFeaturesData);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
tableFeaturesData = new TableFeaturesBuilder().withKey(tableFeaturesKey).setName("dummy name").build();
writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, tableFeaturesII, tableFeaturesData);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
SalTableServiceMock salTableServiceMock = (SalTableServiceMock) forwardingRulesManager.getSalTableService();
List<UpdateTableInput> updateTableInputs = salTableServiceMock.getUpdateTableInput();
*/
package test.mock.util;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTest;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeBuilder;
writeTx.put(LogicalDatastoreType.OPERATIONAL, flowNodeIdentifier, nodeBuilder.build());
writeTx.put(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Nodes.class), nodes);
writeTx.put(LogicalDatastoreType.CONFIGURATION, flowNodeIdentifier, nodeBuilder.build());
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
+ }
+
+ // TODO: remove with mdsal-3.0.7 or later
+ @SuppressWarnings("unchecked")
+ protected static final void assertCommit(FluentFuture<?> future) {
+ assertCommit((ListenableFuture<Void>) future);
}
public void removeNode(NodeKey nodeKey) throws ExecutionException, InterruptedException {
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.delete(LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.create(Nodes.class).child(Node.class, nodeKey));
- writeTx.submit().get();
+ writeTx.commit().get();
}
public void addTable(final TableKey tableKey, final NodeKey nodeKey) {
InstanceIdentifier<Table> tableII = InstanceIdentifier.create(Nodes.class).child(Node.class, nodeKey)
.augmentation(FlowCapableNode.class).child(Table.class, tableKey);
writeTx.put(LogicalDatastoreType.CONFIGURATION, tableII, table);
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
}
public ForwardingRulesManagerConfig getConfig() {
*/
package test.mock.util;
-import org.opendaylight.controller.md.sal.common.api.routing.RouteChangeListener;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.controller.sal.binding.api.rpc.RpcContextIdentifier;
+import java.util.Set;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.SalGroupService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.SalMeterService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.SalBundleService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.arbitrator.reconcile.service.rev180227.ArbitratorReconcileService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.SalTableService;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcService;
-public class RpcProviderRegistryMock implements RpcProviderRegistry {
+public class RpcProviderRegistryMock implements RpcConsumerRegistry, RpcProviderService {
@Override
- public <T extends RpcService> BindingAwareBroker.RpcRegistration<T> addRpcImplementation(Class<T> serviceInterface,
- T implementation) throws IllegalStateException {
+ public <S extends RpcService, T extends S> ObjectRegistration<T> registerRpcImplementation(Class<S> type,
+ T implementation) {
return null;
}
@Override
- public <T extends RpcService> BindingAwareBroker.RoutedRpcRegistration<T> addRoutedRpcImplementation(
- Class<T> serviceInterface, T implementation) throws IllegalStateException {
- return null;
- }
-
- @Override
- public <L extends RouteChangeListener<RpcContextIdentifier,
- InstanceIdentifier<?>>> ListenerRegistration<L> registerRouteChangeListener(
- L listener) {
+ public <S extends RpcService, T extends S> ObjectRegistration<T> registerRpcImplementation(Class<S> type,
+ T implementation, Set<InstanceIdentifier<?>> paths) {
return null;
}
return null;
}
}
+
+
}
<dependencies>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
-
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<artifactId>concepts</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-util</artifactId>
- </dependency>
-
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-singleton-common-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
<type>test-jar</type>
</dependency>
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.yangtools.yang.binding.DataObject;
/**
* Unifying listener for data and event changes on node.
*/
public interface NodeListener<T extends DataObject> extends ClusteredDataTreeChangeListener<T> {
+
}
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.dao;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
this.odlDao = odlDao;
}
+ @Override
public Optional<FlowCapableNode> loadByNodeId(@Nonnull NodeId nodeId) {
final Optional<FlowCapableNode> node = snapshotDao.loadByNodeId(nodeId);
return odlDao.loadByNodeId(nodeId);
}
-
}
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.dao;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.dao;
-import com.google.common.base.Optional;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
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;
@Override
public Optional<FlowCapableNode> loadByNodeId(@Nonnull NodeId nodeId) {
- try (ReadOnlyTransaction roTx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction roTx = dataBroker.newReadOnlyTransaction()) {
final InstanceIdentifier<FlowCapableNode> path =
NODES_IID.child(Node.class, new NodeKey(nodeId)).augmentation(FlowCapableNode.class);
- return roTx.read(logicalDatastoreType, path).checkedGet(5000, TimeUnit.MILLISECONDS);
- } catch (ReadFailedException | TimeoutException e) {
+ return roTx.read(logicalDatastoreType, path).get(5000, TimeUnit.MILLISECONDS);
+ } catch (TimeoutException | InterruptedException | ExecutionException e) {
LOG.error("error reading {}", nodeId.getValue(), e);
}
- return Optional.absent();
+ return Optional.empty();
}
}
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.dao;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
}
}
+ @Override
public Optional<FlowCapableNode> loadByNodeId(@Nonnull NodeId nodeId) {
final FlowCapableNode node = cache.get(nodeId.getValue());
- return Optional.fromNullable(node);
+ return Optional.ofNullable(node);
}
-
}
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.impl;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frsync.NodeListener;
import org.opendaylight.openflowplugin.applications.frsync.util.PathUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.impl;
import com.google.common.base.Preconditions;
import java.util.Objects;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
-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.controller.sal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.openflowplugin.applications.frsync.NodeListener;
import org.opendaylight.openflowplugin.applications.frsync.SyncPlanPushStrategy;
this.flatBatchService = Preconditions.checkNotNull(rpcRegistry.getRpcService(SalFlatBatchService.class),
"RPC SalFlatBatchService not found.");
- nodeConfigDataTreePath = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ nodeConfigDataTreePath = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
FLOW_CAPABLE_NODE_WC_PATH);
- nodeOperationalDataTreePath = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, NODE_WC_PATH);
+ nodeOperationalDataTreePath = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, NODE_WC_PATH);
final ExecutorService executorService = Executors.newCachedThreadPool(new ThreadFactoryBuilder()
.setNameFormat(FRS_EXECUTOR_PREFIX + "%d")
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.impl;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
+import java.util.Optional;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frsync.SyncReactor;
import org.opendaylight.openflowplugin.applications.frsync.dao.FlowCapableNodeDao;
import org.opendaylight.openflowplugin.applications.frsync.dao.FlowCapableNodeSnapshotDao;
final InstanceIdentifier<FlowCapableNode> nodePath = modification.getRootPath().getRootIdentifier();
final NodeId nodeId = PathUtil.digNodeId(nodePath);
- configSnapshot.updateCache(nodeId, Optional.fromNullable(modification.getRootNode().getDataAfter()));
+ configSnapshot.updateCache(nodeId, Optional.ofNullable(modification.getRootNode().getDataAfter()));
final Optional<FlowCapableNode> operationalNode = operationalDao.loadByNodeId(nodeId);
if (!operationalNode.isPresent()) {
LOG.debug("Skip syncup, {} operational is not present", nodeId.getValue());
- return Optional.absent();
+ return Optional.empty();
}
final DataObjectModification<FlowCapableNode> configModification = modification.getRootNode();
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.impl;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frsync.SyncReactor;
import org.opendaylight.openflowplugin.applications.frsync.dao.FlowCapableNodeDao;
import org.opendaylight.openflowplugin.applications.frsync.dao.FlowCapableNodeSnapshotDao;
final DataObjectModification<Node> nodeModification = modification.getRootNode();
if (isDelete(nodeModification) || isDeleteLogical(nodeModification)) {
- operationalSnapshot.updateCache(nodeId, Optional.absent());
+ operationalSnapshot.updateCache(nodeId, Optional.empty());
deviceMastershipManager.onDeviceDisconnected(nodeId);
result = skipModification(modification);
} else {
- operationalSnapshot.updateCache(nodeId, Optional.fromNullable(
+ operationalSnapshot.updateCache(nodeId, Optional.ofNullable(
ModificationUtil.flowCapableNodeAfter(modification)));
final boolean isAdd = isAdd(nodeModification) || isAddLogical(nodeModification);
modification.getRootNode().getDataBefore() == null ? "null" : "nonnull",
modification.getRootNode().getDataAfter() == null ? "null" : "nonnull");
}
- return Optional.absent();
+ return Optional.empty();
}
private boolean isDelete(final DataObjectModification<Node> nodeModification) {
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.util;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
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.Node;
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.util;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
/**
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" odl:type="pingpong"/>
- <reference id="rpcRegistry" interface="org.opendaylight.controller.sal.binding.api.RpcProviderRegistry"/>
+ <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker" odl:type="pingpong"/>
+ <reference id="rpcRegistry" interface="org.opendaylight.mdsal.binding.api.RpcConsumerRegistry"/>
<reference id="clusterSingletonService" interface="org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider"/>
<bean id="frSync" class="org.opendaylight.openflowplugin.applications.frsync.impl.ForwardingRulesSyncProvider"
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.sal.binding.api.RpcConsumerRegistry;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.SalFlatBatchService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.impl;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import java.util.Collections;
+import java.util.Optional;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frsync.SyncReactor;
import org.opendaylight.openflowplugin.applications.frsync.dao.FlowCapableNodeCachedDao;
import org.opendaylight.openflowplugin.applications.frsync.dao.FlowCapableNodeDao;
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.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
@Mock
private SyncReactor reactor;
@Mock
- private ReadOnlyTransaction roTx;
+ private ReadTransaction roTx;
@Mock
private DataTreeModification<FlowCapableNode> dataTreeModification;
@Mock
.augmentation(FlowCapableNode.class);
final DataTreeIdentifier<FlowCapableNode> dataTreeIdentifier =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, fcNodePath);
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, fcNodePath);
Mockito.when(db.newReadOnlyTransaction()).thenReturn(roTx);
Mockito.when(dataTreeModification.getRootPath()).thenReturn(dataTreeIdentifier);
@Test
public void testOnDataTreeChangedSkip() {
- Mockito.when(roTx.read(LogicalDatastoreType.OPERATIONAL, fcNodePath))
- .thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
+ Mockito.doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(roTx)
+ .read(LogicalDatastoreType.OPERATIONAL, fcNodePath);
nodeListenerConfig.onDataTreeChanged(Collections.singleton(dataTreeModification));
private SyncupEntry loadOperationalDSAndPrepareSyncupEntry(final FlowCapableNode after,
final LogicalDatastoreType dsTypeAfter, final FlowCapableNode before,
final LogicalDatastoreType dsTypeBefore) {
- Mockito.when(roTx.read(LogicalDatastoreType.OPERATIONAL, fcNodePath))
- .thenReturn(Futures.immediateCheckedFuture(Optional.of(dataBefore)));
+ Mockito.doReturn(FluentFutures.immediateFluentFuture(Optional.of(dataBefore))).when(roTx)
+ .read(LogicalDatastoreType.OPERATIONAL, fcNodePath);
final SyncupEntry syncupEntry = new SyncupEntry(after, dsTypeAfter, before, dsTypeBefore);
Mockito.when(reactor.syncup(ArgumentMatchers.<InstanceIdentifier<FlowCapableNode>>any(),
Mockito.eq(syncupEntry))).thenReturn(Futures.immediateFuture(Boolean.TRUE));
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.impl;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frsync.SyncReactor;
import org.opendaylight.openflowplugin.applications.frsync.dao.FlowCapableNodeCachedDao;
import org.opendaylight.openflowplugin.applications.frsync.dao.FlowCapableNodeDao;
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.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
@Mock
private SyncReactor reactor;
@Mock
- private ReadOnlyTransaction roTx;
+ private ReadTransaction roTx;
@Mock
private DataTreeModification<Node> dataTreeModification;
@Mock
fcNodePath = nodePath.augmentation(FlowCapableNode.class);
final DataTreeIdentifier<Node> dataTreeIdentifier =
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, nodePath);
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, nodePath);
Mockito.when(db.newReadOnlyTransaction()).thenReturn(roTx);
Mockito.when(operationalNode.getId()).thenReturn(NODE_ID);
operationalUpdate();
prepareFreshOperational(true);
- Mockito.when(roTx.read(LogicalDatastoreType.CONFIGURATION, fcNodePath))
- .thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
+ Mockito.doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(roTx)
+ .read(LogicalDatastoreType.CONFIGURATION, fcNodePath);
nodeListenerOperational.onDataTreeChanged(Collections.singleton(dataTreeModification));
private SyncupEntry loadConfigDSAndPrepareSyncupEntry(final FlowCapableNode after,
final LogicalDatastoreType dsTypeAfter, final FlowCapableNode before,
final LogicalDatastoreType dsTypeBefore) {
- Mockito.when(roTx.read(LogicalDatastoreType.CONFIGURATION, fcNodePath))
- .thenReturn(Futures.immediateCheckedFuture(Optional.of(configNode)));
+
+ Mockito.doReturn(FluentFutures.immediateFluentFuture(Optional.of(configNode))).when(roTx)
+ .read(LogicalDatastoreType.CONFIGURATION, fcNodePath);
final SyncupEntry syncupEntry = new SyncupEntry(after, dsTypeAfter, before, dsTypeBefore);
Mockito.when(reactor.syncup(ArgumentMatchers.<InstanceIdentifier<FlowCapableNode>>any(),
Mockito.eq(syncupEntry))).thenReturn(Futures.immediateFuture(Boolean.TRUE));
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.impl;
import com.google.common.util.concurrent.Futures;
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frsync.SyncReactor;
import org.opendaylight.openflowplugin.applications.frsync.util.SyncupEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.impl;
import com.google.common.util.concurrent.ListenableFuture;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frsync.SyncPlanPushStrategy;
import org.opendaylight.openflowplugin.applications.frsync.impl.strategy.SynchronizationDiffInput;
import org.opendaylight.openflowplugin.applications.frsync.util.ReconcileUtil;
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. 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.applications.frsync.impl.strategy;
import com.google.common.collect.Lists;
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.openflowplugin.applications.frsync.impl.DSInputFactory;
import org.opendaylight.openflowplugin.applications.frsync.util.ItemSyncBox;
import org.opendaylight.openflowplugin.applications.frsync.util.SyncCrudCounters;
<artifactId>openflowplugin-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
* 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 com.google.common.collect.ImmutableSet;
import java.util.Map;
import java.util.Set;
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.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.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
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.flow.inventory.rev130819.FlowCapableNodeConnectorBuilder;
@SuppressWarnings("IllegalCatch")
public NodeConnectorInventoryEventTranslator(DataBroker dataBroker, NodeConnectorEventsObserver... observers) {
this.observers = ImmutableSet.copyOf(observers);
- final DataTreeIdentifier<T> dtiToNodeConnector = new DataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
- II_TO_FLOW_CAPABLE_NODE_CONNECTOR);
- final DataTreeIdentifier<T> dtiToNodeConnectorState = new DataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
- II_TO_STATE);
+ final DataTreeIdentifier dtiToNodeConnector = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
+ II_TO_FLOW_CAPABLE_NODE_CONNECTOR);
+ final DataTreeIdentifier dtiToNodeConnectorState = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
+ II_TO_STATE);
final SimpleTaskRetryLooper looper = new SimpleTaskRetryLooper(STARTUP_LOOP_TICK, STARTUP_LOOP_MAX_RETRIES);
try {
listenerOnPortRegistration = looper.loopUntilNoException(() ->
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="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
<reference id="deviceOwnershipService" interface="org.opendaylight.openflowplugin.applications.deviceownershipservice.DeviceOwnershipService"/>
<odl:clustered-app-config id="lldpSpeakerConfig"
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
-import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.DELETE;
-import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.SUBTREE_MODIFIED;
-import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.WRITE;
+import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.DELETE;
+import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.SUBTREE_MODIFIED;
+import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.WRITE;
import java.util.ArrayList;
import java.util.Collections;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-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.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.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
import org.opendaylight.yangtools.yang.binding.DataObject;
final FlowCapableNodeConnector connector) {
final DataTreeModification dataTreeModification = mock(DataTreeModification.class);
when(dataTreeModification.getRootNode()).thenReturn(mock(DataObjectModification.class));
- DataTreeIdentifier<T> identifier = new DataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, ii);
+ DataTreeIdentifier<T> identifier = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, ii);
when(dataTreeModification.getRootNode().getModificationType()).thenReturn(type);
when(dataTreeModification.getRootPath()).thenReturn(identifier);
when(dataTreeModification.getRootNode().getDataAfter()).thenReturn(connector);
<artifactId>openflowplugin-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
* 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.notification.supplier;
import com.google.common.annotations.VisibleForTesting;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.NodeConnectorNotificationSupplierImpl;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.NodeNotificationSupplierImpl;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.item.FlowNotificationSupplierImpl;
private final DataBroker db;
private final NotificationProviderConfig config;
- private final NotificationProviderService nps;
+ private final NotificationPublishService nps;
/* Supplier List property help for easy close method implementation and testing */
private List<NotificationSupplierDefinition<?>> supplierList;
* @param groupStatSupp - Group Stat Support Flag
* @param queueStatSupp - Queue Stat Support Flag
*/
- public NotificationProvider(final NotificationProviderService nps, final DataBroker db, boolean flowSupp,
+ public NotificationProvider(final NotificationPublishService nps, final DataBroker db, boolean flowSupp,
boolean meterSupp, boolean groupSupp, boolean connectorStatSupp, boolean flowStatSupp,
boolean flowTableStatSupp, boolean meterStatSupp, boolean groupStatSupp,
boolean queueStatSupp) {
* 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.notification.supplier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
* Default definition for every Notification Supplier. Migration from notification
- * to {@link org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener} has one
+ * to {@link DataTreeChangeListener} has one
* keyed component - WildCarded Path which represent a changes checker in DataStoreTreeNode
*
* @param <O> - {@link DataObject} represent Data Tree Item from DataStore
* 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.notification.supplier.impl;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.notification.supplier.NotificationSupplierDefinition;
import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
/**
* Public abstract basic Supplier implementation contains code for a make Supplier instance,
- * registration Supplier like {@link org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener}
+ * registration Supplier like {@link DataTreeChangeListener}
* and close method. In additional case, it contains help methods for all Supplier implementations.
*
* @param <O> - data tree item Object extends {@link DataObject}
private static final int STARTUP_LOOP_MAX_RETRIES = 8;
- final DataTreeIdentifier<O> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, getWildCardPath());
+ final DataTreeIdentifier<O> treeId = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, getWildCardPath());
/**
* Default constructor for all Notification Supplier implementation.
* 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.notification.supplier.impl;
import com.google.common.base.Preconditions;
import java.util.Collection;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.NotificationSupplierForItemRoot;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public abstract class AbstractNotificationSupplierForItemRoot<O extends DataObject, C extends Notification, D extends
Notification> extends AbstractNotificationSupplierBase<O> implements NotificationSupplierForItemRoot<O, C, D> {
- private final NotificationProviderService notificationProviderService;
+ private final NotificationPublishService notificationProviderService;
/**
* Default constructor for all Root Item Notification Supplier implementation.
* @param db - DataBroker for DataTreeChangeListener registration
* @param clazz - Statistics Notification Class
*/
- public AbstractNotificationSupplierForItemRoot(final NotificationProviderService notificationProviderService,
+ public AbstractNotificationSupplierForItemRoot(final NotificationPublishService notificationProviderService,
final DataBroker db, final Class<O> clazz) {
super(db, clazz);
this.notificationProviderService = Preconditions.checkNotNull(notificationProviderService);
public void add(InstanceIdentifier<O> identifier, O add) {
-
- final C notif = createNotification(add, identifier);
- if (notif != null) {
- notificationProviderService.publish(notif);
- }
+ putNotification(createNotification(add, identifier));
}
public void remove(InstanceIdentifier<O> identifier, O del) {
- final D notif = deleteNotification(identifier.firstIdentifierOf(clazz));
- if (notif != null) {
- notificationProviderService.publish(notif);
- }
+ putNotification(deleteNotification(identifier.firstIdentifierOf(clazz)));
}
public void update(InstanceIdentifier<O> identifier, O before, O after) {
//EMPTY NO-OP
}
+ private void putNotification(Notification notif) {
+ if (notif != null) {
+ try {
+ notificationProviderService.putNotification(notif);
+ } catch (InterruptedException e) {
+ throw new IllegalStateException("Interrupted while publishing " + notif, e);
+ }
+ }
+ }
}
* 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.notification.supplier.impl;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorUpdated;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorUpdatedBuilder;
/**
* Constructor register supplier as DataTreeChangeListener and create wildCarded InstanceIdentifier.
*
- * @param notifProviderService - {@link NotificationProviderService}
+ * @param notifProviderService - {@link NotificationPublishService}
* @param db - {@link DataBroker}
*/
- public NodeConnectorNotificationSupplierImpl(final NotificationProviderService notifProviderService,
+ public NodeConnectorNotificationSupplierImpl(final NotificationPublishService notifProviderService,
final DataBroker db) {
super(notifProviderService, db, FlowCapableNodeConnector.class);
}
* 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.notification.supplier.impl;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeUpdated;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeUpdatedBuilder;
/**
* Constructor register supplier as DataTreeChangeListener and create wildCarded InstanceIdentifier.
*
- * @param notifProviderService - {@link NotificationProviderService}
+ * @param notifProviderService - {@link NotificationPublishService}
* @param db - {@link DataBroker}
*/
- public NodeNotificationSupplierImpl(final NotificationProviderService notifProviderService, final DataBroker db) {
+ public NodeNotificationSupplierImpl(final NotificationPublishService notifProviderService, final DataBroker db) {
super(notifProviderService, db, FlowCapableNode.class);
}
* 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.notification.supplier.impl.item;
import com.google.common.base.Preconditions;
import java.util.Collection;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.NotificationSupplierForItem;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.AbstractNotificationSupplierBase;
import org.opendaylight.yangtools.yang.binding.DataObject;
Notification, D extends Notification> extends AbstractNotificationSupplierBase<O> implements
NotificationSupplierForItem<O, C, U, D> {
- private final NotificationProviderService notificationProviderService;
+ private final NotificationPublishService notificationProviderService;
/**
* Default constructor for all item Notification Supplier implementation.
* @param db - DataBroker for DataTreeChangeListener registration
* @param clazz - Statistics Notification Class
*/
- public AbstractNotificationSupplierForItem(final NotificationProviderService notifProviderService,
+ public AbstractNotificationSupplierForItem(final NotificationPublishService notifProviderService,
final DataBroker db, final Class<O> clazz) {
super(db, clazz);
this.notificationProviderService = Preconditions.checkNotNull(notifProviderService);
}
public void add(InstanceIdentifier<O> identifier, O add) {
- final C notif = createNotification(add, identifier);
- if (notif != null) {
- notificationProviderService.publish(notif);
- }
+ putNotification(createNotification(add, identifier));
}
public void remove(InstanceIdentifier<O> identifier, O del) {
- final D notif = deleteNotification(identifier.firstIdentifierOf(clazz));
- if (notif != null) {
- notificationProviderService.publish(notif);
- }
+ putNotification(deleteNotification(identifier.firstIdentifierOf(clazz)));
}
public void update(InstanceIdentifier<O> identifier, O before, O after) {
+ putNotification(updateNotification(after, identifier));
+ }
- final U notif = updateNotification(after, identifier);
+ private void putNotification(Notification notif) {
if (notif != null) {
- notificationProviderService.publish(notif);
+ try {
+ notificationProviderService.putNotification(notif);
+ } catch (InterruptedException e) {
+ throw new IllegalStateException("Interrupted while publishing " + notif, e);
+ }
}
}
}
* 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.notification.supplier.impl.item;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
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;
/**
* Constructor register supplier as DataTreeChangeListener and create wildCarded InstanceIdentifier.
*
- * @param notifProviderService - {@link NotificationProviderService}
+ * @param notifProviderService - {@link NotificationPublishService}
* @param db - {@link DataBroker}
*/
- public FlowNotificationSupplierImpl(final NotificationProviderService notifProviderService, final DataBroker db) {
+ public FlowNotificationSupplierImpl(final NotificationPublishService notifProviderService, final DataBroker db) {
super(notifProviderService, db, Flow.class);
}
* 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.notification.supplier.impl.item;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.GroupAdded;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.GroupAddedBuilder;
/**
* Constructor register supplier as DataTreeChangeListener and create wildCarded InstanceIdentifier.
*
- * @param notifProviderService - {@link NotificationProviderService}
+ * @param notifProviderService - {@link NotificationPublishService}
* @param db - {@link DataBroker}
*/
- public GroupNotificationSupplierImpl(final NotificationProviderService notifProviderService, final DataBroker db) {
+ public GroupNotificationSupplierImpl(final NotificationPublishService notifProviderService, final DataBroker db) {
super(notifProviderService, db, Group.class);
}
* 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.notification.supplier.impl.item;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.MeterAdded;
/**
* Constructor register supplier as DataTreeChangeListener and create wildCarded InstanceIdentifier.
*
- * @param notifProviderService - {@link NotificationProviderService}
+ * @param notifProviderService - {@link NotificationPublishService}
* @param db - {@link DataBroker}
*/
- public MeterNotificationSupplierImpl(final NotificationProviderService notifProviderService, final DataBroker db) {
+ public MeterNotificationSupplierImpl(final NotificationPublishService notifProviderService, final DataBroker db) {
super(notifProviderService, db, Meter.class);
}
* 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.notification.supplier.impl.item.stat;
import com.google.common.base.Preconditions;
import java.util.Collection;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.NotificationSupplierForItemStat;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.AbstractNotificationSupplierBase;
import org.opendaylight.yangtools.yang.binding.DataObject;
public abstract class AbstractNotificationSupplierForItemStat<O extends DataObject, N extends Notification> extends
AbstractNotificationSupplierBase<O> implements NotificationSupplierForItemStat<O, N> {
- private final NotificationProviderService notifProviderService;
+ private final NotificationPublishService notifProviderService;
/**
* Default constructor for all Statistic Notification Supplier implementation.
* @param db - DataBroker for DataTreeChangeListener registration
* @param clazz - Statistics Notification Class
*/
- public AbstractNotificationSupplierForItemStat(final NotificationProviderService notifProviderService,
+ public AbstractNotificationSupplierForItemStat(final NotificationPublishService notifProviderService,
final DataBroker db, final Class<O> clazz) {
super(db, clazz);
this.notifProviderService = Preconditions.checkNotNull(notifProviderService);
public void add(InstanceIdentifier<O> identifier, O add) {
final N notif = createNotification(add, identifier);
if (notif != null) {
- notifProviderService.publish(notif);
+ try {
+ notifProviderService.putNotification(notif);
+ } catch (InterruptedException e) {
+ throw new IllegalStateException("Interrupted while publishing " + notif, e);
+ }
}
}
* 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.notification.supplier.impl.item.stat;
import com.google.common.base.Preconditions;
import java.util.Collections;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
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;
/**
* Constructor register supplier as DataTreeChangeListener and create wildCarded InstanceIdentifier.
*
- * @param notifProviderService - {@link NotificationProviderService}
+ * @param notifProviderService - {@link NotificationPublishService}
* @param db - {@link DataBroker}
*/
- public FlowStatNotificationSupplierImpl(final NotificationProviderService notifProviderService,
+ public FlowStatNotificationSupplierImpl(final NotificationPublishService notifProviderService,
final DataBroker db) {
super(notifProviderService, db, FlowStatistics.class);
}
* 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.notification.supplier.impl.item.stat;
import com.google.common.base.Preconditions;
import java.util.Collections;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsData;
/**
* Constructor register supplier as DataTreeChangeListener and create wildCarded InstanceIdentifier.
*
- * @param notifProviderService - {@link NotificationProviderService}
+ * @param notifProviderService - {@link NotificationPublishService}
* @param db - {@link DataBroker}
*/
- public FlowTableStatNotificationSupplierImpl(final NotificationProviderService notifProviderService,
+ public FlowTableStatNotificationSupplierImpl(final NotificationPublishService notifProviderService,
final DataBroker db) {
super(notifProviderService, db, FlowTableStatistics.class);
}
* 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.notification.supplier.impl.item.stat;
import com.google.common.base.Preconditions;
import java.util.Collections;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.GroupStatisticsUpdated;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.GroupStatisticsUpdatedBuilder;
/**
* Constructor register supplier as DataTreeChangeListener and create wildCarded InstanceIdentifier.
*
- * @param notifProviderService - {@link NotificationProviderService}
+ * @param notifProviderService - {@link NotificationPublishService}
* @param db - {@link DataBroker}
*/
- public GroupStatNotificationSupplierImpl(final NotificationProviderService notifProviderService,
+ public GroupStatNotificationSupplierImpl(final NotificationPublishService notifProviderService,
final DataBroker db) {
super(notifProviderService, db, GroupStatistics.class);
}
* 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.notification.supplier.impl.item.stat;
import com.google.common.base.Preconditions;
import java.util.Collections;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
/**
* Constructor register supplier as DataTreeChangeListener and create wildCarded InstanceIdentifier.
*
- * @param notifProviderService - {@link NotificationProviderService}
+ * @param notifProviderService - {@link NotificationPublishService}
* @param db - {@link DataBroker}
*/
- public MeterStatNotificationSupplierImpl(final NotificationProviderService notifProviderService,
+ public MeterStatNotificationSupplierImpl(final NotificationPublishService notifProviderService,
final DataBroker db) {
super(notifProviderService, db, MeterStatistics.class);
}
* 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.notification.supplier.impl.item.stat;
import com.google.common.base.Preconditions;
import java.util.Collections;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
/**
* Constructor register supplier as DataTreeChangeListener and create wildCarded InstanceIdentifier.
*
- * @param notifProviderService - {@link NotificationProviderService}
+ * @param notifProviderService - {@link NotificationPublishService}
* @param db - {@link DataBroker}
*/
- public NodeConnectorStatNotificationSupplierImpl(final NotificationProviderService notifProviderService,
+ public NodeConnectorStatNotificationSupplierImpl(final NotificationPublishService notifProviderService,
final DataBroker db) {
super(notifProviderService, db, FlowCapableNodeConnectorStatistics.class);
}
* 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.notification.supplier.impl.item.stat;
import com.google.common.base.Preconditions;
import java.util.Collections;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.queues.Queue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
/**
* Constructor register supplier as DataTreeChangeListener and create wildCarded InstanceIdentifier.
*
- * @param notifProviderService - {@link NotificationProviderService}
+ * @param notifProviderService - {@link NotificationPublishService}
* @param db - {@link DataBroker}
*/
- public QueueStatNotificationSupplierImpl(final NotificationProviderService notifProviderService,
+ public QueueStatNotificationSupplierImpl(final NotificationPublishService notifProviderService,
final DataBroker db) {
super(notifProviderService, db, FlowCapableNodeConnectorQueueStatisticsData.class);
}
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="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
- <reference id="NotificationProviderService" interface="org.opendaylight.controller.sal.binding.api.NotificationProviderService"/>
+ <reference id="NotificationProviderService" interface="org.opendaylight.mdsal.binding.api.NotificationPublishService"/>
<bean id="NotificationProvider" class="org.opendaylight.openflowplugin.applications.notification.supplier.NotificationProvider"
init-method="start" destroy-method="close">
<argument value="false"/>
</bean>
-</blueprint>
\ No newline at end of file
+</blueprint>
import java.util.List;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.tools.NotificationProviderConfig;
import org.opendaylight.openflowplugin.applications.notification.supplier.tools.NotificationProviderConfig.NotificationProviderConfigBuilder;
public class NotificationProviderTest {
- private NotificationProviderService notificationProviderService;
+ private NotificationPublishService notificationProviderService;
private DataBroker dataBroker;
@Before
public void initialization() {
dataBroker = mock(DataBroker.class);
- notificationProviderService = mock(NotificationProviderService.class);
+ notificationProviderService = mock(NotificationPublishService.class);
}
@Test
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestChangeEventBuildHelper;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestData;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestSupplierVerifyHelper;
private static final String FLOW_NODE_ID = "openflow:111";
private static final String FLOW_CODE_CONNECTOR_ID = "test-con-111";
private NodeConnectorNotificationSupplierImpl notifSupplierImpl;
- private NotificationProviderService notifProviderService;
+ private NotificationPublishService notifProviderService;
private DataBroker dataBroker;
@Before
public void initalization() {
- notifProviderService = mock(NotificationProviderService.class);
+ notifProviderService = mock(NotificationPublishService.class);
dataBroker = mock(DataBroker.class);
notifSupplierImpl = new NodeConnectorNotificationSupplierImpl(notifProviderService, dataBroker);
TestSupplierVerifyHelper.verifyDataTreeChangeListenerRegistration(dataBroker);
}
@Test
- public void testCreateChangeEvent() {
- final TestData testData = new TestData(createTestFlowCapableConnectorNodePath(), null,
- createTestFlowCapableNodeConnecor(),
- DataObjectModification.ModificationType.WRITE);
+ public void testCreateChangeEvent() throws InterruptedException {
+ final TestData<FlowCapableNodeConnector> testData = new TestData<>(createTestFlowCapableConnectorNodePath(),
+ null, createTestFlowCapableNodeConnecor(), DataObjectModification.ModificationType.WRITE);
Collection<DataTreeModification<FlowCapableNodeConnector>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(NodeConnectorUpdated.class));
+ verify(notifProviderService, times(1)).putNotification(any(NodeConnectorUpdated.class));
}
@Test(expected = IllegalArgumentException.class)
}
@Test
- public void testDeleteChangeEvent() {
- final TestData testData = new TestData(createTestFlowCapableConnectorNodePath(),
- createTestFlowCapableNodeConnecor(), null,
- DataObjectModification.ModificationType.DELETE);
+ public void testDeleteChangeEvent() throws InterruptedException {
+ final TestData<FlowCapableNodeConnector> testData = new TestData<>(createTestFlowCapableConnectorNodePath(),
+ createTestFlowCapableNodeConnecor(), null, DataObjectModification.ModificationType.DELETE);
Collection<DataTreeModification<FlowCapableNodeConnector>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(NodeConnectorRemoved.class));
+ verify(notifProviderService, times(1)).putNotification(any(NodeConnectorRemoved.class));
}
@Test(expected = IllegalArgumentException.class)
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestChangeEventBuildHelper;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestData;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestSupplierVerifyHelper;
private static final String FLOW_NODE_ID = "openflow:111";
private NodeNotificationSupplierImpl notifSupplierImpl;
- private NotificationProviderService notifProviderService;
+ private NotificationPublishService notifProviderService;
private DataBroker dataBroker;
@Before
public void initalization() {
- notifProviderService = mock(NotificationProviderService.class);
+ notifProviderService = mock(NotificationPublishService.class);
dataBroker = mock(DataBroker.class);
notifSupplierImpl = new NodeNotificationSupplierImpl(notifProviderService, dataBroker);
TestSupplierVerifyHelper.verifyDataTreeChangeListenerRegistration(dataBroker);
}
@Test
- public void testCreateChangeEvent() {
- final TestData testData = new TestData(createTestFlowCapableNodePath(), null, createTestFlowCapableNode(),
- DataObjectModification.ModificationType.WRITE);
+ public void testCreateChangeEvent() throws InterruptedException {
+ final TestData<FlowCapableNode> testData = new TestData<>(createTestFlowCapableNodePath(), null,
+ createTestFlowCapableNode(), DataObjectModification.ModificationType.WRITE);
Collection<DataTreeModification<FlowCapableNode>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(NodeUpdated.class));
+ verify(notifProviderService, times(1)).putNotification(any(NodeUpdated.class));
}
@Test(expected = IllegalArgumentException.class)
}
@Test
- public void testDeleteChangeEvent() {
- final TestData testData = new TestData(createTestFlowCapableNodePath(), createTestFlowCapableNode(), null,
- DataObjectModification.ModificationType.DELETE);
+ public void testDeleteChangeEvent() throws InterruptedException {
+ final TestData<FlowCapableNode> testData = new TestData<>(createTestFlowCapableNodePath(),
+ createTestFlowCapableNode(), null, DataObjectModification.ModificationType.DELETE);
Collection<DataTreeModification<FlowCapableNode>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(NodeRemoved.class));
+ verify(notifProviderService, times(1)).putNotification(any(NodeRemoved.class));
}
@Test(expected = IllegalArgumentException.class)
* 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.notification.supplier.impl.helper;
import java.util.Collection;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-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.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.ChildOf;
+import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
/**
* Created by eshuvka on 6/7/2016.
public TestData(final InstanceIdentifier<T> path, final T dataBefore, final T dataAfter,
DataObjectModification.ModificationType modType) {
- this.path = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, path);
- this.rootNode = new Test(dataBefore, dataAfter, modType);
+ this.path = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, path);
+ this.rootNode = new Test<>(dataBefore, dataAfter, modType);
}
- @Nonnull
@Override
public DataTreeIdentifier<T> getRootPath() {
return path;
}
- @Nonnull
@Override
public DataObjectModification<T> getRootNode() {
return rootNode;
}
@Override
- public InstanceIdentifier.PathArgument getIdentifier() {
+ public PathArgument getIdentifier() {
return null;
}
- @Nonnull
@Override
public Class<T> getDataType() {
return null;
}
- @Nonnull
@Override
public ModificationType getModificationType() {
return modification;
}
- @Nullable
@Override
public T getDataBefore() {
return dataObjBefore;
}
- @Nullable
@Override
public T getDataAfter() {
return dataObjAfter;
}
- @Nonnull
@Override
public Collection<DataObjectModification<? extends DataObject>> getModifiedChildren() {
return null;
}
- @Nullable
@Override
- public <C extends ChildOf<? super T>> DataObjectModification<C> getModifiedChildContainer(
- @Nonnull Class<C> theClass) {
+ public <C extends ChildOf<? super T>> Collection<DataObjectModification<C>> getModifiedChildren(
+ Class<C> childType) {
+ return null;
+ }
+
+ @Override
+ public <H extends ChoiceIn<? super T> & DataObject, C extends ChildOf<? super H>>
+ Collection<DataObjectModification<C>> getModifiedChildren(Class<H> caseType, Class<C> childType) {
+ return null;
+ }
+
+ @Override
+ public <C extends ChildOf<? super T>> DataObjectModification<C> getModifiedChildContainer(Class<C> theClass) {
+ return null;
+ }
+
+ @Override
+ public <H extends ChoiceIn<? super T> & DataObject, C extends ChildOf<? super H>> DataObjectModification<C>
+ getModifiedChildContainer(Class<H> caseType, Class<C> child) {
return null;
}
- @Nullable
@Override
public <C extends Augmentation<T> & DataObject> DataObjectModification<C> getModifiedAugmentation(
- @Nonnull Class<C> theClass) {
+ Class<C> theClass) {
return null;
}
@Override
public <C extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<C>> DataObjectModification<C>
- getModifiedChildListItem(@Nonnull Class<C> theClass, @Nonnull K listKey) {
+ getModifiedChildListItem(Class<C> theClass, K listKey) {
+ return null;
+ }
+
+ @Override
+ public <H extends ChoiceIn<? super T> & DataObject, C extends Identifiable<K> & ChildOf<? super H>,
+ K extends Identifier<C>> DataObjectModification<C> getModifiedChildListItem(Class<H> caseType,
+ Class<C> listItem, K listKey) {
return null;
}
- @Nullable
@Override
- public DataObjectModification<? extends DataObject> getModifiedChild(
- InstanceIdentifier.PathArgument pathArgument) {
+ public DataObjectModification<? extends DataObject> getModifiedChild(PathArgument pathArgument) {
return null;
}
}
-}
\ No newline at end of file
+}
* 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.notification.supplier.impl.helper;
import org.mockito.ArgumentMatchers;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
public final class TestSupplierVerifyHelper {
* 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.notification.supplier.impl.item;
import static org.junit.Assert.assertEquals;
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestChangeEventBuildHelper;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestData;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestSupplierVerifyHelper;
private static final String FLOW_ID = "test-flow-111";
private static final String UPDATED_FLOW_ID = "test-flow-100";
private FlowNotificationSupplierImpl notifSupplierImpl;
- private NotificationProviderService notifProviderService;
+ private NotificationPublishService notifProviderService;
private DataBroker dataBroker;
@Before
public void initalization() {
- notifProviderService = mock(NotificationProviderService.class);
+ notifProviderService = mock(NotificationPublishService.class);
dataBroker = mock(DataBroker.class);
notifSupplierImpl = new FlowNotificationSupplierImpl(notifProviderService, dataBroker);
TestSupplierVerifyHelper.verifyDataTreeChangeListenerRegistration(dataBroker);
}
@Test
- public void testCreateChangeEvent() {
- final TestData testData = new TestData(createTestFlowPath(), null, createTestFlow(),
- DataObjectModification.ModificationType.WRITE);
+ public void testCreateChangeEvent() throws InterruptedException {
+ final TestData<Flow> testData = new TestData<>(createTestFlowPath(), null, createTestFlow(),
+ DataObjectModification.ModificationType.WRITE);
Collection<DataTreeModification<Flow>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(FlowAdded.class));
+ verify(notifProviderService, times(1)).putNotification(any(FlowAdded.class));
}
@Test(expected = IllegalArgumentException.class)
}
@Test
- public void testUpdateChangeEvent() {
- final TestData testData = new TestData(createTestFlowPath(), createTestFlow(), createUpdatedTestFlow(),
- DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+ public void testUpdateChangeEvent() throws InterruptedException {
+ final TestData<Flow> testData = new TestData<>(createTestFlowPath(), createTestFlow(), createUpdatedTestFlow(),
+ DataObjectModification.ModificationType.SUBTREE_MODIFIED);
Collection<DataTreeModification<Flow>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(FlowUpdated.class));
+ verify(notifProviderService, times(1)).putNotification(any(FlowUpdated.class));
}
@Test(expected = IllegalArgumentException.class)
}
@Test
- public void testDeleteChangeEvent() {
- final TestData testData = new TestData(createTestFlowPath(), createTestFlow(), null,
- DataObjectModification.ModificationType.DELETE);
+ public void testDeleteChangeEvent() throws InterruptedException {
+ final TestData<Flow> testData = new TestData<>(createTestFlowPath(), createTestFlow(), null,
+ DataObjectModification.ModificationType.DELETE);
Collection<DataTreeModification<Flow>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(FlowRemoved.class));
+ verify(notifProviderService, times(1)).putNotification(any(FlowRemoved.class));
}
@Test(expected = IllegalArgumentException.class)
* 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.notification.supplier.impl.item;
import static org.junit.Assert.assertEquals;
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestChangeEventBuildHelper;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestData;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestSupplierVerifyHelper;
private static final Long UPDATED_GROUP_ID = 100L;
private GroupNotificationSupplierImpl notifSupplierImpl;
- private NotificationProviderService notifProviderService;
+ private NotificationPublishService notifProviderService;
private DataBroker dataBroker;
@Before
public void initalization() {
- notifProviderService = mock(NotificationProviderService.class);
+ notifProviderService = mock(NotificationPublishService.class);
dataBroker = mock(DataBroker.class);
notifSupplierImpl = new GroupNotificationSupplierImpl(notifProviderService, dataBroker);
TestSupplierVerifyHelper.verifyDataTreeChangeListenerRegistration(dataBroker);
}
@Test
- public void testCreateChangeEvent() {
- final TestData testData = new TestData(createTestGroupPath(), null, createTestGroup(),
- DataObjectModification.ModificationType.WRITE);
+ public void testCreateChangeEvent() throws InterruptedException {
+ final TestData<Group> testData = new TestData<>(createTestGroupPath(), null, createTestGroup(),
+ DataObjectModification.ModificationType.WRITE);
Collection<DataTreeModification<Group>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(GroupAdded.class));
+ verify(notifProviderService, times(1)).putNotification(any(GroupAdded.class));
}
@Test(expected = IllegalArgumentException.class)
}
@Test
- public void testUpdateChangeEvent() {
- final TestData testData = new TestData(createTestGroupPath(), createTestGroup(), createUpdatedTestGroup(),
- DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+ public void testUpdateChangeEvent() throws InterruptedException {
+ final TestData<Group> testData = new TestData<>(createTestGroupPath(), createTestGroup(),
+ createUpdatedTestGroup(),
+ DataObjectModification.ModificationType.SUBTREE_MODIFIED);
Collection<DataTreeModification<Group>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(GroupUpdated.class));
+ verify(notifProviderService, times(1)).putNotification(any(GroupUpdated.class));
}
@Test(expected = IllegalArgumentException.class)
}
@Test
- public void testDeleteChangeEvent() {
- final TestData testData = new TestData(createTestGroupPath(), createTestGroup(), null,
- DataObjectModification.ModificationType.DELETE);
+ public void testDeleteChangeEvent() throws InterruptedException {
+ final TestData<Group> testData = new TestData<>(createTestGroupPath(), createTestGroup(), null,
+ DataObjectModification.ModificationType.DELETE);
Collection<DataTreeModification<Group>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(GroupRemoved.class));
+ verify(notifProviderService, times(1)).putNotification(any(GroupRemoved.class));
}
@Test(expected = IllegalArgumentException.class)
* 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.notification.supplier.impl.item;
import static org.junit.Assert.assertEquals;
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestChangeEventBuildHelper;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestData;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestSupplierVerifyHelper;
private static final Long UPDATED_METER_ID = 100L;
private MeterNotificationSupplierImpl notifSupplierImpl;
- private NotificationProviderService notifProviderService;
+ private NotificationPublishService notifProviderService;
private DataBroker dataBroker;
@Before
public void initalization() {
- notifProviderService = mock(NotificationProviderService.class);
+ notifProviderService = mock(NotificationPublishService.class);
dataBroker = mock(DataBroker.class);
notifSupplierImpl = new MeterNotificationSupplierImpl(notifProviderService, dataBroker);
TestSupplierVerifyHelper.verifyDataTreeChangeListenerRegistration(dataBroker);
}
@Test
- public void testCreateChangeEvent() {
- final TestData testData = new TestData(createTestMeterPath(), null, createTestMeter(),
- DataObjectModification.ModificationType.WRITE);
+ public void testCreateChangeEvent() throws InterruptedException {
+ final TestData<Meter> testData = new TestData<>(createTestMeterPath(), null, createTestMeter(),
+ DataObjectModification.ModificationType.WRITE);
Collection<DataTreeModification<Meter>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(MeterAdded.class));
+ verify(notifProviderService, times(1)).putNotification(any(MeterAdded.class));
}
@Test(expected = IllegalArgumentException.class)
}
@Test
- public void testUdateChangeEvent() {
- final TestData testData = new TestData(createTestMeterPath(), createTestMeter(), createUpdatedTestMeter(),
- DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+ public void testUdateChangeEvent() throws InterruptedException {
+ final TestData<Meter> testData = new TestData<>(createTestMeterPath(), createTestMeter(),
+ createUpdatedTestMeter(),
+ DataObjectModification.ModificationType.SUBTREE_MODIFIED);
Collection<DataTreeModification<Meter>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(MeterUpdated.class));
+ verify(notifProviderService, times(1)).putNotification(any(MeterUpdated.class));
}
@Test(expected = IllegalArgumentException.class)
}
@Test
- public void testDeleteChangeEvent() {
- final TestData testData = new TestData(createTestMeterPath(), createTestMeter(), null,
- DataObjectModification.ModificationType.DELETE);
+ public void testDeleteChangeEvent() throws InterruptedException {
+ final TestData<Meter> testData = new TestData<>(createTestMeterPath(), createTestMeter(), null,
+ DataObjectModification.ModificationType.DELETE);
Collection<DataTreeModification<Meter>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(MeterRemoved.class));
+ verify(notifProviderService, times(1)).putNotification(any(MeterRemoved.class));
}
@Test(expected = IllegalArgumentException.class)
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestChangeEventBuildHelper;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestData;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestSupplierVerifyHelper;
private static final Short FLOW_TABLE_ID = 111;
private static final String FLOW_ID = "test-flow-111";
private FlowStatNotificationSupplierImpl notifSupplierImpl;
- private NotificationProviderService notifProviderService;
+ private NotificationPublishService notifProviderService;
private DataBroker dataBroker;
@Before
public void initalization() {
- notifProviderService = mock(NotificationProviderService.class);
+ notifProviderService = mock(NotificationPublishService.class);
dataBroker = mock(DataBroker.class);
notifSupplierImpl = new FlowStatNotificationSupplierImpl(notifProviderService, dataBroker);
TestSupplierVerifyHelper.verifyDataTreeChangeListenerRegistration(dataBroker);
}
@Test
- public void testCreateChangeEvent() {
- final TestData testData = new TestData(createTestFlowStatPath(), null, createTestFlowStat(),
- DataObjectModification.ModificationType.WRITE);
+ public void testCreateChangeEvent() throws InterruptedException {
+ final TestData<FlowStatistics> testData = new TestData<>(createTestFlowStatPath(), null, createTestFlowStat(),
+ DataObjectModification.ModificationType.WRITE);
Collection<DataTreeModification<FlowStatistics>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(FlowsStatisticsUpdate.class));
+ verify(notifProviderService, times(1)).putNotification(any(FlowsStatisticsUpdate.class));
}
@Test(expected = IllegalArgumentException.class)
* 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.notification.supplier.impl.item.stat;
import static org.junit.Assert.assertEquals;
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestChangeEventBuildHelper;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestData;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestSupplierVerifyHelper;
private static final Short FLOW_TABLE_ID = 111;
private static final String FLOW_ID = "test-flow-111";
private FlowTableStatNotificationSupplierImpl notifSupplierImpl;
- private NotificationProviderService notifProviderService;
+ private NotificationPublishService notifProviderService;
private DataBroker dataBroker;
@Before
public void initalization() {
- notifProviderService = mock(NotificationProviderService.class);
+ notifProviderService = mock(NotificationPublishService.class);
dataBroker = mock(DataBroker.class);
notifSupplierImpl = new FlowTableStatNotificationSupplierImpl(notifProviderService, dataBroker);
TestSupplierVerifyHelper.verifyDataTreeChangeListenerRegistration(dataBroker);
}
@Test
- public void testCreateChangeEvent() {
- final TestData testData = new TestData(createTestFlowTableStatPath(), null, createTestFlowTableStat(),
- DataObjectModification.ModificationType.WRITE);
+ public void testCreateChangeEvent() throws InterruptedException {
+ final TestData<FlowTableStatistics> testData = new TestData<>(createTestFlowTableStatPath(), null,
+ createTestFlowTableStat(),
+ DataObjectModification.ModificationType.WRITE);
Collection<DataTreeModification<FlowTableStatistics>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(FlowTableStatisticsUpdate.class));
+ verify(notifProviderService, times(1)).putNotification(any(FlowTableStatisticsUpdate.class));
}
@Test(expected = IllegalArgumentException.class)
* 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.notification.supplier.impl.item.stat;
import static org.junit.Assert.assertEquals;
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestChangeEventBuildHelper;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestData;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestSupplierVerifyHelper;
private static final String FLOW_NODE_ID = "openflow:111";
private static final Long FLOW_TABLE_ID = 111L;
private GroupStatNotificationSupplierImpl notifSupplierImpl;
- private NotificationProviderService notifProviderService;
+ private NotificationPublishService notifProviderService;
private DataBroker dataBroker;
@Before
public void initalization() {
- notifProviderService = mock(NotificationProviderService.class);
+ notifProviderService = mock(NotificationPublishService.class);
dataBroker = mock(DataBroker.class);
notifSupplierImpl = new GroupStatNotificationSupplierImpl(notifProviderService, dataBroker);
TestSupplierVerifyHelper.verifyDataTreeChangeListenerRegistration(dataBroker);
}
@Test
- public void testCreateChangeEvent() {
- final TestData testData = new TestData(createTestGroupStatPath(), null, createTestGroupStat(),
- DataObjectModification.ModificationType.WRITE);
+ public void testCreateChangeEvent() throws InterruptedException {
+ final TestData<GroupStatistics> testData = new TestData<>(createTestGroupStatPath(), null,
+ createTestGroupStat(), DataObjectModification.ModificationType.WRITE);
Collection<DataTreeModification<GroupStatistics>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(GroupStatisticsUpdated.class));
+ verify(notifProviderService, times(1)).putNotification(any(GroupStatisticsUpdated.class));
}
@Test(expected = IllegalArgumentException.class)
* 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.notification.supplier.impl.item.stat;
import static org.junit.Assert.assertEquals;
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestChangeEventBuildHelper;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestData;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestSupplierVerifyHelper;
private static final String FLOW_NODE_ID = "openflow:111";
private static final Long FLOW_METER_ID = 111L;
private MeterStatNotificationSupplierImpl notifSupplierImpl;
- private NotificationProviderService notifProviderService;
+ private NotificationPublishService notifProviderService;
private DataBroker dataBroker;
@Before
public void initalization() {
- notifProviderService = mock(NotificationProviderService.class);
+ notifProviderService = mock(NotificationPublishService.class);
dataBroker = mock(DataBroker.class);
notifSupplierImpl = new MeterStatNotificationSupplierImpl(notifProviderService, dataBroker);
TestSupplierVerifyHelper.verifyDataTreeChangeListenerRegistration(dataBroker);
}
@Test
- public void testCreateChangeEvent() {
- final TestData testData = new TestData(createTestMeterStatPath(),null,createTestMeterStat(),
+ public void testCreateChangeEvent() throws InterruptedException {
+ final TestData<MeterStatistics> testData = new TestData<>(createTestMeterStatPath(),null,createTestMeterStat(),
DataObjectModification.ModificationType.WRITE);
Collection<DataTreeModification<MeterStatistics>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(MeterStatisticsUpdated.class));
+ verify(notifProviderService, times(1)).putNotification(any(MeterStatisticsUpdated.class));
}
@Test(expected = IllegalArgumentException.class)
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestChangeEventBuildHelper;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestData;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestSupplierVerifyHelper;
private static final String FLOW_NODE_ID = "openflow:111";
private static final String FLOW_CODE_CONNECTOR_ID = "test-con-111";
private NodeConnectorStatNotificationSupplierImpl notifSupplierImpl;
- private NotificationProviderService notifProviderService;
+ private NotificationPublishService notifProviderService;
private DataBroker dataBroker;
@Before
public void initalization() {
- notifProviderService = mock(NotificationProviderService.class);
+ notifProviderService = mock(NotificationPublishService.class);
dataBroker = mock(DataBroker.class);
notifSupplierImpl = new NodeConnectorStatNotificationSupplierImpl(notifProviderService, dataBroker);
TestSupplierVerifyHelper.verifyDataTreeChangeListenerRegistration(dataBroker);
}
@Test
- public void testCreateChangeEvent() {
- final TestData testData = new TestData(createTestConnectorStatPath(), null, createTestConnectorStat(),
- DataObjectModification.ModificationType.WRITE);
+ public void testCreateChangeEvent() throws InterruptedException {
+ final TestData<FlowCapableNodeConnectorStatistics> testData = new TestData<>(createTestConnectorStatPath(),
+ null, createTestConnectorStat(), DataObjectModification.ModificationType.WRITE);
Collection<DataTreeModification<FlowCapableNodeConnectorStatistics>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(NodeConnectorStatisticsUpdate.class));
+ verify(notifProviderService, times(1)).putNotification(any(NodeConnectorStatisticsUpdate.class));
}
@Test(expected = IllegalArgumentException.class)
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
-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.DataTreeModification;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestChangeEventBuildHelper;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestData;
import org.opendaylight.openflowplugin.applications.notification.supplier.impl.helper.TestSupplierVerifyHelper;
private static final String FLOW_NODE_ID = "openflow:111";
private static final String FLOW_CODE_CONNECTOR_ID = "test-con-111";
private QueueStatNotificationSupplierImpl notifSupplierImpl;
- private NotificationProviderService notifProviderService;
+ private NotificationPublishService notifProviderService;
private DataBroker dataBroker;
@Before
public void initalization() {
- notifProviderService = mock(NotificationProviderService.class);
+ notifProviderService = mock(NotificationPublishService.class);
dataBroker = mock(DataBroker.class);
notifSupplierImpl = new QueueStatNotificationSupplierImpl(notifProviderService, dataBroker);
TestSupplierVerifyHelper.verifyDataTreeChangeListenerRegistration(dataBroker);
}
@Test
- public void testCreateChangeEvent() {
- final TestData testData = new TestData(createTestQueueStatPath(), null, createTestQueueStat(),
- DataObjectModification.ModificationType.WRITE);
+ public void testCreateChangeEvent() throws InterruptedException {
+ final TestData<FlowCapableNodeConnectorQueueStatisticsData> testData = new TestData<>(createTestQueueStatPath(),
+ null, createTestQueueStat(), DataObjectModification.ModificationType.WRITE);
Collection<DataTreeModification<FlowCapableNodeConnectorQueueStatisticsData>> collection = new ArrayList<>();
collection.add(testData);
notifSupplierImpl.onDataTreeChanged(collection);
- verify(notifProviderService, times(1)).publish(any(QueueStatisticsUpdate.class));
+ verify(notifProviderService, times(1)).putNotification(any(QueueStatisticsUpdate.class));
}
@Test(expected = IllegalArgumentException.class)
<artifactId>openflowplugin-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
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.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.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.applications.deviceownershipservice.DeviceOwnershipService;
import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
try {
final InstanceIdentifier<FlowCapableNode> path = InstanceIdentifier.create(Nodes.class).child(Node.class)
.augmentation(FlowCapableNode.class);
- final DataTreeIdentifier<FlowCapableNode> identifier = new DataTreeIdentifier<>(
+ final DataTreeIdentifier<FlowCapableNode> identifier = DataTreeIdentifier.create(
LogicalDatastoreType.OPERATIONAL, path);
final SimpleTaskRetryLooper looper = new SimpleTaskRetryLooper(STARTUP_LOOP_TICK, STARTUP_LOOP_MAX_RETRIES);
listenerRegistration = looper.loopUntilNoException(
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
-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.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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.applications.deviceownershipservice.DeviceOwnershipService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
doReturn(RpcResultBuilder.success().buildFuture()).when(nodeConfigService).setConfig(any());
defaultConfigPusher = new DefaultConfigPusher(nodeConfigService, Mockito.mock(DataBroker.class),
deviceOwnershipService);
- final DataTreeIdentifier<FlowCapableNode> identifier =
- new DataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, NODE_IID);
+ final DataTreeIdentifier<FlowCapableNode> identifier = DataTreeIdentifier.create(
+ LogicalDatastoreType.OPERATIONAL, NODE_IID.augmentation(FlowCapableNode.class));
Mockito.when(dataTreeModification.getRootPath()).thenReturn(identifier);
Mockito.when(dataTreeModification.getRootNode()).thenReturn(Mockito.mock(DataObjectModification.class));
Mockito.when(dataTreeModification.getRootNode().getModificationType()).thenReturn(ModificationType.WRITE);
<artifactId>junit</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.openflowplugin</groupId>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-common</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-util</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-singleton-common-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
<type>test-jar</type>
</dependency>
<artifactId>junit</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.openflowplugin</groupId>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-common</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-util</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-singleton-common-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
<type>test-jar</type>
</dependency>
import static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.NodeReconcileState.State.FAILED;
import static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.NodeReconcileState.State.INPROGRESS;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.southboundcli.alarm.AlarmAgent;
import org.opendaylight.openflowplugin.applications.southboundcli.util.OFNode;
import org.opendaylight.openflowplugin.applications.southboundcli.util.ShellUtil;
InstanceIdentifier<ReconciliationStateList> instanceIdentifier = InstanceIdentifier
.builder(ReconciliationState.class).child(ReconciliationStateList.class,
new ReconciliationStateListKey(new BigInteger(String.valueOf(nodeId)))).build();
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
return tx.read(LogicalDatastoreType.OPERATIONAL, instanceIdentifier).get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Exception while reading reconciliation state for {}", nodeId, e);
}
- return Optional.absent();
+ return Optional.empty();
}
private ListenableFuture<RpcResult<ReconcileOutput>> buildErrorResponse(String msg) {
}
try {
tx.merge(LogicalDatastoreType.OPERATIONAL, instanceIdentifier, counterBuilder.build(), true);
- tx.submit().get();
+ tx.commit().get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Exception while submitting counter for {}", nodeId, e);
}
} catch (InterruptedException | ExecutionException e) {
LOG.error("Exception while reading counter for node: {}", nodeId, e);
}
- return Optional.absent();
+ return Optional.empty();
}
private void updateReconciliationState(State state) {
.setState(state);
try {
tx.merge(LogicalDatastoreType.OPERATIONAL, instanceIdentifier, stateBuilder.build(), true);
- tx.submit().get();
+ tx.commit().get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Exception while updating reconciliation state: {}", nodeId, e);
}
import java.util.List;
import org.apache.felix.gogo.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.openflowplugin.applications.southboundcli.util.OFNode;
import org.opendaylight.openflowplugin.applications.southboundcli.util.ShellUtil;
import org.slf4j.Logger;
import java.util.List;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.openflowplugin.applications.southboundcli.util.ShellUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.reconciliation.service.rev180227.reconciliation.counter.ReconcileCounter;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.apache.karaf.shell.console.OsgiCommandSupport;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.openflowplugin.applications.southboundcli.util.OFNode;
import org.opendaylight.openflowplugin.applications.southboundcli.util.ShellUtil;
package org.opendaylight.openflowplugin.applications.southboundcli.util;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
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;
public static List<OFNode> getAllNodes(final DataBroker broker) {
List<Node> nodes = null;
InstanceIdentifier<Nodes> path = InstanceIdentifier.builder(Nodes.class).build();
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
Optional<Nodes> result = tx.read(LogicalDatastoreType.OPERATIONAL, path).get();
if (result.isPresent()) {
nodes = result.get().getNode();
InstanceIdentifier<Node> path = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(new NodeId(NODE_PREFIX + nodeId))).build();
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
Optional<Node> result = tx.read(LogicalDatastoreType.OPERATIONAL, path).get();
if (result.isPresent()) {
Node node = result.get();
InstanceIdentifier<ReconciliationCounter> instanceIdentifier = InstanceIdentifier
.builder(ReconciliationCounter.class).build();
List<ReconcileCounter> output = Collections.emptyList();
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
Optional<ReconciliationCounter> result =
tx.read(LogicalDatastoreType.OPERATIONAL, instanceIdentifier).get();
if (result.isPresent()) {
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
<odl:rpc-service id="frmReconciliationService"
interface="org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.frm.reconciliation.service.rev180227.FrmReconciliationService"/>
</command>
</command-bundle>
-</blueprint>
\ No newline at end of file
+</blueprint>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
import java.util.List;
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.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.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.applications.deviceownershipservice.DeviceOwnershipService;
import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
public void start() {
final InstanceIdentifier<FlowCapableNode> path = InstanceIdentifier.create(Nodes.class).child(Node.class)
.augmentation(FlowCapableNode.class);
- final DataTreeIdentifier<FlowCapableNode> identifier = new DataTreeIdentifier<>(
+ final DataTreeIdentifier<FlowCapableNode> identifier = DataTreeIdentifier.create(
LogicalDatastoreType.OPERATIONAL, path);
SimpleTaskRetryLooper looper = new SimpleTaskRetryLooper(STARTUP_LOOP_TICK, STARTUP_LOOP_MAX_RETRIES);
try {
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="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
<reference id="deviceOwnershipService" interface="org.opendaylight.openflowplugin.applications.deviceownershipservice.DeviceOwnershipService"/>
<odl:rpc-service id="flowService" interface="org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService"/>
<argument ref="dataBroker"/>
<argument ref="deviceOwnershipService"/>
</bean>
-</blueprint>
\ No newline at end of file
+</blueprint>
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.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.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.deviceownershipservice.DeviceOwnershipService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.OutputActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
doReturn(RpcResultBuilder.success().buildFuture()).when(flowService).addFlow(any());
lldpPacketPuntEnforcer = new LLDPPacketPuntEnforcer(flowService, Mockito.mock(DataBroker.class),
deviceOwnershipService);
- final DataTreeIdentifier<FlowCapableNode> identifier = new DataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
- NODE_IID);
+ final DataTreeIdentifier<FlowCapableNode> identifier = DataTreeIdentifier.create(
+ LogicalDatastoreType.OPERATIONAL, NODE_IID.augmentation(FlowCapableNode.class));
Mockito.when(dataTreeModification.getRootPath()).thenReturn(identifier);
Mockito.when(dataTreeModification.getRootNode()).thenReturn(Mockito.mock(DataObjectModification.class));
Mockito.when(dataTreeModification.getRootNode().getModificationType()).thenReturn(ModificationType.WRITE);
<artifactId>commons-lang</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
-/**
+/*
* Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
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.binding.api.NotificationService;
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.opendaylight.yangtools.yang.binding.NotificationListener;
@SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
@Inject
- public LLDPActivator(@Reference NotificationProviderService notificationService,
+ public LLDPActivator(@Reference NotificationService notificationService,
LLDPDiscoveryListener lldpDiscoveryListener,
TopologyLldpDiscoveryConfig topologyLldpDiscoveryConfig) {
lldpSecureKey = topologyLldpDiscoveryConfig.getLldpSecureKey();
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
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.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.openflowplugin.applications.topology.lldp.utils.LLDPDiscoveryUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkDiscovered;
private static final Logger LOG = LoggerFactory.getLogger(LLDPDiscoveryListener.class);
private final LLDPLinkAger lldpLinkAger;
- private final NotificationProviderService notificationService;
+ private final NotificationPublishService notificationService;
private final EntityOwnershipService eos;
@Inject
- public LLDPDiscoveryListener(@Reference final NotificationProviderService notificationService,
+ public LLDPDiscoveryListener(@Reference final NotificationPublishService notificationService,
final LLDPLinkAger lldpLinkAger, @Reference final EntityOwnershipService entityOwnershipService) {
this.notificationService = notificationService;
this.lldpLinkAger = lldpLinkAger;
lldpLinkAger.put(ld);
if (LLDPDiscoveryUtils.isEntityOwned(this.eos, nodeKey.getId().getValue())) {
LOG.debug("Publish add event for link {}", ld);
- notificationService.publish(ld);
+ try {
+ notificationService.putNotification(ld);
+ } catch (InterruptedException e) {
+ LOG.warn("Interrupted while publishing notification {}", ld, e);
+ }
} else {
LOG.trace("Skip publishing the add event for link because controller is non-owner of the "
+ "node {}. Link : {}", nodeKey.getId().getValue(), ld);
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.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationListener;
import org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationService;
import org.opendaylight.openflowplugin.applications.topology.lldp.utils.LLDPDiscoveryUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkDiscovered;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkRemoved;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkRemovedBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
private final long linkExpirationTime;
private final Map<LinkDiscovered, Date> linkToDate;
private final Timer timer;
- private final NotificationProviderService notificationService;
+ private final NotificationPublishService notificationService;
private final AutoCloseable configurationServiceRegistration;
private final EntityOwnershipService eos;
*/
@Inject
public LLDPLinkAger(final TopologyLldpDiscoveryConfig topologyLldpDiscoveryConfig,
- @Reference final NotificationProviderService notificationService,
+ @Reference final NotificationPublishService notificationService,
@Reference final ConfigurationService configurationService,
@Reference final EntityOwnershipService entityOwnershipService) {
this.linkExpirationTime = topologyLldpDiscoveryConfig.getTopologyLldpExpirationInterval().getValue();
linkToDate.remove(link);
if (nodeKey != null && LLDPDiscoveryUtils.isEntityOwned(eos, nodeKey.getId().getValue())) {
LOG.info("Publish Link Remove event for the link {}", link);
- notificationService.publish(lrb.build());
+ final LinkRemoved lr = lrb.build();
+ try {
+ notificationService.putNotification(lr);
+ } catch (InterruptedException e) {
+ LOG.warn("Interrupted while publishing notification {}", lr, e);
+ }
} else {
LOG.trace("Skip publishing Link Remove event for the link {} because link destination "
+ "node is not owned by the controller", link);
import static org.mockito.Mockito.verify;
import java.util.Optional;
-
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
@Mock
private LinkDiscovered link;
@Mock
- private NotificationProviderService notificationService;
+ private NotificationPublishService notificationService;
@Mock
private EntityOwnershipService eos;
@Mock
public void testLLDPAgingTask() throws InterruptedException {
lldpLinkAger.put(link);
Thread.sleep(SLEEP);
- verify(notificationService).publish(any(LinkRemoved.class));
+ verify(notificationService).putNotification(any(LinkRemoved.class));
}
private TopologyLldpDiscoveryConfig getConfig() {
<artifactId>guava</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-util</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
*/
package org.opendaylight.openflowplugin.applications.topology.manager;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
@SuppressWarnings("checkstyle:IllegalCatch")
public DataTreeChangeListenerImpl(final OperationProcessor operationProcessor, final DataBroker dataBroker,
final InstanceIdentifier<T> ii) {
- final DataTreeIdentifier<T> identifier = new DataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, ii);
+ final DataTreeIdentifier<T> identifier = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, ii);
final SimpleTaskRetryLooper looper = new SimpleTaskRetryLooper(STARTUP_LOOP_TICK, STARTUP_LOOP_MAX_RETRIES);
try {
listenerRegistration = looper.loopUntilNoException(
import static org.opendaylight.openflowplugin.applications.topology.manager.FlowCapableNodeMapping.toTopologyLink;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.common.txchain.TransactionChainManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.FlowTopologyDiscoveryListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkDiscovered;
processor.enqueueOperation(new TopologyOperation() {
@Override
public void applyOperation(final TransactionChainManager manager) {
- Optional<Link> linkOptional = Optional.absent();
+ Optional<Link> linkOptional = Optional.empty();
try {
// read that checks if link exists (if we do not do this we might get an exception on delete)
linkOptional = manager.readFromTransaction(LogicalDatastoreType.OPERATIONAL,
*/
package org.opendaylight.openflowplugin.applications.topology.manager;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
import javax.annotation.PostConstruct;
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.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
static final String TOPOLOGY_ID = "flow:1";
private final DataBroker dataBroker;
- private final NotificationProviderService notificationService;
+ private final NotificationService notificationService;
private final OperationProcessor processor;
private final ClusterSingletonServiceProvider clusterSingletonServiceProvider;
private InstanceIdentifier<Topology> topologyPathIID;
@Inject
public FlowCapableTopologyProvider(@Reference final DataBroker dataBroker,
- @Reference final NotificationProviderService notificationService,
+ @Reference final NotificationService notificationService,
final OperationProcessor processor,
@Reference final ClusterSingletonServiceProvider
clusterSingletonServiceProvider) {
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.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
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.mdsal.binding.api.DataBroker;
import org.opendaylight.openflowplugin.common.txchain.TransactionChainManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final BlockingQueue<TopologyOperation> queue = new LinkedBlockingQueue<>(OPERATION_QUEUE_DEPTH);
private final Thread thread;
- private TransactionChainManager transactionChainManager;
+ private final TransactionChainManager transactionChainManager;
private volatile boolean finishing = false;
@Inject
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.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
.topology.topology.Node>
nodeOptional = Optional.empty();
try {
- nodeOptional = Optional.ofNullable(
- manager.readFromTransaction(LogicalDatastoreType.OPERATIONAL, node).get().orNull());
+ nodeOptional = manager.readFromTransaction(LogicalDatastoreType.OPERATIONAL, node).get();
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Error occurred when trying to read NodeConnector: {}", e.getMessage());
LOG.debug("Error occurred when trying to read NodeConnector.. ", e);
private void removeLinks(final FlowCapableNodeConnector flowCapNodeConnector, final TerminationPoint point) {
operationProcessor.enqueueOperation(manager -> {
- if ((flowCapNodeConnector.getState() != null && flowCapNodeConnector.getState().isLinkDown()) || (
- flowCapNodeConnector.getConfiguration() != null && flowCapNodeConnector.getConfiguration()
- .isPORTDOWN())) {
+ if (flowCapNodeConnector.getState() != null && flowCapNodeConnector.getState().isLinkDown()
+ || flowCapNodeConnector.getConfiguration() != null
+ && flowCapNodeConnector.getConfiguration().isPORTDOWN()) {
TopologyManagerUtil.removeAffectedLinks(point.getTpId(), manager, II_TO_TOPOLOGY);
}
});
*/
package org.opendaylight.openflowplugin.applications.topology.manager;
-import com.google.common.base.Optional;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.common.txchain.TransactionChainManager;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
static void removeAffectedLinks(final NodeId id, final TransactionChainManager manager,
InstanceIdentifier<Topology> topology) {
- Optional<Topology> topologyOptional = Optional.absent();
+ Optional<Topology> topologyOptional = Optional.empty();
try {
topologyOptional = manager.readFromTransaction(LogicalDatastoreType.OPERATIONAL, topology).get();
} catch (InterruptedException | ExecutionException e) {
static void removeAffectedLinks(final TpId id, final TransactionChainManager manager,
final InstanceIdentifier<Topology> topology) {
- Optional<Topology> topologyOptional = Optional.absent();
+ Optional<Topology> topologyOptional = Optional.empty();
try {
topologyOptional = manager.readFromTransaction(LogicalDatastoreType.OPERATIONAL, topology).get();
} catch (InterruptedException | ExecutionException e) {
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-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.DataObjectModification;
-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.controller.md.sal.common.api.data.TransactionChainListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.TransactionChainListener;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortConfig;
@Mock
private DataBroker mockDataBroker;
@Mock
- protected BindingTransactionChain mockTxChain;
+ protected TransactionChain mockTxChain;
@Before
public void setUp() {
return builder.build();
}
- protected <T extends DataObject> DataTreeModification setupDataTreeChange(final ModificationType type,
+ protected <T extends DataObject> DataTreeModification<T> setupDataTreeChange(final ModificationType type,
final InstanceIdentifier<T> ii) {
final DataTreeModification dataTreeModification = mock(DataTreeModification.class);
- final DataTreeIdentifier identifier = new DataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, ii);
+ final DataTreeIdentifier<T> identifier = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, ii);
when(dataTreeModification.getRootNode()).thenReturn(mock(DataObjectModification.class));
when(dataTreeModification.getRootNode().getModificationType()).thenReturn(type);
when(dataTreeModification.getRootPath()).thenReturn(identifier);
* 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.topology.manager;
import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.any;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.opendaylight.openflowplugin.applications.topology.manager.TestUtils.setupStubbedSubmit;
import static org.opendaylight.openflowplugin.applications.topology.manager.TestUtils.waitForSubmit;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
+import java.util.Optional;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-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;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.TransactionChainListener;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkDiscoveredBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkRemovedBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.LinkKey;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class FlowCapableTopologyExporterTest {
@Mock
private DataBroker mockDataBroker;
@Mock
- private BindingTransactionChain mockTxChain;
+ private TransactionChain mockTxChain;
@Before
public void setUp() {
ReadWriteTransaction mockTx = mock(ReadWriteTransaction.class);
final CountDownLatch submitLatch = setupStubbedSubmit(mockTx);
doReturn(mockTx).when(mockTxChain).newReadWriteTransaction();
- doReturn(Futures.immediateCheckedFuture(Optional.of(link))).when(mockTx)
+ doReturn(FluentFutures.immediateFluentFuture(Optional.of(link))).when(mockTx)
.read(LogicalDatastoreType.OPERATIONAL,
topologyIID.child(Link.class, new LinkKey(new LinkId(sourceNodeConnKey.getId()))));
ReadWriteTransaction mockTx = mock(ReadWriteTransaction.class);
final CountDownLatch submitLatch = setupStubbedSubmit(mockTx);
doReturn(mockTx).when(mockTxChain).newReadWriteTransaction();
- doReturn(Futures.immediateCheckedFuture(Optional.<Link>absent())).when(mockTx)
+ doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockTx)
.read(LogicalDatastoreType.OPERATIONAL,
topologyIID.child(Link.class, new LinkKey(new LinkId(sourceNodeConnKey.getId()))));
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.DELETE;
-import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.WRITE;
+import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.DELETE;
+import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.WRITE;
import static org.opendaylight.openflowplugin.applications.topology.manager.TestUtils.assertDeletedIDs;
import static org.opendaylight.openflowplugin.applications.topology.manager.TestUtils.newDestNode;
import static org.opendaylight.openflowplugin.applications.topology.manager.TestUtils.newInvNodeKey;
import static org.opendaylight.openflowplugin.applications.topology.manager.TestUtils.waitForDeletes;
import static org.opendaylight.openflowplugin.applications.topology.manager.TestUtils.waitForSubmit;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.SettableFuture;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.CountDownLatch;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.topology.inventory.rev131030.InventoryNode;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class NodeChangeListenerImplTest extends DataTreeChangeListenerBase {
SettableFuture<Optional<Topology>> readFuture = SettableFuture.create();
readFuture.set(Optional.of(topology));
ReadWriteTransaction mockTx1 = mock(ReadWriteTransaction.class);
- doReturn(Futures.makeChecked(readFuture, ReadFailedException.MAPPER)).when(mockTx1)
- .read(LogicalDatastoreType.OPERATIONAL, topologyIID);
+ doReturn(readFuture).when(mockTx1).read(LogicalDatastoreType.OPERATIONAL, topologyIID);
SettableFuture<Optional<Node>> readFutureNode = SettableFuture.create();
readFutureNode.set(Optional.of(topoNode));
- doReturn(Futures.makeChecked(readFutureNode, ReadFailedException.MAPPER)).when(mockTx1)
- .read(LogicalDatastoreType.OPERATIONAL, topoNodeII);
+ doReturn(readFutureNode).when(mockTx1).read(LogicalDatastoreType.OPERATIONAL, topoNodeII);
final CountDownLatch submitLatch1 = setupStubbedSubmit(mockTx1);
};
ReadWriteTransaction mockTx = mock(ReadWriteTransaction.class);
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockTx)
+ doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockTx)
.read(LogicalDatastoreType.OPERATIONAL, topologyIID);
final CountDownLatch submitLatch = setupStubbedSubmit(mockTx);
- SettableFuture<Optional<Node>> readFutureNode = SettableFuture.create();
- readFutureNode.set(Optional.of(topoNode));
- doReturn(Futures.makeChecked(readFutureNode, ReadFailedException.MAPPER)).when(mockTx)
- .read(LogicalDatastoreType.OPERATIONAL, topoNodeII);
+ doReturn(FluentFutures.immediateFluentFuture(Optional.of(topoNode))).when(mockTx)
+ .read(LogicalDatastoreType.OPERATIONAL, topoNodeII);
CountDownLatch deleteLatch = new CountDownLatch(1);
ArgumentCaptor<InstanceIdentifier> deletedLinkIDs =
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.DELETE;
-import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.WRITE;
+import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.DELETE;
+import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.WRITE;
import static org.opendaylight.openflowplugin.applications.topology.manager.TestUtils.assertDeletedIDs;
import static org.opendaylight.openflowplugin.applications.topology.manager.TestUtils.newDestTp;
import static org.opendaylight.openflowplugin.applications.topology.manager.TestUtils.newInvNodeConnKey;
import static org.opendaylight.openflowplugin.applications.topology.manager.TestUtils.waitForDeletes;
import static org.opendaylight.openflowplugin.applications.topology.manager.TestUtils.waitForSubmit;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.SettableFuture;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.CountDownLatch;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.topology.inventory.rev131030.InventoryNodeConnector;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class TerminationPointChangeListenerImplTest extends DataTreeChangeListenerBase {
final SettableFuture<Optional<Topology>> readFuture = SettableFuture.create();
readFuture.set(Optional.of(topology));
ReadWriteTransaction mockTx1 = mock(ReadWriteTransaction.class);
- doReturn(Futures.makeChecked(readFuture, ReadFailedException.MAPPER)).when(mockTx1)
- .read(LogicalDatastoreType.OPERATIONAL, topologyIID);
+ doReturn(readFuture).when(mockTx1).read(LogicalDatastoreType.OPERATIONAL, topologyIID);
SettableFuture<Optional<Node>> readFutureNode = SettableFuture.create();
readFutureNode.set(Optional.of(topoNode));
- doReturn(Futures.makeChecked(readFutureNode, ReadFailedException.MAPPER)).when(mockTx1)
- .read(LogicalDatastoreType.OPERATIONAL, topoNodeII);
+ doReturn(readFutureNode).when(mockTx1).read(LogicalDatastoreType.OPERATIONAL, topoNodeII);
final CountDownLatch submitLatch1 = setupStubbedSubmit(mockTx1);
};
ReadWriteTransaction mockTx = mock(ReadWriteTransaction.class);
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockTx)
+ doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockTx)
.read(LogicalDatastoreType.OPERATIONAL, topologyIID);
final CountDownLatch submitLatch = setupStubbedSubmit(mockTx);
- SettableFuture<Optional<Node>> readFutureNode = SettableFuture.create();
- readFutureNode.set(Optional.of(topoNode));
- doReturn(Futures.makeChecked(readFutureNode, ReadFailedException.MAPPER)).when(mockTx)
+ doReturn(FluentFutures.immediateFluentFuture(Optional.of(topoNode))).when(mockTx)
.read(LogicalDatastoreType.OPERATIONAL, topoNodeII);
CountDownLatch deleteLatch = new CountDownLatch(1);
Topology topology = new TopologyBuilder().setLink(linkList).build();
ReadWriteTransaction mockTx = mock(ReadWriteTransaction.class);
- doReturn(Futures.immediateCheckedFuture(Optional.of(topology))).when(mockTx)
+ doReturn(FluentFutures.immediateFluentFuture(Optional.of(topology))).when(mockTx)
.read(LogicalDatastoreType.OPERATIONAL, topologyIID);
setupStubbedSubmit(mockTx);
Topology topology = new TopologyBuilder().setLink(linkList).build();
ReadWriteTransaction mockTx = mock(ReadWriteTransaction.class);
- doReturn(Futures.immediateCheckedFuture(Optional.of(topology))).when(mockTx)
+ doReturn(FluentFutures.immediateFluentFuture(Optional.of(topology))).when(mockTx)
.read(LogicalDatastoreType.OPERATIONAL, topologyIID);
setupStubbedSubmit(mockTx);
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.never;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.SettableFuture;
import com.google.common.util.concurrent.Uninterruptibles;
import java.util.HashSet;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
static void verifyMockTx(ReadWriteTransaction mockTx) {
InOrder inOrder = inOrder(mockTx);
- inOrder.verify(mockTx, atLeast(0)).submit();
+ inOrder.verify(mockTx, atLeast(0)).commit();
inOrder.verify(mockTx, never()).delete(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
}
final CountDownLatch latch = new CountDownLatch(1);
doAnswer(invocation -> {
latch.countDown();
- return Futures.immediateCheckedFuture(null);
- }).when(mockTx).submit();
+ return CommitInfo.emptyFluentFuture();
+ }).when(mockTx).commit();
return latch;
}
<artifactId>guava</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.openflowplugin.model</groupId>
package org.opendaylight.openflowplugin.droptestkaraf;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.openflowplugin.testcommon.DropTestDsProvider;
import org.opendaylight.openflowplugin.testcommon.DropTestRpcProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
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" odl:type="pingpong"/>
- <reference id="notificationService" interface="org.opendaylight.controller.md.sal.binding.api.NotificationService"/>
+ <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker" odl:type="pingpong"/>
+ <reference id="notificationService" interface="org.opendaylight.mdsal.binding.api.NotificationService"/>
<odl:rpc-service id="flowService"
interface="org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService"/>
<argument ref="notificationService"/>
<argument ref="flowService"/>
</bean>
-</blueprint>
\ No newline at end of file
+</blueprint>
<artifactId>model-flow-statistics</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>${project.groupId}.openflowjava</groupId>
<groupId>${project.groupId}.openflowjava</groupId>
<artifactId>openflow-protocol-spi</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-api</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-singleton-common-api</artifactId>
* 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.api.openflow;
-import org.opendaylight.controller.md.sal.binding.api.BindingService;
+import org.opendaylight.mdsal.binding.api.BindingService;
/**
* Plugin services provider.
* 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.api.openflow.device;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.OFPContext;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceReplyProcessor;
* 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.api.openflow.device;
import com.google.common.util.concurrent.ListenableFuture;
*/
void initialize();
- ListenableFuture<Void> removeDeviceFromOperationalDS(
- @Nonnull KeyedInstanceIdentifier<Node, NodeKey> ii);
+ ListenableFuture<?> removeDeviceFromOperationalDS(@Nonnull KeyedInstanceIdentifier<Node, NodeKey> ii);
DeviceContext createContext(@Nonnull ConnectionContext connectionContext);
* 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.api.openflow.device;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
* as write transaction in this context.
* @return readOnlyTransaction - Don't forget to close it after finish reading
*/
- ReadOnlyTransaction getReadTransaction();
+ ReadTransaction getReadTransaction();
/**
* Method returns true if transaction chain manager is enabled.
* 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.api.openflow.registry.flow;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.openflowplugin.api.openflow.registry.CommonDeviceRegistry;
* 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.api.openflow.statistics.compatibility;
import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yangtools.yang.common.RpcResult;
/**
<artifactId>slf4j-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. 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.common.txchain;
import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.FluentFuture;
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.MoreExecutors;
import java.util.Objects;
import java.util.concurrent.TimeoutException;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.GuardedBy;
-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;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainClosedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.Transaction;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.TransactionChainClosedException;
+import org.opendaylight.mdsal.binding.api.TransactionChainListener;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
* package protected class for controlling {@link WriteTransaction} life cycle. It is
* a {@link TransactionChainListener} and provide package protected methods for writeToTransaction
* method (wrapped {@link WriteTransaction#put(LogicalDatastoreType, InstanceIdentifier, DataObject)})
- * and submitTransaction method (wrapped {@link WriteTransaction#submit()}).
+ * and submitTransaction method (wrapped {@link WriteTransaction#commit()}).
*/
public class TransactionChainManager implements TransactionChainListener, AutoCloseable {
@GuardedBy("txLock")
private ReadWriteTransaction writeTx;
@GuardedBy("txLock")
- private BindingTransactionChain transactionChain;
+ private TransactionChain transactionChain;
@GuardedBy("txLock")
private boolean submitIsEnabled;
@GuardedBy("txLock")
- private ListenableFuture<Void> lastSubmittedFuture;
+ private FluentFuture<? extends CommitInfo> lastSubmittedFuture;
private volatile boolean initCommit;
@Nonnull final String deviceIdentifier) {
this.dataBroker = dataBroker;
this.nodeId = deviceIdentifier;
- this.lastSubmittedFuture = Futures.immediateFuture(null);
+ this.lastSubmittedFuture = CommitInfo.emptyFluentFuture();
}
@GuardedBy("txLock")
private void createTxChain() {
- BindingTransactionChain txChainFactoryTemp = transactionChain;
+ TransactionChain txChainFactoryTemp = transactionChain;
transactionChain = dataBroker.createTransactionChain(TransactionChainManager.this);
Optional.ofNullable(txChainFactoryTemp).ifPresent(TransactionChain::close);
}
* Call this method for SLAVE only.
* @return Future
*/
- public ListenableFuture<Void> deactivateTransactionManager() {
+ public FluentFuture<?> deactivateTransactionManager() {
if (LOG.isDebugEnabled()) {
LOG.debug("deactivateTransactionManager for node {}", this.nodeId);
}
- final ListenableFuture<Void> future;
+ final FluentFuture<? extends CommitInfo> future;
synchronized (txLock) {
if (TransactionChainManagerStatus.WORKING == transactionChainManagerStatus) {
transactionChainManagerStatus = TransactionChainManagerStatus.SLEEPING;
future = txChainShuttingDown();
Preconditions.checkState(writeTx == null,
"We have some unexpected WriteTransaction.");
- Futures.addCallback(future, new FutureCallback<Void>() {
+ future.addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
closeTransactionChain();
}
}, MoreExecutors.directExecutor());
} else {
// ignoring redundant deactivate invocation
- future = Futures.immediateFuture(null);
+ future = CommitInfo.emptyFluentFuture();
}
}
return future;
Preconditions.checkState(TransactionChainManagerStatus.WORKING == transactionChainManagerStatus,
"we have here Uncompleted Transaction for node {} and we are not MASTER",
this.nodeId);
- final ListenableFuture<Void> submitFuture = writeTx.submit();
+ final FluentFuture<? extends CommitInfo> submitFuture = writeTx.commit();
lastSubmittedFuture = submitFuture;
writeTx = null;
return true;
}
- Futures.addCallback(submitFuture, new FutureCallback<Void>() {
+ submitFuture.addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
//NOOP
}
}
}
- public <T extends DataObject> ListenableFuture<com.google.common.base.Optional<T>>
+ public <T extends DataObject> ListenableFuture<Optional<T>>
readFromTransaction(final LogicalDatastoreType store, final InstanceIdentifier<T> path) {
synchronized (txLock) {
ensureTransaction();
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain,
- final AsyncTransaction<?, ?> transaction, final Throwable cause) {
+ public void onTransactionChainFailed(final TransactionChain chain,
+ final Transaction transaction, final Throwable cause) {
synchronized (txLock) {
if (TransactionChainManagerStatus.WORKING == transactionChainManagerStatus
&& chain.equals(this.transactionChain)) {
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final TransactionChain chain) {
// NOOP
}
}
}
- public ListenableFuture<Void> shuttingDown() {
+ public ListenableFuture<?> shuttingDown() {
if (LOG.isDebugEnabled()) {
LOG.debug("TxManager is going SHUTTING_DOWN for node {}", this.nodeId);
}
}
@GuardedBy("txLock")
- private ListenableFuture<Void> txChainShuttingDown() {
+ private FluentFuture<? extends CommitInfo> txChainShuttingDown() {
boolean wasSubmitEnabled = submitIsEnabled;
submitIsEnabled = false;
- ListenableFuture<Void> future;
+ FluentFuture<? extends CommitInfo> future;
if (!wasSubmitEnabled || transactionChain == null) {
// stay with actual thread
- future = Futures.immediateFuture(null);
+ future = CommitInfo.emptyFluentFuture();
if (writeTx != null) {
writeTx.cancel();
LOG.debug("Submitting all transactions for Node {}", this.nodeId);
}
// hijack md-sal thread
- future = writeTx.submit();
+ future = writeTx.commit();
writeTx = null;
}
<artifactId>model-inventory</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-spi</artifactId>
</dependency>
<dependency>
<groupId>${project.groupId}.openflowjava</groupId>
<artifactId>slf4j-log4j12</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-util</artifactId>
- </dependency>
<dependency>
<groupId>${project.groupId}.openflowjava</groupId>
<artifactId>openflowjava-util</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-api</artifactId>
- </dependency>
<dependency>
<groupId>${project.groupId}.openflowjava</groupId>
<artifactId>openflow-protocol-impl</artifactId>
*/
package org.opendaylight.openflowplugin.impl;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ForwardingDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.spi.ForwardingDataBroker;
/**
* Delegating {@link PingPongDataBroker} implementation.
import javax.management.ObjectName;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.infrautils.diagstatus.ServiceState;
import org.opendaylight.infrautils.ready.SystemReadyListener;
import org.opendaylight.infrautils.ready.SystemReadyMonitor;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProvider;
private final Collection<SwitchConnectionProvider> switchConnectionProviders;
private final DeviceInitializerProvider deviceInitializerProvider;
private final ConvertorManager convertorManager;
- private final RpcProviderRegistry rpcProviderRegistry;
+ private final RpcProviderService rpcProviderRegistry;
private final ClusterSingletonServiceProvider singletonServicesProvider;
private final OpenflowProviderConfig config;
private final EntityOwnershipService entityOwnershipService;
public OpenFlowPluginProviderImpl(final ConfigurationService configurationService,
final SwitchConnectionProviderList switchConnectionProviders,
final PingPongDataBroker pingPongDataBroker,
- final @Reference RpcProviderRegistry rpcProviderRegistry,
+ final @Reference RpcProviderService rpcProviderRegistry,
final @Reference NotificationPublishService notificationPublishService,
final @Reference ClusterSingletonServiceProvider singletonServiceProvider,
final @Reference EntityOwnershipService entityOwnershipService,
*/
package org.opendaylight.openflowplugin.impl;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
/**
* An <code>odl:type="pingpong"</code> {@link DataBroker}.
*
* @author Michael Vorburger.ch
*/
-public interface PingPongDataBroker extends DataBroker {}
+public interface PingPongDataBroker extends DataBroker {
+
+}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.datastore.multipart;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.TxFacade;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yangtools.yang.binding.DataContainer;
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import java.util.concurrent.atomic.AtomicBoolean;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey;
}
@Override
- public ReadOnlyTransaction getReadTransaction() {
+ public ReadTransaction getReadTransaction() {
return dataBroker.newReadOnlyTransaction();
}
}
@Override
- public ListenableFuture<Void> closeServiceInstance() {
- final ListenableFuture<Void> listenableFuture = initialized.get()
+ public ListenableFuture<?> closeServiceInstance() {
+ final ListenableFuture<?> listenableFuture = initialized.get()
? transactionChainManager.deactivateTransactionManager()
: Futures.immediateFuture(null);
deviceFlowRegistry.close();
deviceMeterRegistry.close();
- final ListenableFuture<Void> txChainShuttingDown = transactionChainManager.shuttingDown();
+ final ListenableFuture<?> txChainShuttingDown = transactionChainManager.shuttingDown();
- Futures.addCallback(txChainShuttingDown, new FutureCallback<Void>() {
+ Futures.addCallback(txChainShuttingDown, new FutureCallback<Object>() {
@Override
- public void onSuccess(@Nullable final Void result) {
+ public void onSuccess(final Object result) {
transactionChainManager.close();
transactionChainManager = null;
}
deviceInfo.toString()));
}
- final ListenableFuture<List<com.google.common.base.Optional<FlowCapableNode>>> deviceFlowRegistryFill =
+ final ListenableFuture<List<Optional<FlowCapableNode>>> deviceFlowRegistryFill =
getDeviceFlowRegistry().fill();
Futures.addCallback(deviceFlowRegistryFill,
new DeviceFlowRegistryCallback(deviceFlowRegistryFill, contextChainMastershipWatcher),
hasState.set(true);
}
- private class DeviceFlowRegistryCallback implements FutureCallback<List<com.google.common.base
- .Optional<FlowCapableNode>>> {
- private final ListenableFuture<List<com.google.common.base.Optional<FlowCapableNode>>> deviceFlowRegistryFill;
+ private class DeviceFlowRegistryCallback implements FutureCallback<List<Optional<FlowCapableNode>>> {
+ private final ListenableFuture<List<Optional<FlowCapableNode>>> deviceFlowRegistryFill;
private final ContextChainMastershipWatcher contextChainMastershipWatcher;
DeviceFlowRegistryCallback(
- ListenableFuture<List<com.google.common.base.Optional<FlowCapableNode>>> deviceFlowRegistryFill,
+ ListenableFuture<List<Optional<FlowCapableNode>>> deviceFlowRegistryFill,
ContextChainMastershipWatcher contextChainMastershipWatcher) {
this.deviceFlowRegistryFill = deviceFlowRegistryFill;
this.contextChainMastershipWatcher = contextChainMastershipWatcher;
}
@Override
- public void onSuccess(@Nullable List<com.google.common.base.Optional<FlowCapableNode>> result) {
+ public void onSuccess(@Nullable List<Optional<FlowCapableNode>> result) {
if (LOG.isDebugEnabled()) {
// Count all flows we read from datastore for debugging purposes.
// This number do not always represent how many flows were actually added
.stream()
.flatMap(Collection::stream)
.filter(Objects::nonNull)
- .flatMap(flowCapableNodeOptional -> flowCapableNodeOptional.asSet().stream())
+ .flatMap(flowCapableNodeOptional
+ -> com.google.common.base.Optional.fromJavaUtil(flowCapableNodeOptional).asSet().stream())
.filter(Objects::nonNull)
.filter(flowCapableNode -> Objects.nonNull(flowCapableNode.getTable()))
.flatMap(flowCapableNode -> flowCapableNode.getTable().stream())
import java.util.concurrent.ScheduledThreadPoolExecutor;
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.NotificationPublishService;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueueHandlerRegistration;
import org.opendaylight.openflowplugin.api.openflow.OFPContext;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
}
@Override
- public ListenableFuture<Void> removeDeviceFromOperationalDS(
- @Nonnull final KeyedInstanceIdentifier<Node, NodeKey> ii) {
+ public ListenableFuture<?> removeDeviceFromOperationalDS(@Nonnull final KeyedInstanceIdentifier<Node, NodeKey> ii) {
final WriteTransaction delWtx = dataBroker.newWriteOnlyTransaction();
delWtx.delete(LogicalDatastoreType.OPERATIONAL, ii);
- return delWtx.submit();
+ return delWtx.commit();
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.device.initialization;
import com.google.common.base.Preconditions;
import java.util.concurrent.Future;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.ConnectionException;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.impl.datastore.MultipartWriterProvider;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.device.initialization;
import com.google.common.base.Function;
import java.util.concurrent.Future;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
package org.opendaylight.openflowplugin.impl.registry.flow;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.Maps;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
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.MoreExecutors;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.ThreadSafe;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.openflowplugin.api.openflow.registry.flow.DeviceFlowRegistry;
import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowDescriptor;
import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowRegistryKey;
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.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.GeneralAugMatchNodesNodeTableFlow;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.slf4j.Logger;
final InstanceIdentifier<FlowCapableNode> path = instanceIdentifier.augmentation(FlowCapableNode.class);
// First, try to fill registry with flows from DS/Configuration
- final CheckedFuture<Optional<FlowCapableNode>, ReadFailedException> configFuture =
+ final FluentFuture<Optional<FlowCapableNode>> configFuture =
fillFromDatastore(LogicalDatastoreType.CONFIGURATION, path);
// Now, try to fill registry with flows from DS/Operational
// in case of cluster fail over, when clients are not using DS/Configuration
// for adding flows, but only RPCs
- final CheckedFuture<Optional<FlowCapableNode>, ReadFailedException> operationalFuture =
+ final FluentFuture<Optional<FlowCapableNode>> operationalFuture =
fillFromDatastore(LogicalDatastoreType.OPERATIONAL, path);
// And at last, chain and return futures created above.
return lastFillFuture;
}
- private CheckedFuture<Optional<FlowCapableNode>, ReadFailedException>
- fillFromDatastore(final LogicalDatastoreType logicalDatastoreType,
+ private FluentFuture<Optional<FlowCapableNode>> fillFromDatastore(final LogicalDatastoreType logicalDatastoreType,
final InstanceIdentifier<FlowCapableNode> path) {
// Create new read-only transaction
- final ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
+ final ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
// Bail out early if transaction is null
if (transaction == null) {
- return Futures.immediateFailedCheckedFuture(
+ return FluentFutures.immediateFailedFluentFuture(
new ReadFailedException("Read transaction is null"));
}
// Prepare read operation from datastore for path
- final CheckedFuture<Optional<FlowCapableNode>, ReadFailedException> future =
- transaction.read(logicalDatastoreType, path);
+ final FluentFuture<Optional<FlowCapableNode>> future = transaction.read(logicalDatastoreType, path);
// Bail out early if future is null
if (future == null) {
- return Futures.immediateFailedCheckedFuture(
+ return FluentFutures.immediateFailedFluentFuture(
new ReadFailedException("Future from read transaction is null"));
}
- Futures.addCallback(future, new FutureCallback<Optional<FlowCapableNode>>() {
+ future.addCallback(new FutureCallback<Optional<FlowCapableNode>>() {
@Override
public void onSuccess(@Nonnull Optional<FlowCapableNode> result) {
- result.asSet().stream()
+ result.map(Collections::singleton).orElse(Collections.emptySet()).stream()
.filter(Objects::nonNull)
.filter(flowCapableNode -> Objects.nonNull(flowCapableNode.getTable()))
.flatMap(flowCapableNode -> flowCapableNode.getTable().stream())
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Function;
+import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterators;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.Semaphore;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.extension.api.core.extension.ExtensionConverterProvider;
import org.opendaylight.openflowplugin.impl.util.MdSalRegistrationUtils;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeContext;
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.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.slf4j.Logger;
class RpcContextImpl implements RpcContext {
private static final Logger LOG = LoggerFactory.getLogger(RpcContextImpl.class);
- private final RpcProviderRegistry rpcProviderRegistry;
+ private final RpcProviderService rpcProviderRegistry;
private final MessageSpy messageSpy;
private final Semaphore tracker;
- private boolean isStatisticsRpcEnabled;
+ private final boolean isStatisticsRpcEnabled;
// TODO: add private Sal salBroker
- private final ConcurrentMap<Class<?>, RoutedRpcRegistration<?>> rpcRegistrations = new ConcurrentHashMap<>();
+ private final ConcurrentMap<Class<?>, ObjectRegistration<? extends RpcService>> rpcRegistrations =
+ new ConcurrentHashMap<>();
private final KeyedInstanceIdentifier<Node, NodeKey> nodeInstanceIdentifier;
private final DeviceInfo deviceInfo;
private final DeviceContext deviceContext;
private final NotificationPublishService notificationPublishService;
private ContextChainMastershipWatcher contextChainMastershipWatcher;
- RpcContextImpl(@Nonnull final RpcProviderRegistry rpcProviderRegistry,
+ RpcContextImpl(@Nonnull final RpcProviderService rpcProviderRegistry,
final int maxRequests,
@Nonnull final DeviceContext deviceContext,
@Nonnull final ExtensionConverterProvider extensionConverterProvider,
public <S extends RpcService> void registerRpcServiceImplementation(final Class<S> serviceClass,
final S serviceInstance) {
if (!rpcRegistrations.containsKey(serviceClass)) {
- final RoutedRpcRegistration<S> routedRpcReg =
- rpcProviderRegistry.addRoutedRpcImplementation(serviceClass, serviceInstance);
- routedRpcReg.registerPath(NodeContext.class, nodeInstanceIdentifier);
+ final ObjectRegistration<S> routedRpcReg = rpcProviderRegistry.registerRpcImplementation(serviceClass,
+ serviceInstance, ImmutableSet.of(nodeInstanceIdentifier));
rpcRegistrations.put(serviceClass, routedRpcReg);
if (LOG.isDebugEnabled()) {
LOG.debug("Registration of service {} for device {}.",
@Override
public <S extends RpcService> S lookupRpcService(final Class<S> serviceClass) {
- RoutedRpcRegistration<?> registration = rpcRegistrations.get(serviceClass);
+ ObjectRegistration<? extends RpcService> registration = rpcRegistrations.get(serviceClass);
final RpcService rpcService = registration.getInstance();
return serviceClass.cast(rpcService);
}
}
private void unregisterRPCs() {
- for (final Iterator<Entry<Class<?>, RoutedRpcRegistration<?>>> iterator = Iterators
+ for (final Iterator<Entry<Class<?>, ObjectRegistration<? extends RpcService>>> iterator = Iterators
.consumingIterator(rpcRegistrations.entrySet().iterator()); iterator.hasNext(); ) {
- final RoutedRpcRegistration<?> rpcRegistration = iterator.next().getValue();
- rpcRegistration.unregisterPath(NodeContext.class, nodeInstanceIdentifier);
+ final ObjectRegistration<? extends RpcService> rpcRegistration = iterator.next().getValue();
rpcRegistration.close();
if (LOG.isDebugEnabled()) {
LOG.debug("Closing RPC Registration of service {} for device {}.",
- rpcRegistration.getServiceType().getSimpleName(),
+ rpcRegistration.getInstance().getClass().getSimpleName(),
nodeInstanceIdentifier.getKey().getId().getValue());
}
}
public <S extends RpcService> void unregisterRpcServiceImplementation(final Class<S> serviceClass) {
LOG.trace("Try to unregister serviceClass {} for Node {}",
serviceClass, nodeInstanceIdentifier.getKey().getId());
- final RoutedRpcRegistration<?> rpcRegistration = rpcRegistrations.remove(serviceClass);
+ final ObjectRegistration<? extends RpcService> rpcRegistration = rpcRegistrations.remove(serviceClass);
if (rpcRegistration != null) {
- rpcRegistration.unregisterPath(NodeContext.class, nodeInstanceIdentifier);
rpcRegistration.close();
LOG.debug("Un-registration serviceClass {} for Node {}", serviceClass.getSimpleName(),
nodeInstanceIdentifier.getKey().getId().getValue());
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.rpc.RpcContext;
private static final Logger LOG = LoggerFactory.getLogger(RpcManagerImpl.class);
private final OpenflowProviderConfig config;
- private final RpcProviderRegistry rpcProviderRegistry;
+ private final RpcProviderService rpcProviderRegistry;
private final ConcurrentMap<DeviceInfo, RpcContext> contexts = new ConcurrentHashMap<>();
private final ExtensionConverterProvider extensionConverterProvider;
private final ConvertorExecutor convertorExecutor;
private final NotificationPublishService notificationPublishService;
public RpcManagerImpl(final OpenflowProviderConfig config,
- final RpcProviderRegistry rpcProviderRegistry,
+ final RpcProviderService rpcProviderRegistry,
final ExtensionConverterProvider extensionConverterProvider,
final ConvertorExecutor convertorExecutor,
final NotificationPublishService notificationPublishService) {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics;
import com.google.common.base.Function;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import java.util.Date;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;
-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.TransactionChainClosedException;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.TransactionChainClosedException;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceRegistry;
import org.opendaylight.openflowplugin.api.openflow.device.TxFacade;
}
final ListenableFuture<Optional<FlowCapableNode>> future;
- try (ReadOnlyTransaction readTx = txFacade.getReadTransaction()) {
+ try (ReadTransaction readTx = txFacade.getReadTransaction()) {
future = readTx.read(LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics;
import com.google.common.base.Preconditions;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Semaphore;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.statistics.StatisticsContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.sm.control.rev150812.GetStatisticsWorkModeOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.sm.control.rev150812.StatisticsManagerControlService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.sm.control.rev150812.StatisticsWorkMode;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
private final ConvertorExecutor converterExecutor;
private final ConcurrentMap<DeviceInfo, StatisticsContext> contexts = new ConcurrentHashMap<>();
private final Semaphore workModeGuard = new Semaphore(1, true);
- private final BindingAwareBroker.RpcRegistration<StatisticsManagerControlService> controlServiceRegistration;
+ private final ObjectRegistration<StatisticsManagerControlService> controlServiceRegistration;
private final ListeningExecutorService executorService;
private final StatisticsWorkMode workMode = StatisticsWorkMode.COLLECTALL;
private boolean isStatisticsFullyDisabled;
public StatisticsManagerImpl(@Nonnull final OpenflowProviderConfig config,
- @Nonnull final RpcProviderRegistry rpcProviderRegistry,
+ @Nonnull final RpcProviderService rpcProviderRegistry,
final ConvertorExecutor convertorExecutor,
@Nonnull final ListeningExecutorService executorService) {
this.config = config;
this.converterExecutor = convertorExecutor;
this.controlServiceRegistration = Preconditions.checkNotNull(rpcProviderRegistry
- .addRpcImplementation(StatisticsManagerControlService.class, this));
+ .registerRpcImplementation(StatisticsManagerControlService.class, this));
this.executorService = executorService;
}
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.atomic.AtomicLong;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.atomic.AtomicLong;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.atomic.AtomicLong;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.GetAllNodeConnectorsStatisticsInput;
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.atomic.AtomicLong;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.GetAllQueuesStatisticsFromAllPortsInput;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.services.compatibility;
import com.google.common.util.concurrent.FutureCallback;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.atomic.AtomicLong;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.impl.statistics.services.AggregateFlowsInTableService;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.util;
import java.net.InetSocketAddress;
import java.util.Collections;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.device.TxFacade;
tx.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class), new NodesBuilder()
.setNode(Collections.emptyList())
.build());
- tx.submit().get();
+ tx.commit().get();
} catch (ExecutionException | InterruptedException e) {
LOG.error("Creation of node failed.", e);
throw new IllegalStateException(e);
import com.google.common.base.Preconditions;
import java.util.concurrent.atomic.AtomicLong;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.rpc.RpcContext;
import org.opendaylight.openflowplugin.api.openflow.statistics.compatibility.Delegator;
</bean>
<service ref="configurationService" interface="org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationService"/>
- <reference id="ppDB" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker" odl:type="pingpong"/>
+ <reference id="ppDB" interface="org.opendaylight.mdsal.binding.api.DataBroker" odl:type="pingpong"/>
<bean id="pingPongDataBroker" class="org.opendaylight.openflowplugin.impl.ForwardingPingPongDataBroker">
<argument ref="ppDB"/>
</bean>
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.infrautils.ready.SystemReadyMonitor;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListenerRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationService;
import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.sm.control.rev150812.StatisticsManagerControlService;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
@RunWith(MockitoJUnitRunner.class)
public class OpenFlowPluginProviderImplTest {
PingPongDataBroker dataBroker;
@Mock
- RpcProviderRegistry rpcProviderRegistry;
+ RpcProviderService rpcProviderRegistry;
@Mock
NotificationPublishService notificationPublishService;
EntityOwnershipListenerRegistration entityOwnershipListenerRegistration;
@Mock
- BindingAwareBroker.RpcRegistration<StatisticsManagerControlService> controlServiceRegistration;
+ ObjectRegistration<StatisticsManagerControlService> controlServiceRegistration;
@Mock
SwitchConnectionProvider switchConnectionProvider;
@Before
public void setUp() throws Exception {
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
- when(writeTransaction.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(CommitInfo.emptyFluentFuture()).when(writeTransaction).commit();
when(entityOwnershipService.registerListener(any(), any())).thenReturn(entityOwnershipListenerRegistration);
- when(rpcProviderRegistry.addRpcImplementation(eq(StatisticsManagerControlService.class), any()))
+ when(rpcProviderRegistry.registerRpcImplementation(eq(StatisticsManagerControlService.class), any()))
.thenReturn(controlServiceRegistration);
when(switchConnectionProvider.startup()).thenReturn(Futures.immediateFuture(true));
when(switchConnectionProvider.shutdown()).thenReturn(Futures.immediateFuture(true));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.device;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import io.netty.util.HashedWheelTimer;
import java.math.BigInteger;
+import java.util.Optional;
import java.util.concurrent.atomic.AtomicLong;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.NotificationPublishService;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceivedBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.role.service.rev150727.SalRoleService;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
@Mock
private ReadWriteTransaction writeTx;
@Mock
- private ReadOnlyTransaction readTx;
+ private ReadTransaction readTx;
@Mock
- private BindingTransactionChain txChainFactory;
+ private TransactionChain txChainFactory;
@Mock
private HashedWheelTimer timer;
@Mock
@Before
public void setUp() throws Exception {
- final CheckedFuture<Optional<Node>, ReadFailedException> noExistNodeFuture =
- Futures.immediateCheckedFuture(Optional.<Node>absent());
+ final FluentFuture<Optional<Node>> noExistNodeFuture =
+ FluentFutures.immediateFluentFuture(Optional.<Node>empty());
Mockito.lenient().when(readTx.read(LogicalDatastoreType.OPERATIONAL, nodeKeyIdent))
.thenReturn(noExistNodeFuture);
Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(readTx);
@Test
public void testInitialSubmitTransaction() throws Exception {
- Mockito.when(writeTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ Mockito.doReturn(CommitInfo.emptyFluentFuture()).when(writeTx).commit();
final InstanceIdentifier<Nodes> dummyII = InstanceIdentifier.create(Nodes.class);
((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
((DeviceContextImpl) deviceContext).getTransactionChainManager().initialSubmitWriteTransaction();
deviceContext.addDeleteToTxChain(LogicalDatastoreType.CONFIGURATION, dummyII);
deviceContext.initialSubmitTransaction();
- verify(writeTx).submit();
+ verify(writeTx).commit();
}
private ConnectionContext prepareConnectionContext() {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.device;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
import io.netty.util.HashedWheelTimer;
import java.lang.reflect.Field;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.NotificationPublishService;
-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.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.NonZeroUint16Type;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.NonZeroUint32Type;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.OpenflowProviderConfigBuilder;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
@RunWith(MockitoJUnitRunner.class)
.createNodeInstanceIdentifier(DUMMY_NODE_ID);
@Mock
- private CheckedFuture<Void, TransactionCommitFailedException> mockedFuture;
+ private FluentFuture<CommitInfo> mockedFuture;
@Mock
private FeaturesReply mockFeatures;
@Mock
@Mock
private WriteTransaction writeTransaction;
@Mock
- private BindingTransactionChain transactionChain;
+ private TransactionChain transactionChain;
@Mock
private Capabilities capabilities;
@Mock
when(deviceInfo.getNodeId()).thenReturn(DUMMY_NODE_ID);
when(mockedFuture.isDone()).thenReturn(true);
- when(writeTransaction.submit()).thenReturn(mockedFuture);
+ doReturn(mockedFuture).when(writeTransaction).commit();
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
deviceManager = new DeviceManagerImpl(
deviceManager.setTranslatorLibrary(translatorLibrary);
verify(dataBroker).newWriteOnlyTransaction();
verify(writeTransaction).merge(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
- verify(writeTransaction).submit();
+ verify(writeTransaction).commit();
}
@Test
@Test
public void removeDeviceFromOperationalDS() throws Exception {
- final ListenableFuture<Void> future = deviceManager
+ final ListenableFuture<?> future = deviceManager
.removeDeviceFromOperationalDS(DUMMY_IDENTIFIER);
future.get();
@Test(expected = ExecutionException.class)
public void removeDeviceFromOperationalDSException() throws Exception {
- final CheckedFuture<Void, TransactionCommitFailedException> failedFuture =
- Futures.immediateFailedCheckedFuture(
+ final FluentFuture<CommitInfo> failedFuture = FluentFutures.immediateFailedFluentFuture(
new TransactionCommitFailedException("Test failed transaction"));
- Mockito.when(writeTransaction.submit()).thenReturn(failedFuture);
- final ListenableFuture<Void> future = deviceManager
- .removeDeviceFromOperationalDS(DUMMY_IDENTIFIER);
+ Mockito.doReturn(failedFuture).when(writeTransaction).commit();
+ final ListenableFuture<?> future = deviceManager.removeDeviceFromOperationalDS(DUMMY_IDENTIFIER);
future.get();
assertTrue(future.isDone());
verify(writeTransaction).delete(LogicalDatastoreType.OPERATIONAL, DUMMY_IDENTIFIER);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.device;
import static org.mockito.ArgumentMatchers.any;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.Transaction;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.TransactionChainListener;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.common.txchain.TransactionChainManager;
import org.opendaylight.openflowplugin.impl.util.DeviceStateUtil;
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.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
@Mock
private DataBroker dataBroker;
@Mock
- private BindingTransactionChain txChain;
+ private TransactionChain txChain;
@Mock
private ReadWriteTransaction writeTx;
@Mock
- private TransactionChain<?, ?> transactionChain;
+ private TransactionChain transactionChain;
@Mock
DeviceInfo deviceInfo;
@Before
public void setUp() throws Exception {
- final ReadOnlyTransaction readOnlyTx = Mockito.mock(ReadOnlyTransaction.class);
- final CheckedFuture<Optional<Node>, ReadFailedException> noExistNodeFuture = Futures
- .immediateCheckedFuture(Optional.<Node>absent());
+ final ReadTransaction readOnlyTx = Mockito.mock(ReadTransaction.class);
Mockito.when(dataBroker.createTransactionChain(any(TransactionChainListener.class)))
.thenReturn(txChain);
nodeId = new NodeId("h2g2:42");
Mockito.when(txChain.newReadWriteTransaction()).thenReturn(writeTx);
path = InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(nodeId));
- Mockito.when(writeTx.submit())
- .thenReturn(Futures.<Void, TransactionCommitFailedException>immediateCheckedFuture(null));
+ Mockito.doReturn(CommitInfo.emptyFluentFuture()).when(writeTx).commit();
txChainManager.activateTransactionManager();
}
Mockito.verify(txChain).newReadWriteTransaction();
Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
- Mockito.verify(writeTx).submit();
+ Mockito.verify(writeTx).commit();
}
/**
Mockito.verify(txChain).newReadWriteTransaction();
Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
- Mockito.verify(writeTx, Mockito.never()).submit();
+ Mockito.verify(writeTx, Mockito.never()).commit();
}
@Test
public void testSubmitTransactionFailed() throws Exception {
- Mockito.when(writeTx.submit()).thenReturn(
- Futures.<Void, TransactionCommitFailedException>immediateFailedCheckedFuture(
- new TransactionCommitFailedException("mock")));
+ Mockito.doReturn(FluentFutures.immediateFailedFluentFuture(new TransactionCommitFailedException("mock")))
+ .when(writeTx).commit();
final Node data = new NodeBuilder().setId(nodeId).build();
txChainManager.initialSubmitWriteTransaction();
txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
Mockito.verify(txChain).newReadWriteTransaction();
Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
- Mockito.verify(writeTx).submit();
+ Mockito.verify(writeTx).commit();
}
/**
Mockito.verify(txChain).newReadWriteTransaction();
Mockito.verify(writeTx, Mockito.times(2)).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
- Mockito.verify(writeTx, Mockito.never()).submit();
+ Mockito.verify(writeTx, Mockito.never()).commit();
}
@Test
public void testOnTransactionChainFailed() throws Exception {
- txChainManager
- .onTransactionChainFailed(txChain, Mockito.mock(AsyncTransaction.class), Mockito.mock(Throwable.class));
+ txChainManager.onTransactionChainFailed(txChain, Mockito.mock(Transaction.class),
+ Mockito.mock(Throwable.class));
Mockito.verify(txChain).close();
Mockito.verify(dataBroker, Mockito.times(2)).createTransactionChain(txChainManager);
}
Mockito.verify(txChain).newReadWriteTransaction();
Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
- Mockito.verify(writeTx, Mockito.never()).submit();
+ Mockito.verify(writeTx, Mockito.never()).commit();
Mockito.verify(writeTx).cancel();
Mockito.verify(txChain).close();
}
Mockito.verify(txChain).newReadWriteTransaction();
Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
- Mockito.verify(writeTx).submit();
+ Mockito.verify(writeTx).commit();
}
@Test
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.device.initialization;
import static org.mockito.ArgumentMatchers.any;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.connection.OutboundQueueProvider;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.device.initialization;
import static org.mockito.ArgumentMatchers.any;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.connection.OutboundQueueProvider;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.registry.flow;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.inOrder;
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 com.google.common.util.concurrent.Futures;
import java.math.BigInteger;
import java.util.Collections;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.junit.runner.RunWith;
import org.mockito.InOrder;
import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-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.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowDescriptor;
import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowRegistryKey;
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.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
@Mock
private DataBroker dataBroker;
@Mock
- private ReadOnlyTransaction readOnlyTransaction;
+ private ReadTransaction readOnlyTransaction;
@Before
public void setUp() throws Exception {
private Map<FlowRegistryKey, FlowDescriptor> fillRegistry(final InstanceIdentifier<FlowCapableNode> path,
final FlowCapableNode flowCapableNode) throws Exception {
- when(readOnlyTransaction.read(any(), any()))
- .thenReturn(Futures.immediateCheckedFuture(Optional.fromNullable(flowCapableNode)));
+ doReturn(FluentFutures.immediateFluentFuture(Optional.ofNullable(flowCapableNode))).when(readOnlyTransaction)
+ .read(any(), any());
deviceFlowRegistry.fill().get();
return deviceFlowRegistry.getAllFlowDescriptors();
}
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import static org.mockito.ArgumentMatchers.anySet;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.collect.ImmutableSet;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageSpy;
import org.opendaylight.openflowplugin.extension.api.core.extension.ExtensionConverterProvider;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
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.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcService;
@Mock
- private RpcProviderRegistry rpcProviderRegistry;
+ private RpcProviderService rpcProviderRegistry;
@Mock
private DeviceState deviceState;
@Mock
@Mock
private DeviceContext deviceContext;
@Mock
- private BindingAwareBroker.RoutedRpcRegistration<TestRpcService> routedRpcReg;
+ private ObjectRegistration<TestRpcService> routedRpcReg;
@Mock
private NotificationPublishService notificationPublishService;
convertorExecutor,
notificationPublishService, true);
- when(rpcProviderRegistry.addRoutedRpcImplementation(TestRpcService.class, serviceInstance))
+ when(rpcProviderRegistry.registerRpcImplementation(eq(TestRpcService.class), eq(serviceInstance), anySet()))
.thenReturn(routedRpcReg);
}
public void testRegisterRpcServiceImplementation() {
rpcContext.registerRpcServiceImplementation(TestRpcService.class, serviceInstance);
- verify(rpcProviderRegistry, Mockito.times(1)).addRoutedRpcImplementation(TestRpcService.class,serviceInstance);
- verify(routedRpcReg,Mockito.times(1)).registerPath(NodeContext.class,nodeInstanceIdentifier);
+ verify(rpcProviderRegistry, Mockito.times(1)).registerRpcImplementation(TestRpcService.class, serviceInstance,
+ ImmutableSet.of(nodeInstanceIdentifier));
assertEquals(rpcContext.isEmptyRpcRegistrations(), false);
}
@Test
public void testClose() {
- Class<TestRpcService> serviceClass = TestRpcService.class;
- when(routedRpcReg.getServiceType()).thenReturn(serviceClass);
+ when(routedRpcReg.getInstance()).thenReturn(serviceInstance);
rpcContext.registerRpcServiceImplementation(TestRpcService.class, serviceInstance);
rpcContext.close();
assertEquals(rpcContext.isEmptyRpcRegistrations(), true);
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.NonZeroUint16Type;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.OpenflowProviderConfigBuilder;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcService;
-
@RunWith(MockitoJUnitRunner.class)
public class RpcManagerImplTest {
private RpcManagerImpl rpcManager;
@Mock
- private RpcProviderRegistry rpcProviderRegistry;
+ private RpcProviderService rpcProviderRegistry;
@Mock
private DeviceContext deviceContext;
@Mock
- private BindingAwareBroker.RoutedRpcRegistration<RpcService> routedRpcRegistration;
+ private ObjectRegistration<RpcService> routedRpcRegistration;
@Mock
private DeviceState deviceState;
@Mock
import static org.mockito.Mockito.when;
import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
@Mock
private FlowDescriptor mockedFlowDescriptor;
@Mock
- private ReadOnlyTransaction mockedReadOnlyTx;
+ private ReadTransaction mockedReadOnlyTx;
private AbstractRequestContext<List<MultipartReply>> dummyRequestContext;
private final EventIdentifier dummyEventIdentifier = new EventIdentifier(DUMMY_EVENT_NAME, DUMMY_DEVICE_ID);
final FlowCapableNodeBuilder flowNodeBuilder = new FlowCapableNodeBuilder();
flowNodeBuilder.setTable(Collections.<Table>emptyList());
final Optional<FlowCapableNode> flowNodeOpt = Optional.of(flowNodeBuilder.build());
- final CheckedFuture<Optional<FlowCapableNode>, ReadFailedException> flowNodeFuture =
- Futures.immediateCheckedFuture(flowNodeOpt);
dummyRequestContext = new AbstractRequestContext<List<MultipartReply>>(DUMMY_XID) {
@Override
tableDataBld.setId(tableId);
flowNodeBuilder.setTable(Collections.singletonList(tableDataBld.build()));
final Optional<FlowCapableNode> flowNodeOpt = Optional.of(flowNodeBuilder.build());
- final CheckedFuture<Optional<FlowCapableNode>, ReadFailedException> flowNodeFuture = Futures
- .immediateCheckedFuture(flowNodeOpt);
multipartRequestOnTheFlyCallback.onSuccess(mpReplyMessage.build());
import org.junit.runner.RunWith;
import org.mockito.Matchers;
import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueue;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.stubbing.Answer;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.EventIdentifier;
import org.opendaylight.openflowplugin.impl.datastore.MultipartWriterProviderFactory;
import org.opendaylight.openflowplugin.impl.services.ServiceMocking;
public class SalTableServiceImplTest extends ServiceMocking {
@Mock
- RpcProviderRegistry mockedRpcProviderRegistry;
+ RpcProviderService mockedRpcProviderRegistry;
private SettableFuture<Object> handleResultFuture;
private SalTableServiceImpl salTableService;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
-
-class StatisticsContextImpMockInitiation {
+public class StatisticsContextImpMockInitiation {
Boolean isTable = false;
Boolean isFlow = false;
Boolean isGroup = false;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics;
import static org.junit.Assert.assertEquals;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.EventIdentifier;
import org.opendaylight.openflowplugin.impl.datastore.MultipartWriterProviderFactory;
private StatisticsContextImpl<MultipartReply> statisticsContext;
private ConvertorManager convertorManager;
@Mock
- private OpenflowProviderConfig config =
+ private final OpenflowProviderConfig config =
Mockito.mock(OpenflowProviderConfig.class);
@Before
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-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.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.table._case.multipart.reply.table.TableStatsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.flow.capable.node.connector.statistics.FlowCapableNodeConnectorStatistics;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-
@RunWith(MockitoJUnitRunner.class)
public class StatisticsGatheringUtilsTest {
@Mock
private GetFeaturesOutput features;
@Mock
- private ReadOnlyTransaction readTx;
+ private ReadTransaction readTx;
@Mock
private ConnectionContext connectionAdapter;
@Mock
final FlowCapableNodeBuilder flowNodeBuilder = new FlowCapableNodeBuilder();
flowNodeBuilder.setTable(Collections.singletonList(tableDataBld.build()));
final Optional<FlowCapableNode> flowNodeOpt = Optional.of(flowNodeBuilder.build());
- final CheckedFuture<Optional<FlowCapableNode>, ReadFailedException> flowNodeFuture =
- Futures.immediateCheckedFuture(flowNodeOpt);
- when(readTx.read(LogicalDatastoreType.OPERATIONAL, nodePath)).thenReturn(flowNodeFuture);
+ doReturn(FluentFutures.immediateFluentFuture(flowNodeOpt)).when(readTx)
+ .read(LogicalDatastoreType.OPERATIONAL, nodePath);
when(flowDescriptor.getFlowId()).thenReturn(flowId);
final org.opendaylight.yang.gen.v1.urn
final FlowCapableNodeBuilder flowNodeBuilder = new FlowCapableNodeBuilder();
flowNodeBuilder.setTable(Collections.singletonList(tableDataBld.build()));
final Optional<FlowCapableNode> flowNodeOpt = Optional.of(flowNodeBuilder.build());
- final CheckedFuture<Optional<FlowCapableNode>, ReadFailedException> flowNodeFuture =
- Futures.immediateCheckedFuture(flowNodeOpt);
- when(readTx.read(LogicalDatastoreType.OPERATIONAL, nodePath)).thenReturn(flowNodeFuture);
+ doReturn(FluentFutures.immediateFluentFuture(flowNodeOpt)).when(readTx)
+ .read(LogicalDatastoreType.OPERATIONAL, nodePath);
StatisticsGatheringUtils.deleteAllKnownFlows(deviceContext, deviceInfo.getNodeInstanceIdentifier()
.augmentation(FlowCapableNode.class), deviceFlowRegistry);
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueue;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.sm.control.rev150812.GetStatisticsWorkModeOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.sm.control.rev150812.StatisticsManagerControlService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.sm.control.rev150812.StatisticsWorkMode;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
@RunWith(MockitoJUnitRunner.class)
public class StatisticsManagerImplTest {
@Mock
private DeviceInfo mockedDeviceInfo;
@Mock
- private RpcProviderRegistry rpcProviderRegistry;
+ private RpcProviderService rpcProviderRegistry;
@Mock
private OutboundQueue outboundQueue;
@Mock
private MultiMsgCollector multiMagCollector;
@Mock
- private BindingAwareBroker.RpcRegistration<StatisticsManagerControlService> serviceControlRegistration;
+ private ObjectRegistration<StatisticsManagerControlService> serviceControlRegistration;
@Mock
private DeviceInfo deviceInfo;
@Mock
.create(Nodes.class)
.child(Node.class, new NodeKey(new NodeId("openflow:10")));
- when(rpcProviderRegistry.addRpcImplementation(
+ when(rpcProviderRegistry.registerRpcImplementation(
eq(StatisticsManagerControlService.class),
- ArgumentMatchers.<StatisticsManagerControlService>any())).thenReturn(serviceControlRegistration);
+ ArgumentMatchers.any())).thenReturn(serviceControlRegistration);
final ConvertorManager convertorManager = ConvertorManagerFactory.createDefaultManager();
final long basicTimerDelay = 3000L;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.services;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.stubbing.Answer;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
import org.opendaylight.openflowplugin.impl.rpc.AbstractRequestContext;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.stubbing.Answer;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.services.compatibility;
import static org.mockito.ArgumentMatchers.any;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.services.direct.multilayer;
import static org.junit.Assert.assertEquals;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.api.openflow.registry.flow.DeviceFlowRegistry;
import org.opendaylight.openflowplugin.impl.registry.flow.FlowDescriptorFactory;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.services.direct.multilayer;
import static org.junit.Assert.assertEquals;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.impl.statistics.services.direct.AbstractDirectStatisticsServiceTest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetGroupStatisticsInput;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.services.direct.multilayer;
import static org.junit.Assert.assertEquals;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.impl.statistics.services.direct.AbstractDirectStatisticsServiceTest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetMeterStatisticsInput;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.services.direct.multilayer;
import static org.junit.Assert.assertEquals;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.impl.statistics.services.direct.AbstractDirectStatisticsServiceTest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetNodeConnectorStatisticsInput;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.services.direct.multilayer;
import static org.junit.Assert.assertEquals;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.impl.statistics.services.direct.AbstractDirectStatisticsServiceTest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetQueueStatisticsInput;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.services.direct.singlelayer;
import static org.junit.Assert.assertEquals;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.api.openflow.registry.flow.DeviceFlowRegistry;
import org.opendaylight.openflowplugin.impl.registry.flow.FlowDescriptorFactory;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.services.direct.singlelayer;
import static org.junit.Assert.assertEquals;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.impl.statistics.services.direct.AbstractDirectStatisticsServiceTest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetGroupStatisticsInput;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.services.direct.singlelayer;
import static org.junit.Assert.assertEquals;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.impl.statistics.services.direct.AbstractDirectStatisticsServiceTest;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Counter32;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.services.direct.singlelayer;
import static org.junit.Assert.assertEquals;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.impl.statistics.services.direct.AbstractDirectStatisticsServiceTest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetNodeConnectorStatisticsInput;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.services.direct.singlelayer;
import static org.junit.Assert.assertEquals;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.impl.statistics.services.direct.AbstractDirectStatisticsServiceTest;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Counter64;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.util;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
+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 com.google.common.util.concurrent.Futures;
import java.net.InetSocketAddress;
import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-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.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
@Before
public void setUp() throws Exception {
when(deviceInfo.getNodeInstanceIdentifier()).thenReturn(NODE_II);
- when(writeTransaction.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(CommitInfo.emptyFluentFuture()).when(writeTransaction).commit();
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
when(connectionAdapter.getRemoteAddress()).thenReturn(INET_SOCKET_ADDRESS);
when(featuresReply.getTables()).thenReturn(TABLES);
.create(Nodes.class), new NodesBuilder()
.setNode(Collections.emptyList())
.build());
- verify(writeTransaction).submit();
+ verify(writeTransaction).commit();
}
@Test
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
<artifactId>model-inventory</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-common-util</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-api</artifactId>
- </dependency>
<dependency>
<groupId>${project.groupId}.openflowjava</groupId>
<artifactId>openflowjava-util</artifactId>
<artifactId>model-inventory</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
package org.opendaylight.openflowplugin.learningswitch;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
/**
- * Holder for {@link org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener} registration.
+ * Holder for {@link DataTreeChangeListener} registration.
*/
public interface DataTreeChangeListenerRegistrationHolder {
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. 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.learningswitch;
import com.google.common.util.concurrent.ListenableFuture;
* @param flowBody the flow body
* @return transaction commit
*/
- ListenableFuture<Void> writeFlowToConfig(InstanceIdentifier<Flow> flowPath, Flow flowBody);
+ ListenableFuture<?> writeFlowToConfig(InstanceIdentifier<Flow> flowPath, Flow flowBody);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. 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.learningswitch;
import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
}
@Override
- public ListenableFuture<Void> writeFlowToConfig(InstanceIdentifier<Flow> flowPath, Flow flowBody) {
+ public ListenableFuture<?> writeFlowToConfig(InstanceIdentifier<Flow> flowPath, Flow flowBody) {
ReadWriteTransaction addFlowTransaction = dataBrokerService.newReadWriteTransaction();
addFlowTransaction.put(LogicalDatastoreType.CONFIGURATION, flowPath, flowBody, true);
- return addFlowTransaction.submit();
+ return addFlowTransaction.commit();
}
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. 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.learningswitch;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
public interface LearningSwitchManager {
*/
package org.opendaylight.openflowplugin.learningswitch;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
.augmentation(FlowCapableNode.class)
.child(Table.class);
final DataTreeIdentifier<Table> dataTreeIdentifier =
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
dataTreeChangeListenerRegistration = data.registerDataTreeChangeListener(dataTreeIdentifier, wakeupListener);
LOG.debug("start() <--");
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. 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.learningswitch;
import java.util.Collection;
import javax.annotation.Nonnull;
-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.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
Short requiredTableId = 0;
// TODO add flow
- for (DataTreeModification modification : modifications) {
+ for (DataTreeModification<Table> modification : modifications) {
if (modification.getRootNode().getModificationType() == ModificationType.SUBTREE_MODIFIED) {
DataObject table = modification.getRootNode().getDataAfter();
if (table instanceof Table) {
-/**
+/*
* 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.learningswitch.multi;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.openflowplugin.learningswitch.DataTreeChangeListenerRegistrationHolder;
import org.opendaylight.openflowplugin.learningswitch.FlowCommitWrapper;
import org.opendaylight.openflowplugin.learningswitch.FlowCommitWrapperImpl;
.augmentation(FlowCapableNode.class)
.child(Table.class);
final DataTreeIdentifier<Table> dataTreeIdentifier =
- new DataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
dataTreeChangeListenerRegistration = data.registerDataTreeChangeListener(dataTreeIdentifier, wakeupListener);
LOG.debug("start() <--");
}
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.NotificationService"/>
+ <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
+ <reference id="notificationService" interface="org.opendaylight.mdsal.binding.api.NotificationService"/>
<odl:rpc-service id="packetProcessingService" interface="org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService"/>
<artifactId>model-inventory</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
import java.util.concurrent.Executors;
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.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopVlanActionCaseBuilder;
final InstanceIdentifier<FlowCapableNode> path = InstanceIdentifier.create(Nodes.class).child(Node.class)
.augmentation(FlowCapableNode.class);
final DataTreeIdentifier<FlowCapableNode> identifier =
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, path);
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, path);
listenerReg = dataBroker.registerDataTreeChangeListener(identifier, SampleFlowCapableNodeListener.this);
}
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="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
<odl:rpc-service id="salBundleService" interface="org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.SalBundleService"/>
<groupId>org.opendaylight.controller.model</groupId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>guava</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.openflowplugin.model</groupId>
import java.math.BigInteger;
import java.util.concurrent.atomic.AtomicLong;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
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.flow.inventory.rev130819.FlowId;
LOG.debug("onPacketReceived - About to write flow {}", flow);
}
transaction.put(LogicalDatastoreType.CONFIGURATION, flowInstanceId, flow, true);
- transaction.submit();
+ transaction.commit();
LOG.debug("onPacketReceived - About to write flow commited");
}
*/
package org.opendaylight.openflowplugin.testcommon;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
package org.opendaylight.openflowplugin.testcommon;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.math.BigInteger;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowInputBuilder;
<artifactId>guava</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.openflowplugin.model</groupId>
* 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.test;
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.MoreExecutors;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.osgi.framework.console.CommandInterpreter;
import org.eclipse.osgi.framework.console.CommandProvider;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
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.action.types.rev131112.action.action.ControllerActionCaseBuilder;
.child(Group.class, new GroupKey(group1.getGroupId()));
modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode12), testNode12, true);
modification.merge(LogicalDatastoreType.CONFIGURATION, path2, group1, true);
- ListenableFuture<Void> commitFuture = modification.submit();
- Futures.addCallback(commitFuture, new FutureCallback<Void>() {
+ modification.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
ci.println("Status of Group Data Loaded Transaction: success.");
}
.child(Group.class, new GroupKey(group1.getGroupId()));
modification.delete(LogicalDatastoreType.OPERATIONAL, path2);
modification.delete(LogicalDatastoreType.CONFIGURATION, path2);
- ListenableFuture<Void> commitFuture = modification.submit();
- Futures.addCallback(commitFuture, new FutureCallback<Void>() {
+ modification.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
ci.println("Status of Group Data Loaded Transaction: success.");
}
* 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.test;
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.MoreExecutors;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.osgi.framework.console.CommandInterpreter;
import org.eclipse.osgi.framework.console.CommandProvider;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6FlowLabel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
modification.delete(LogicalDatastoreType.OPERATIONAL, path4);
modification.delete(LogicalDatastoreType.CONFIGURATION, nodeBuilderToInstanceId(tn));
modification.delete(LogicalDatastoreType.CONFIGURATION, path4);
- ListenableFuture<Void> commitFuture = modification.submit();
- Futures.addCallback(commitFuture, new FutureCallback<Void>() {
+ modification.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
ci.println("Status of Group Data Loaded Transaction: success.");
}
modification.merge(LogicalDatastoreType.CONFIGURATION, nodeBuilderToInstanceId(nodeBuilder),
nodeBuilder.build(), true);
modification.merge(LogicalDatastoreType.CONFIGURATION, path4, flow3.build(), true);
- ListenableFuture<Void> commitFuture = modification.submit();
- Futures.addCallback(commitFuture, new FutureCallback<Void>() {
+ modification.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
ci.println("Status of Group Data Loaded Transaction: success.");
}
* 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.test;
import com.google.common.base.Preconditions;
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.MoreExecutors;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.osgi.framework.console.CommandInterpreter;
import org.eclipse.osgi.framework.console.CommandProvider;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
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.action.types.rev131112.action.action.CopyTtlInCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.CopyTtlOutCaseBuilder;
InstanceIdentifier<Group> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
.augmentation(FlowCapableNode.class).child(Group.class, new GroupKey(gbuilder.getGroupId()));
modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
- ListenableFuture<Void> commitFuture = modification.submit();
- Futures.addCallback(commitFuture, new FutureCallback<Void>() {
+ modification.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
ci.println("Status of Group Data Loaded Transaction: success.");
}
.child(Group.class, new GroupKey(group.getGroupId()));
modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode), testNode, true);
modification.merge(LogicalDatastoreType.CONFIGURATION, path1, group, true);
- ListenableFuture<Void> commitFuture = modification.submit();
- Futures.addCallback(commitFuture, new FutureCallback<Void>() {
+ modification.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
ci.println("Status of Group Data Loaded Transaction: success.");
}
-/**
+/*
* Copyright (c) 2013 Cisco Systems, Inc. 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.test;
+import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.AddGroupInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.AddGroupOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.RemoveGroupInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.SalGroupService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.UpdateGroupInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.UpdateGroupOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
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.concepts.AbstractObjectRegistration;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory
.getLogger(OpenflowpluginGroupTestServiceProvider.class);
- private RoutedRpcRegistration<SalGroupService> groupRegistration;
- private NotificationProviderService notificationService;
+ private ObjectRegistration<SalGroupService> groupRegistration;
+ private NotificationPublishService notificationService;
/**
* Get group registration.
*
* @return {@link #groupRegistration}
*/
- public RoutedRpcRegistration<SalGroupService> getGroupRegistration() {
+ public ObjectRegistration<SalGroupService> getGroupRegistration() {
return groupRegistration;
}
/**
* Set {@link #groupRegistration}.
*/
- public void setGroupRegistration(
- final RoutedRpcRegistration<SalGroupService> groupRegistration) {
+ public void setGroupRegistration(final ObjectRegistration<SalGroupService> groupRegistration) {
this.groupRegistration = groupRegistration;
}
*
* @return {@link #notificationService}
*/
- public NotificationProviderService getNotificationService() {
+ public NotificationPublishService getNotificationService() {
return notificationService;
}
/**
* Set {@link #notificationService}.
*/
- public void setNotificationService(
- final NotificationProviderService notificationService) {
+ public void setNotificationService(final NotificationPublishService notificationService) {
this.notificationService = notificationService;
}
return null;
}
- public ObjectRegistration<OpenflowpluginGroupTestServiceProvider> register(
- final RpcProviderRegistry rpcRegistry) {
- RoutedRpcRegistration<SalGroupService> addRoutedRpcImplementation = rpcRegistry.addRoutedRpcImplementation(
- SalGroupService.class, this);
- setGroupRegistration(addRoutedRpcImplementation);
-
- InstanceIdentifierBuilder<Nodes> builder1 = InstanceIdentifier
- .<Nodes>builder(Nodes.class);
-
- NodeId nodeId = new NodeId(OpenflowpluginTestActivator.NODE_ID);
- NodeKey nodeKey = new NodeKey(nodeId);
+ public ObjectRegistration<OpenflowpluginGroupTestServiceProvider> register(final RpcProviderService rpcRegistry) {
+ setGroupRegistration(rpcRegistry.registerRpcImplementation(SalGroupService.class, this, ImmutableSet.of(
+ InstanceIdentifier.create(Nodes.class)
+ .child(Node.class, new NodeKey(new NodeId(OpenflowpluginTestActivator.NODE_ID))))));
- InstanceIdentifierBuilder<Node> nodeIndentifier = builder1
- .<Node, NodeKey>child(Node.class, nodeKey);
- InstanceIdentifier<Node> instance = nodeIndentifier.build();
- groupRegistration.registerPath(NodeContext.class, instance);
- RoutedRpcRegistration<SalGroupService> groupRegistration1 = this
- .getGroupRegistration();
return new AbstractObjectRegistration<OpenflowpluginGroupTestServiceProvider>(this) {
@Override
protected void removeRegistration() {
- groupRegistration1.close();
+ groupRegistration.close();
}
};
}
* 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.test;
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.MoreExecutors;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.osgi.framework.console.CommandInterpreter;
import org.eclipse.osgi.framework.console.CommandProvider;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.MeterBuilder;
InstanceIdentifier<Meter> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, testNode.key())
.augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(testMeter.getMeterId()));
modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
- ListenableFuture<Void> commitFuture = modification.submit();
- Futures.addCallback(commitFuture, new FutureCallback<Void>() {
+ modification.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
ci.println("Status of Group Data Loaded Transaction: success.");
}
break;
}
- ListenableFuture<Void> commitFuture = modification.submit();
- Futures.addCallback(commitFuture, new FutureCallback<Void>() {
+ modification.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
ci.println("Status of Group Data Loaded Transaction: success.");
}
.augmentation(FlowCapableNode.class).child(Meter.class, new MeterKey(meter.getMeterId()));
modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode), testNode, true);
modification.merge(LogicalDatastoreType.CONFIGURATION, path1, meter, true);
- ListenableFuture<Void> commitFuture = modification.submit();
- Futures.addCallback(commitFuture, new FutureCallback<Void>() {
+ modification.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
ci.println("Status of Group Data Loaded Transaction: success.");
}
modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode), testNode, true);
modification.merge(LogicalDatastoreType.CONFIGURATION, path2, meter1, true);
- ListenableFuture<Void> commitFuture = modification.submit();
- Futures.addCallback(commitFuture, new FutureCallback<Void>() {
+ modification.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
ci.println("Status of Group Data Loaded Transaction: success.");
}
-/**
+/*
* Copyright (c) 2013 Cisco Systems, Inc. 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.test;
+import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeContext;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
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.concepts.AbstractObjectRegistration;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory
.getLogger(OpenflowpluginMeterTestServiceProvider.class);
private DataBroker dataService;
- private RoutedRpcRegistration<SalMeterService> meterRegistration;
- private NotificationProviderService notificationService;
+ private ObjectRegistration<SalMeterService> meterRegistration;
+ private NotificationPublishService notificationService;
/**
* Gets the data service.
*
* @return {@link #meterRegistration}
*/
- public RoutedRpcRegistration<SalMeterService> getMeterRegistration() {
+ public ObjectRegistration<SalMeterService> getMeterRegistration() {
return this.meterRegistration;
}
/**
* Sets the {@link #meterRegistration}.
*/
- public void setMeterRegistration(
- final RoutedRpcRegistration<SalMeterService> meterRegistration) {
+ public void setMeterRegistration(final ObjectRegistration<SalMeterService> meterRegistration) {
this.meterRegistration = meterRegistration;
}
*
* @return {@link #notificationService}
*/
- public NotificationProviderService getNotificationService() {
+ public NotificationPublishService getNotificationService() {
return this.notificationService;
}
/**
* Sets the {@link #notificationService}.
*/
- public void setNotificationService(
- final NotificationProviderService notificationService) {
+ public void setNotificationService(final NotificationPublishService notificationService) {
this.notificationService = notificationService;
}
return null;
}
- public ObjectRegistration<OpenflowpluginMeterTestServiceProvider> register(
- final RpcProviderRegistry rpcRegistry) {
-
- RoutedRpcRegistration<SalMeterService> addRoutedRpcImplementation = rpcRegistry.addRoutedRpcImplementation(
- SalMeterService.class, this);
-
- setMeterRegistration(addRoutedRpcImplementation);
-
- InstanceIdentifierBuilder<Nodes> builder1 = InstanceIdentifier
- .<Nodes>builder(Nodes.class);
-
- NodeId nodeId = new NodeId(OpenflowpluginTestActivator.NODE_ID);
- NodeKey nodeKey = new NodeKey(nodeId);
-
- InstanceIdentifierBuilder<Node> nodeIndentifier = builder1
- .<Node, NodeKey>child(Node.class, nodeKey);
-
- InstanceIdentifier<Node> instance = nodeIndentifier.build();
-
- meterRegistration.registerPath(NodeContext.class, instance);
-
- RoutedRpcRegistration<SalMeterService> meterRegistration1 = this
- .getMeterRegistration();
+ public ObjectRegistration<OpenflowpluginMeterTestServiceProvider> register(final RpcProviderService rpcRegistry) {
+ setMeterRegistration(rpcRegistry.registerRpcImplementation(SalMeterService.class, this, ImmutableSet.of(
+ InstanceIdentifier.create(Nodes.class)
+ .child(Node.class, new NodeKey(new NodeId(OpenflowpluginTestActivator.NODE_ID))))));
return new AbstractObjectRegistration<OpenflowpluginMeterTestServiceProvider>(this) {
@Override
protected void removeRegistration() {
- meterRegistration1.close();
+ meterRegistration.close();
}
};
}
* 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.test;
import java.util.List;
import org.eclipse.osgi.framework.console.CommandInterpreter;
import org.eclipse.osgi.framework.console.CommandProvider;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
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.flow.inventory.rev130819.meters.Meter;
for (Node node2 : nodes) {
NodeKey nodeKey = node2.key();
InstanceIdentifier<Node> nodeRef = InstanceIdentifier.create(Nodes.class).child(Node.class, nodeKey);
- ReadOnlyTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
+ ReadTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
Node node = TestProviderTransactionUtil.getDataObject(readOnlyTransaction, nodeRef);
if (node != null) {
if (node.getNodeConnector() != null) {
NodeKey nodeKey = node2.key();
InstanceIdentifier<Node> nodeRef = InstanceIdentifier.create(Nodes.class).child(Node.class, nodeKey);
- ReadOnlyTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
+ ReadTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
Node node = TestProviderTransactionUtil.getDataObject(readOnlyTransaction, nodeRef);
if (node != null) {
if (node.getNodeConnector() != null) {
InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier.create(Nodes.class)
.child(Node.class, nodeKey).augmentation(FlowCapableNode.class);
- ReadOnlyTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
+ ReadTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
FlowCapableNode node = TestProviderTransactionUtil.getDataObject(readOnlyTransaction, nodeRef);
if (node != null) {
InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier.create(Nodes.class)
.child(Node.class, nodeKey).augmentation(FlowCapableNode.class);
- ReadOnlyTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
+ ReadTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
FlowCapableNode node = TestProviderTransactionUtil.getDataObject(readOnlyTransaction, nodeRef);
if (node != null) {
List<Table> tables = node.getTable();
NodeKey nodeKey = node2.key();
InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier.create(Nodes.class)
.child(Node.class, nodeKey).augmentation(FlowCapableNode.class);
- ReadOnlyTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
+ ReadTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
FlowCapableNode node = TestProviderTransactionUtil.getDataObject(readOnlyTransaction, nodeRef);
if (node != null) {
if (node.getGroup() != null) {
NodeKey nodeKey = node2.key();
InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier.create(Nodes.class)
.child(Node.class, nodeKey).augmentation(FlowCapableNode.class);
- ReadOnlyTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
+ ReadTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
FlowCapableNode node = TestProviderTransactionUtil.getDataObject(readOnlyTransaction, nodeRef);
if (node != null) {
NodeKey nodeKey = node2.key();
InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier.create(Nodes.class)
.child(Node.class, nodeKey).augmentation(FlowCapableNode.class);
- ReadOnlyTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
+ ReadTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
FlowCapableNode node = TestProviderTransactionUtil.getDataObject(readOnlyTransaction, nodeRef);
if (node != null) {
if (node.getMeter() != null) {
NodeKey nodeKey = node2.key();
InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier.create(Nodes.class)
.child(Node.class, nodeKey).augmentation(FlowCapableNode.class);
- ReadOnlyTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
+ ReadTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
FlowCapableNode node = TestProviderTransactionUtil.getDataObject(readOnlyTransaction, nodeRef);
if (node != null) {
if (node.getMeter() != null) {
NodeKey nodeKey = node2.key();
InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier.create(Nodes.class)
.child(Node.class, nodeKey).augmentation(FlowCapableNode.class);
- ReadOnlyTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
+ ReadTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
FlowCapableNode node = TestProviderTransactionUtil.getDataObject(readOnlyTransaction, nodeRef);
if (node != null) {
List<Table> tables = node.getTable();
NodeKey nodeKey = node2.key();
InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier.create(Nodes.class)
.child(Node.class, nodeKey).augmentation(FlowCapableNode.class);
- ReadOnlyTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
+ ReadTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
FlowCapableNode node = TestProviderTransactionUtil.getDataObject(readOnlyTransaction, nodeRef);
if (node != null) {
if (null != node.getHardware() && null != node.getManufacturer() && null != node.getSoftware()) {
}
private List<Node> getNodes() {
- ReadOnlyTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
+ ReadTransaction readOnlyTransaction = dataProviderService.newReadOnlyTransaction();
InstanceIdentifier<Nodes> nodesID = InstanceIdentifier.create(Nodes.class);
Nodes nodes = TestProviderTransactionUtil.getDataObject(readOnlyTransaction, nodesID);
if (nodes == null) {
-/**
+/*
* Copyright (c) 2014, 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
package org.opendaylight.openflowplugin.test;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.osgi.framework.console.CommandInterpreter;
import org.eclipse.osgi.framework.console.CommandProvider;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.CopyTtlInCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.CopyTtlOutCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopMplsActionCaseBuilder;
modification.merge(LogicalDatastoreType.OPERATIONAL, path1, tableFeatures, true);
modification.merge(LogicalDatastoreType.CONFIGURATION, nodeToInstanceId(testNode), testNode, true);
modification.merge(LogicalDatastoreType.CONFIGURATION, path1, tableFeatures, true);
- CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
- Futures.addCallback(commitFuture, new FutureCallback<Void>() {
+ modification.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
ci.println("Status of Group Data Loaded Transaction: success.");
}
-/**
+/*
* Copyright (c) 2013 Cisco Systems, Inc. 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.test;
+import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeContext;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
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.concepts.AbstractObjectRegistration;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory
.getLogger(OpenflowpluginTableFeaturesTestServiceProvider.class);
- private RoutedRpcRegistration<SalTableService> tableRegistration;
- private NotificationProviderService notificationService;
+ private ObjectRegistration<SalTableService> tableRegistration;
+ private NotificationPublishService notificationService;
/**
* Get table registration.
*
* @return {@link #tableRegistration}
*/
- public RoutedRpcRegistration<SalTableService> getTableRegistration() {
+ public ObjectRegistration<SalTableService> getTableRegistration() {
return this.tableRegistration;
}
/**
* Set {@link #tableRegistration}.
*/
- public void setTableRegistration(
- final RoutedRpcRegistration<SalTableService> tableRegistration) {
+ public void setTableRegistration(final ObjectRegistration<SalTableService> tableRegistration) {
this.tableRegistration = tableRegistration;
}
*
* @return {@link #notificationService}
*/
- public NotificationProviderService getNotificationService() {
+ public NotificationPublishService getNotificationService() {
return this.notificationService;
}
/**
* Set {@link #notificationService}.
*/
- public void setNotificationService(
- final NotificationProviderService notificationService) {
+ public void setNotificationService(final NotificationPublishService notificationService) {
this.notificationService = notificationService;
}
}
public ObjectRegistration<OpenflowpluginTableFeaturesTestServiceProvider> register(
- final RpcProviderRegistry rpcRegistry) {
- RoutedRpcRegistration<SalTableService> addRoutedRpcImplementation = rpcRegistry.addRoutedRpcImplementation(
- SalTableService.class, this);
-
- setTableRegistration(addRoutedRpcImplementation);
-
- InstanceIdentifierBuilder<Nodes> builder1 = InstanceIdentifier
- .<Nodes>builder(Nodes.class);
-
- NodeId nodeId = new NodeId(OpenflowpluginTestActivator.NODE_ID);
- NodeKey nodeKey = new NodeKey(nodeId);
-
- InstanceIdentifierBuilder<Node> nodeIndentifier = builder1
- .<Node, NodeKey>child(Node.class, nodeKey);
-
- InstanceIdentifier<Node> instance = nodeIndentifier.build();
-
- tableRegistration.registerPath(NodeContext.class, instance);
-
- RoutedRpcRegistration<SalTableService> tableRegistration1 = this
- .getTableRegistration();
+ final RpcProviderService rpcRegistry) {
+ setTableRegistration(rpcRegistry.registerRpcImplementation(SalTableService.class, this, ImmutableSet.of(
+ InstanceIdentifier.create(Nodes.class)
+ .child(Node.class, new NodeKey(new NodeId(OpenflowpluginTestActivator.NODE_ID))))));
return new AbstractObjectRegistration<OpenflowpluginTableFeaturesTestServiceProvider>(this) {
@Override
protected void removeRegistration() {
- tableRegistration1.close();
+ tableRegistration.close();
}
};
}
-/**
+/*
* Copyright (c) 2013 Cisco Systems, Inc. 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.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.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.osgi.framework.BundleContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory
.getLogger(OpenflowpluginTestActivator.class);
- private DataBroker dataBroker;
- private NotificationProviderService notificationService;
- private RpcProviderRegistry rpcRegistry;
+ private RpcProviderService rpcRegistry;
private final OpenflowpluginTestServiceProvider provider;
private final OpenflowpluginGroupTestServiceProvider groupProvider = new OpenflowpluginGroupTestServiceProvider();
private final OpenflowpluginMeterTestServiceProvider meterProvider = new OpenflowpluginMeterTestServiceProvider();
public static final String NODE_ID = "foo:node:1";
public OpenflowpluginTestActivator(@Reference DataBroker dataBroker,
- @Reference NotificationProviderService notificationService, BundleContext ctx) {
- provider = new OpenflowpluginTestServiceProvider(dataBroker, notificationService);
+ @Reference NotificationService notificationService,
+ @Reference NotificationPublishService notificationPublishService, BundleContext ctx) {
+ provider = new OpenflowpluginTestServiceProvider(dataBroker, notificationPublishService);
OpenflowpluginTestCommandProvider openflowpluginTestCommandProvider = new OpenflowpluginTestCommandProvider(
dataBroker, notificationService, ctx);
this.cmdProvider = openflowpluginTestCommandProvider;
* 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.test;
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.MoreExecutors;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;
import org.eclipse.osgi.framework.console.CommandInterpreter;
import org.eclipse.osgi.framework.console.CommandProvider;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Dscp;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6FlowLabel;
.augmentation(FlowCapableNode.class).child(Table.class, new TableKey(tf.getTableId()))
.child(Flow.class, tf.key());
modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
- final ListenableFuture<Void> commitFuture = modification.submit();
- Futures.addCallback(commitFuture, new FutureCallback<Void>() {
+ modification.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(final Void notUsed) {
+ public void onSuccess(final Object notUsed) {
ci.println("Status of Group Data Loaded Transaction: success.");
}
modification.merge(LogicalDatastoreType.CONFIGURATION,
nodeBuilderToInstanceId(nodeBuilder), nodeBuilder.build(), true);
modification.merge(LogicalDatastoreType.CONFIGURATION, path1, flow.build(), true);
- final ListenableFuture<Void> commitFuture = modification.submit();
- Futures.addCallback(commitFuture, new FutureCallback<Void>() {
+ modification.commit().addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(final Void notUsed) {
+ public void onSuccess(final Object notUsed) {
ci.println("Status of Group Data Loaded Transaction: success.");
}
-/**
+/*
* Copyright (c) 2014, 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.controller.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRemoved;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRemoved;
-/**
+/*
* Copyright (c) 2013 Cisco Systems, Inc. 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.test;
+import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.RemoveFlowInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.UpdateFlowInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.UpdateFlowOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
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.concepts.AbstractObjectRegistration;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
.getLogger(OpenflowpluginTestServiceProvider.class);
private final DataBroker dataService;
- private RoutedRpcRegistration<SalFlowService> flowRegistration;
- private final NotificationProviderService notificationProviderService;
+ private ObjectRegistration<SalFlowService> flowRegistration;
+ private final NotificationPublishService notificationProviderService;
public OpenflowpluginTestServiceProvider(DataBroker dataService,
- NotificationProviderService notificationProviderService) {
+ NotificationPublishService notificationProviderService) {
this.dataService = dataService;
this.notificationProviderService = notificationProviderService;
}
*
* @return {@link #flowRegistration}
*/
- public RoutedRpcRegistration<SalFlowService> getFlowRegistration() {
+ public ObjectRegistration<SalFlowService> getFlowRegistration() {
return flowRegistration;
}
/**
* Set {@link #flowRegistration}.
*/
- public void setFlowRegistration(
- final RoutedRpcRegistration<SalFlowService> flowRegistration) {
+ public void setFlowRegistration(final ObjectRegistration<SalFlowService> flowRegistration) {
this.flowRegistration = flowRegistration;
}
*
* @return {@link #notificationProviderService}
*/
- public NotificationProviderService getNotificationService() {
+ public NotificationPublishService getNotificationService() {
return notificationProviderService;
}
return null;
}
- public ObjectRegistration<OpenflowpluginTestServiceProvider> register(RpcProviderRegistry rpcRegistry) {
- RoutedRpcRegistration<SalFlowService> addRoutedRpcImplementation =
- rpcRegistry.addRoutedRpcImplementation(SalFlowService.class, this);
-
- setFlowRegistration(addRoutedRpcImplementation);
-
- InstanceIdentifierBuilder<Nodes> builderII = InstanceIdentifier
- .<Nodes>builder(Nodes.class);
-
- NodeId nodeId = new NodeId(OpenflowpluginTestActivator.NODE_ID);
- NodeKey nodeKey = new NodeKey(nodeId);
-
- InstanceIdentifierBuilder<Node> nodeIdentifier = builderII
- .<Node, NodeKey>child(Node.class, nodeKey);
-
- InstanceIdentifier<Node> instance = nodeIdentifier.build();
-
- flowRegistration.registerPath(NodeContext.class, instance);
-
- RoutedRpcRegistration<SalFlowService> flowRegistration2 = getFlowRegistration();
+ public ObjectRegistration<OpenflowpluginTestServiceProvider> register(RpcProviderService rpcRegistry) {
+ setFlowRegistration(rpcRegistry.registerRpcImplementation(SalFlowService.class, this, ImmutableSet.of(
+ InstanceIdentifier.create(Nodes.class)
+ .child(Node.class, new NodeKey(new NodeId(OpenflowpluginTestActivator.NODE_ID))))));
return new AbstractObjectRegistration<OpenflowpluginTestServiceProvider>(this) {
@Override
protected void removeRegistration() {
- flowRegistration2.close();
+ flowRegistration.close();
}
};
}
-/**
+/*
* Copyright (c) 2014, 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.test;
-import org.opendaylight.controller.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.FlowTopologyDiscoveryListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkDiscovered;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkOverutilized;
* 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.test;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
Code Review / openflowplugin.git / commitdiff