<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>12.0.4</version>
+ <version>13.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>aaa-artifacts</artifactId>
- <version>0.18.4</version>
+ <version>0.19.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.controller</groupId>
<artifactId>mdsal-it-parent</artifactId>
- <version>8.0.4</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>12.0.4</version>
+ <version>13.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>12.0.4</version>
+ <version>13.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-hwvtepsouthbound-api-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-hwvtepsouthbound-api" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
- <feature version="[12,13)">odl-mdsal-model-odl-l2-types</feature>
+ <feature version="[13,14)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[13,14)">odl-mdsal-model-odl-l2-types</feature>
</feature>
</features>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>netconf-artifacts</artifactId>
- <version>6.0.6</version>
+ <version>7.0.0</version>
<scope>import</scope>
<type>pom</type>
</dependency>
-->
<features name="odl-ovsdb-hwvtepsouthbound-rest-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-hwvtepsouthbound-rest" version="${project.version}">
- <feature version="[6,7)">odl-restconf</feature>
+ <feature version="[7,8)">odl-restconf</feature>
</feature>
</features>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>netconf-artifacts</artifactId>
- <version>6.0.6</version>
+ <version>7.0.0</version>
<scope>import</scope>
<type>pom</type>
</dependency>
-->
<features name="odl-ovsdb-hwvtepsouthbound-ui-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-hwvtepsouthbound-ui" version="${project.version}">
- <feature version="[6,7)">odl-restconf-openapi</feature>
+ <feature version="[7,8)">odl-restconf-openapi</feature>
</feature>
</features>
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.eos.binding.api.Entity;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.ovsdb.hwvtepsouthbound.transact.TransactCommand;
import org.opendaylight.ovsdb.hwvtepsouthbound.transact.TransactInvoker;
import org.opendaylight.ovsdb.hwvtepsouthbound.transact.TransactInvokerImpl;
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.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private MonitorCallBack callback;
private volatile boolean hasDeviceOwnership = false;
private Entity connectedEntity;
- private EntityOwnershipCandidateRegistration deviceOwnershipCandidateRegistration;
+ private Registration deviceOwnershipCandidateRegistration;
private HwvtepGlobalAugmentation initialCreatedData = null;
private final HwvtepDeviceInfo deviceInfo;
private final DataBroker dataBroker;
}
}
- public void setDeviceOwnershipCandidateRegistration(
- @NonNull final EntityOwnershipCandidateRegistration registration) {
+ public void setDeviceOwnershipCandidateRegistration(final @NonNull Registration registration) {
this.deviceOwnershipCandidateRegistration = registration;
}
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.Entity;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListener;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListenerRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
+import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
import org.opendaylight.ovsdb.hwvtepsouthbound.events.ClientConnected;
import org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation.ReconciliationManager;
import org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation.ReconciliationTask;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.ConnectionInfo;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
hwvtepConnectionInstance.setConnectedEntity(candidateEntity);
try {
- EntityOwnershipCandidateRegistration registration =
- entityOwnershipService.registerCandidate(candidateEntity);
+ Registration registration = entityOwnershipService.registerCandidate(candidateEntity);
hwvtepConnectionInstance.setDeviceOwnershipCandidateRegistration(registration);
LOG.info("HWVTEP entity {} is registered for ownership.", candidateEntity);
} catch (CandidateAlreadyRegisteredException e) {
final HwvtepConnectionInstance hwvtepConnectionInstance) {
//If entity already has owner, it won't get notification from EntityOwnershipService
//so cache the connection instances.
- java.util.Optional<EntityOwnershipState> ownershipStateOpt =
- entityOwnershipService.getOwnershipState(candidateEntity);
+ Optional<EntityOwnershipState> ownershipStateOpt = entityOwnershipService.getOwnershipState(candidateEntity);
if (ownershipStateOpt.isPresent()) {
EntityOwnershipState ownershipState = ownershipStateOpt.orElseThrow();
putConnectionInstance(hwvtepConnectionInstance.getMDConnectionInfo(), hwvtepConnectionInstance);
}
}
- public void handleOwnershipChanged(final EntityOwnershipChange ownershipChange) {
- HwvtepConnectionInstance hwvtepConnectionInstance =
- getConnectionInstanceFromEntity(ownershipChange.getEntity());
+ public void handleOwnershipChanged(final Entity entity, final EntityOwnershipStateChange change) {
+ HwvtepConnectionInstance hwvtepConnectionInstance = getConnectionInstanceFromEntity(entity);
LOG.info("handleOwnershipChanged: {} event received for device {}",
- ownershipChange, hwvtepConnectionInstance != null ? hwvtepConnectionInstance.getConnectionInfo()
+ change, hwvtepConnectionInstance != null ? hwvtepConnectionInstance.getConnectionInfo()
: "THAT'S NOT REGISTERED BY THIS SOUTHBOUND PLUGIN INSTANCE");
if (hwvtepConnectionInstance == null) {
- if (ownershipChange.getState().isOwner()) {
- LOG.warn("handleOwnershipChanged: found no connection instance for {}", ownershipChange.getEntity());
+ if (change.isOwner()) {
+ LOG.warn("handleOwnershipChanged: found no connection instance for {}", entity);
} else {
// EntityOwnershipService sends notification to all the nodes, irrespective of whether
// that instance registered for the device ownership or not. It is to make sure that
// If all the controller instance that was connected to the device are down, so the
// running instance can clear up the operational data store even though it was not
// connected to the device.
- LOG.debug("handleOwnershipChanged: found no connection instance for {}", ownershipChange.getEntity());
+ LOG.debug("handleOwnershipChanged: found no connection instance for {}", entity);
}
// If entity has no owner, clean up the operational data store (it's possible because owner controller
// might went down abruptly and didn't get a chance to clean up the operational data store.
- if (!ownershipChange.getState().hasOwner()) {
- LOG.info("{} has no owner, cleaning up the operational data store", ownershipChange.getEntity());
+ if (!change.hasOwner()) {
+ LOG.info("{} has no owner, cleaning up the operational data store", entity);
// Below code might look weird but it's required. We want to give first opportunity to the
// previous owner of the device to clean up the operational data store if there is no owner now.
// That way we will avoid lot of nasty md-sal exceptions because of concurrent delete.
- InstanceIdentifier<Node> nodeIid =
- (InstanceIdentifier<Node>) ownershipChange.getEntity().getIdentifier();
+ InstanceIdentifier<Node> nodeIid = (InstanceIdentifier<Node>) entity.getIdentifier();
hwvtepOperGlobalListener.scheduleOldConnectionNodeDelete(nodeIid);
/*
Assuming node1 was the owner earlier.
//Connection detail need to be cached, irrespective of ownership result.
putConnectionInstance(hwvtepConnectionInstance.getMDConnectionInfo(), hwvtepConnectionInstance);
- if (ownershipChange.getState().isOwner() == hwvtepConnectionInstance.getHasDeviceOwnership()) {
+ if (change.isOwner() == hwvtepConnectionInstance.getHasDeviceOwnership()) {
LOG.debug("handleOwnershipChanged: no change in ownership for {}. Ownership status is : {}",
hwvtepConnectionInstance.getConnectionInfo(), hwvtepConnectionInstance.getHasDeviceOwnership());
return;
}
- hwvtepConnectionInstance.setHasDeviceOwnership(ownershipChange.getState().isOwner());
+ hwvtepConnectionInstance.setHasDeviceOwnership(change.isOwner());
// You were not an owner, but now you are
- if (ownershipChange.getState().isOwner()) {
+ if (change.isOwner()) {
LOG.info("handleOwnershipChanged: *this* southbound plugin instance is owner of device {}",
hwvtepConnectionInstance.getConnectionInfo());
private static final class HwvtepDeviceEntityOwnershipListener implements EntityOwnershipListener {
private final HwvtepConnectionManager hcm;
- private final EntityOwnershipListenerRegistration listenerRegistration;
+ private final Registration listenerRegistration;
HwvtepDeviceEntityOwnershipListener(final HwvtepConnectionManager hcm,
final EntityOwnershipService entityOwnershipService) {
}
@Override
- public void ownershipChanged(final EntityOwnershipChange ownershipChange) {
- hcm.handleOwnershipChanged(ownershipChange);
+ public void ownershipChanged(final Entity entity, final EntityOwnershipStateChange change,
+ final boolean inJeopardy) {
+ hcm.handleOwnershipChanged(entity, change);
}
}
* 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.ovsdb.hwvtepsouthbound;
import java.net.ConnectException;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ExecutionException;
-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.DataObjectModification.ModificationType;
+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.binding.api.ReadWriteTransaction;
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.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class HwvtepDataChangeListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
+public final class HwvtepDataChangeListener implements DataTreeChangeListener<Node>, AutoCloseable {
+ private static final Logger LOG = LoggerFactory.getLogger(HwvtepDataChangeListener.class);
- private ListenerRegistration<HwvtepDataChangeListener> registration;
private final HwvtepConnectionManager hcm;
private final DataBroker db;
- private static final Logger LOG = LoggerFactory.getLogger(HwvtepDataChangeListener.class);
+
+ private Registration registration;
HwvtepDataChangeListener(DataBroker db, HwvtepConnectionManager hcm) {
LOG.info("Registering HwvtepDataChangeListener");
this.db = db;
this.hcm = hcm;
- registerListener();
- }
-
- private void registerListener() {
- final DataTreeIdentifier<Node> treeId =
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, getWildcardPath());
+ final var treeId = DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.builder(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID))
+ .child(Node.class)
+ .build());
LOG.trace("Registering on path: {}", treeId);
- registration = db.registerDataTreeChangeListener(treeId, HwvtepDataChangeListener.this);
+ registration = db.registerTreeChangeListener(treeId, this);
}
@Override
}
@Override
- public void onDataTreeChanged(Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(List<DataTreeModification<Node>> changes) {
LOG.trace("onDataTreeChanged: {}", changes);
/* TODO:
disconnectViaCli(changes);
}
- private void connect(Collection<DataTreeModification<Node>> changes) {
+ private void connect(List<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
- final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
+ final InstanceIdentifier<Node> key = change.getRootPath().path();
final DataObjectModification<Node> mod = change.getRootNode();
Node node = getCreated(mod);
if (node != null) {
}
}
- private void updateConnections(Collection<DataTreeModification<Node>> changes) {
+ private void updateConnections(List<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
- final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
+ final InstanceIdentifier<Node> key = change.getRootPath().path();
final DataObjectModification<Node> mod = change.getRootNode();
Node updated = getUpdated(mod);
if (updated != null) {
}
}
- private void updateData(Collection<DataTreeModification<Node>> changes) {
+ private void updateData(List<DataTreeModification<Node>> changes) {
/* TODO:
* Get connection instances for each change
* Update data for each connection
private void disconnect(Collection<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
- final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
+ final InstanceIdentifier<Node> key = change.getRootPath().path();
final DataObjectModification<Node> mod = change.getRootNode();
Node deleted = getRemoved(mod);
if (deleted != null) {
}
private static Node getCreated(DataObjectModification<Node> mod) {
- if (mod.getModificationType() == ModificationType.WRITE && mod.getDataBefore() == null) {
- return mod.getDataAfter();
+ if (mod.modificationType() == ModificationType.WRITE && mod.dataBefore() == null) {
+ return mod.dataAfter();
}
return null;
}
private static Node getRemoved(DataObjectModification<Node> mod) {
- if (mod.getModificationType() == ModificationType.DELETE) {
- return mod.getDataBefore();
+ if (mod.modificationType() == ModificationType.DELETE) {
+ return mod.dataBefore();
}
return null;
}
private static Node getUpdated(DataObjectModification<Node> mod) {
Node node = null;
- switch (mod.getModificationType()) {
+ switch (mod.modificationType()) {
case SUBTREE_MODIFIED:
- node = mod.getDataAfter();
+ node = mod.dataAfter();
break;
case WRITE:
- if (mod.getDataBefore() != null) {
- node = mod.getDataAfter();
+ if (mod.dataBefore() != null) {
+ node = mod.dataAfter();
}
break;
default:
private static Node getOriginal(DataObjectModification<Node> mod) {
Node node = null;
- switch (mod.getModificationType()) {
+ switch (mod.modificationType()) {
case SUBTREE_MODIFIED:
case DELETE:
- node = mod.getDataBefore();
+ node = mod.dataBefore();
break;
case WRITE:
- if (mod.getDataBefore() != null) {
- node = mod.getDataBefore();
+ if (mod.dataBefore() != null) {
+ node = mod.dataBefore();
}
break;
default:
return node;
}
- private static InstanceIdentifier<Node> getWildcardPath() {
- return InstanceIdentifier.create(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID))
- .child(Node.class);
- }
-
private Map<HwvtepConnectionInstance, Collection<DataTreeModification<Node>>> changesByConnectionInstance(
Collection<DataTreeModification<Node>> changes) {
Map<HwvtepConnectionInstance, Collection<DataTreeModification<Node>>> result = new HashMap<>();
for (DataTreeModification<Node> change : changes) {
final DataObjectModification<Node> mod = change.getRootNode();
//From original node to get connection instance
- Node node = mod.getDataBefore() != null ? mod.getDataBefore() : mod.getDataAfter();
+ Node node = mod.dataBefore() != null ? mod.dataBefore() : mod.dataAfter();
HwvtepConnectionInstance connection = hcm.getConnectionInstanceFromNodeIid(
- change.getRootPath().getRootIdentifier());
+ change.getRootPath().path());
if (connection != null) {
if (!result.containsKey(connection)) {
List<DataTreeModification<Node>> tempChanges = new ArrayList<>();
@SuppressWarnings("checkstyle:IllegalCatch")
private void disconnectViaCli(Collection<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
- String nodeId = change.getRootPath().getRootIdentifier().firstKeyOf(Node.class).getNodeId().getValue();
+ String nodeId = change.getRootPath().path().firstKeyOf(Node.class).getNodeId().getValue();
if (!nodeId.contains("/disconnect")) {
continue;
}
int reconcileIndex = nodeId.indexOf("/disconnect");
String globalNodeId = nodeId.substring(0, reconcileIndex);
- InstanceIdentifier<Node> globalNodeIid = change.getRootPath()
- .getRootIdentifier().firstIdentifierOf(Topology.class)
+ InstanceIdentifier<Node> globalNodeIid = change.getRootPath().path().firstIdentifierOf(Topology.class)
.child(Node.class, new NodeKey(new NodeId(globalNodeId)));
HwvtepConnectionInstance connectionInstance = hcm.getConnectionInstanceFromNodeIid(globalNodeIid);
if (connectionInstance != null) {
LOG.error("Disconnecting from controller {}", nodeId);
new Thread(() -> {
ReadWriteTransaction tx = db.newReadWriteTransaction();
- tx.delete(LogicalDatastoreType.CONFIGURATION, change.getRootPath().getRootIdentifier());
+ tx.delete(LogicalDatastoreType.CONFIGURATION, change.getRootPath().path());
try {
tx.commit().get();
} catch (ExecutionException | InterruptedException e) {
- LOG.error("Failed to delete the node {}", change.getRootPath().getRootIdentifier());
+ LOG.error("Failed to delete the node {}", change.getRootPath().path());
}
}).start();
try {
package org.opendaylight.ovsdb.hwvtepsouthbound;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
-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.DataObjectModification.ModificationType;
+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.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
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.Node;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class HwvtepOperGlobalListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
+public final class HwvtepOperGlobalListener implements DataTreeChangeListener<Node>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepOperGlobalListener.class);
private static final Map<InstanceIdentifier<Node>, ConnectionInfo> NODE_CONNECTION_INFO = new ConcurrentHashMap<>();
private static final Map<InstanceIdentifier<Node>, ScheduledFuture> TIMEOUT_FTS = new ConcurrentHashMap<>();
- private ListenerRegistration<HwvtepOperGlobalListener> registration;
+ private Registration registration;
private final HwvtepConnectionManager hcm;
private final DataBroker db;
private static final Map<InstanceIdentifier<Node>, List<Callable<Void>>> NODE_DELET_WAITING_JOBS
private void registerListener() {
final DataTreeIdentifier<Node> treeId =
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, getWildcardPath());
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, getWildcardPath());
- registration = db.registerDataTreeChangeListener(treeId, HwvtepOperGlobalListener.this);
+ registration = db.registerTreeChangeListener(treeId, this);
}
@Override
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
- public void onDataTreeChanged(final Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(final List<DataTreeModification<Node>> changes) {
LOG.trace("onDataTreeChanged: ");
try {
connect(changes);
}
}
- private static void connect(Collection<DataTreeModification<Node>> changes) {
+ private static void connect(List<DataTreeModification<Node>> changes) {
changes.forEach(change -> {
- InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
+ InstanceIdentifier<Node> key = change.getRootPath().path();
DataObjectModification<Node> mod = change.getRootNode();
Node node = getCreated(mod);
if (node == null) {
});
}
- private static void updated(Collection<DataTreeModification<Node>> changes) {
+ private static void updated(List<DataTreeModification<Node>> changes) {
changes.forEach(change -> {
- InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
+ InstanceIdentifier<Node> key = change.getRootPath().path();
DataObjectModification<Node> mod = change.getRootNode();
Node node = getUpdated(mod);
if (node != null) {
return CONNECTED_NODES.get(key);
}
- private void disconnect(Collection<DataTreeModification<Node>> changes) {
+ private void disconnect(List<DataTreeModification<Node>> changes) {
changes.forEach(change -> {
- InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
+ InstanceIdentifier<Node> key = change.getRootPath().path();
DataObjectModification<Node> mod = change.getRootNode();
Node node = getRemoved(mod);
if (node != null) {
package org.opendaylight.ovsdb.hwvtepsouthbound;
import com.google.common.util.concurrent.FluentFuture;
-import java.util.Collection;
+import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-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.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.eos.binding.api.Entity;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListener;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListenerRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
+import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
import org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation.configuration.HwvtepReconciliationManager;
import org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md.TransactionInvoker;
import org.opendaylight.ovsdb.lib.OvsdbConnection;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyBuilder;
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.Node;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
@Singleton
@Component(service = HwvtepSouthboundProviderInfo.class)
public final class HwvtepSouthboundProvider
- implements HwvtepSouthboundProviderInfo, ClusteredDataTreeChangeListener<Topology>, AutoCloseable {
+ implements HwvtepSouthboundProviderInfo, DataTreeChangeListener<Topology>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepSouthboundProvider.class);
private static final String ENTITY_TYPE = "ovsdb-hwvtepsouthbound-provider";
private final OvsdbConnection ovsdbConnection;
private HwvtepConnectionManager cm;
- private EntityOwnershipCandidateRegistration registration;
+ private Registration registration;
private HwvtepsbPluginInstanceEntityOwnershipListener providerOwnershipChangeListener;
private HwvtepDataChangeListener hwvtepDTListener;
private HwvtepReconciliationManager hwvtepReconciliationManager;
private final AtomicBoolean registered = new AtomicBoolean(false);
- private ListenerRegistration<HwvtepSouthboundProvider> operTopologyRegistration;
+ private Registration operTopologyRegistration;
@Inject
@Activate
InstanceIdentifier<Topology> path = InstanceIdentifier
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID));
- DataTreeIdentifier<Topology> treeId =
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, path);
+ DataTreeIdentifier<Topology> treeId = DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, path);
LOG.trace("Registering listener for path {}", treeId);
- operTopologyRegistration = dataBroker.registerDataTreeChangeListener(treeId, this);
+ operTopologyRegistration = dataBroker.registerTreeChangeListener(treeId, this);
Scheduler.getScheduledExecutorService().schedule(() -> {
if (!registered.get()) {
openOvsdbPort();
}
}
- public void handleOwnershipChange(final EntityOwnershipChange ownershipChange) {
- if (ownershipChange.getState().isOwner()) {
+ public void handleOwnershipChange(final EntityOwnershipStateChange change) {
+ if (change.isOwner()) {
LOG.info("*This* instance of HWVTEP southbound provider is set as a MASTER instance");
LOG.info("Initialize HWVTEP topology {} in operational and config data store if not already present",
HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID);
}
}
-
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Topology>> collection) {
+ public void onDataTreeChanged(final List<DataTreeModification<Topology>> collection) {
openOvsdbPort();
if (operTopologyRegistration != null) {
private static final class HwvtepsbPluginInstanceEntityOwnershipListener implements EntityOwnershipListener {
private final HwvtepSouthboundProvider hsp;
- private final EntityOwnershipListenerRegistration listenerRegistration;
+ private final Registration listenerRegistration;
HwvtepsbPluginInstanceEntityOwnershipListener(final HwvtepSouthboundProvider hsp,
final EntityOwnershipService entityOwnershipService) {
}
@Override
- public void ownershipChanged(final EntityOwnershipChange ownershipChange) {
- hsp.handleOwnershipChange(ownershipChange);
+ public void ownershipChanged(final Entity entity, final EntityOwnershipStateChange change,
+ final boolean inJeopardy) {
+ hsp.handleOwnershipChange(change);
}
}
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
-import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
+import org.opendaylight.yangtools.yang.data.util.AbstractStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.util.LeafrefResolver;
-public final class InstanceIdentifierCodec
- // FIXME: this really wants to be wired as yangtools-data-codec-gson's codecs, because ...
- extends AbstractModuleStringInstanceIdentifierCodec implements EffectiveModelContextListener {
-
+// FIXME: this really wants to be wired as yangtools-data-codec-gson's codecs, because ...
+public final class InstanceIdentifierCodec extends AbstractStringInstanceIdentifierCodec {
// FIXME: this is not the only interface exposed from binding-dom-codec-api, something different might be more
// appropriate.
private final BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer;
public InstanceIdentifierCodec(final DOMSchemaService schemaService,
final BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer) {
- schemaService.registerSchemaContextListener(this);
+ schemaService.registerSchemaContextListener(this::onModelContextUpdated);
this.bindingNormalizedNodeSerializer = bindingNormalizedNodeSerializer;
}
}
@Override
- protected Module moduleForPrefix(final String prefix) {
- return context != null ? context.findModule(prefix, Optional.empty()).orElse(null) : null;
+ protected QNameModule moduleForPrefix(final String prefix) {
+ return context != null ? context.findModule(prefix, Optional.empty()).map(Module::getQNameModule).orElse(null)
+ : null;
}
@Override
}
@Override
+ protected Object deserializeKeyValue(final DataSchemaNode schemaNode, final LeafrefResolver resolver,
+ final String value) {
+ throw new UnsupportedOperationException("Not implemented");
+ }
+
public void onModelContextUpdated(final EffectiveModelContext schemaContext) {
this.context = schemaContext;
this.dataSchemaContextTree = DataSchemaContextTree.from(schemaContext);
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.ExactDataObjectStep;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.Key;
import org.opendaylight.yangtools.yang.binding.KeyAware;
+import org.opendaylight.yangtools.yang.binding.KeyStep;
+import org.opendaylight.yangtools.yang.binding.NodeStep;
public class DataObjectModificationImpl<T extends DataObject> implements DataObjectModification<T> {
-
private final Collection<DataObjectModification<? extends DataObject>> childNodesCache = new ArrayList<>();
InstanceIdentifier<T> nodeId;
T newNode;
@Override
- public T getDataBefore() {
+ public T dataBefore() {
return oldNode;
}
@Override
- public T getDataAfter() {
+ public T dataAfter() {
return newNode;
}
@Override
- public Class<T> getDataType() {
+ public Class<T> dataType() {
return (Class<T>) newNode.getClass();
}
@Override
- public InstanceIdentifier.PathArgument getIdentifier() {
- return nodeId.getPathArguments().iterator().next();
+ public ExactDataObjectStep<T> step() {
+ return (ExactDataObjectStep<T>) nodeId.getPathArguments().iterator().next();
}
@Override
- public ModificationType getModificationType() {
+ public ModificationType modificationType() {
return ModificationType.WRITE;
}
@Override
- public Collection<DataObjectModification<? extends DataObject>> getModifiedChildren() {
+ public Collection<DataObjectModification<? extends DataObject>> modifiedChildren() {
return childNodesCache;
}
}
@Override
- public DataObjectModification<? extends DataObject> getModifiedChild(final InstanceIdentifier.PathArgument arg) {
+ public DataObjectModification<? extends DataObject> getModifiedChild(final ExactDataObjectStep<?> childArgument) {
return null;
}
@SuppressWarnings("unchecked")
public <C extends KeyAware<K> & ChildOf<? super T>, K extends Key<C>> DataObjectModification<C>
getModifiedChildListItem(final Class<C> listItem, final K listKey) {
- return (DataObjectModification<C>) getModifiedChild(InstanceIdentifier.IdentifiableItem.of(listItem, listKey));
+ return (DataObjectModification<C>) getModifiedChild(new KeyStep<>(listItem, listKey));
}
@Override
@Override
@SuppressWarnings("unchecked")
public <C extends ChildOf<? super T>> DataObjectModification<C> getModifiedChildContainer(final Class<C> arg) {
- return (DataObjectModification<C>) getModifiedChild(InstanceIdentifier.Item.of(arg));
+ return (DataObjectModification<C>) getModifiedChild(new NodeStep<>(arg));
}
@Override
@SuppressWarnings("unchecked")
public <C extends Augmentation<T> & DataObject> DataObjectModification<C> getModifiedAugmentation(
final Class<C> augmentation) {
- return (DataObjectModification<C>) getModifiedChild(InstanceIdentifier.Item.of(augmentation));
+ return (DataObjectModification<C>) getModifiedChild(new NodeStep<>(augmentation));
}
@Override
*/
package org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation.configuration;
-import java.util.Collection;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import java.util.List;
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.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.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class HwvtepReconciliationManager implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
+public final class HwvtepReconciliationManager implements DataTreeChangeListener<Node>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepReconciliationManager.class);
- private final ListenerRegistration<HwvtepReconciliationManager> registration;
+ private final Registration registration;
private final HwvtepConnectionManager hcm;
public HwvtepReconciliationManager(DataBroker db, HwvtepConnectionManager hcm) {
this.hcm = hcm;
final InstanceIdentifier<Node> iid = HwvtepSouthboundMapper.createInstanceIdentifier();
- final DataTreeIdentifier<Node> treeId = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, iid);
+ final DataTreeIdentifier<Node> treeId = DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, iid);
LOG.trace("Registering listener for path {}", treeId);
- registration = db.registerDataTreeChangeListener(treeId, HwvtepReconciliationManager.this);
+ registration = db.registerTreeChangeListener(treeId, this);
}
@Override
}
@Override
- public void onDataTreeChanged(Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(List<DataTreeModification<Node>> changes) {
processConnectedNodes(changes);
processDisconnectedNodes(changes);
}
- private void processDisconnectedNodes(Collection<DataTreeModification<Node>> changes) {
+ private void processDisconnectedNodes(List<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
- final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
+ final InstanceIdentifier<Node> key = change.getRootPath().path();
final DataObjectModification<Node> mod = change.getRootNode();
Node deleted = getRemoved(mod);
if (deleted != null) {
}
}
- private void processConnectedNodes(Collection<DataTreeModification<Node>> changes) {
+ private void processConnectedNodes(List<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
DataObjectModification<Node> mod = change.getRootNode();
Node node = getCreated(mod);
}
private static Node getCreated(DataObjectModification<Node> mod) {
- if (mod.getModificationType() == ModificationType.WRITE && mod.getDataBefore() == null) {
- return mod.getDataAfter();
+ if (mod.modificationType() == ModificationType.WRITE && mod.dataBefore() == null) {
+ return mod.dataAfter();
}
return null;
}
private static Node getRemoved(DataObjectModification<Node> mod) {
- if (mod.getModificationType() == ModificationType.DELETE) {
- return mod.getDataBefore();
+ if (mod.modificationType() == ModificationType.DELETE) {
+ return mod.dataBefore();
}
return null;
}
}
public static Node getCreated(final DataObjectModification<Node> mod) {
- if (mod.getModificationType() == ModificationType.WRITE
- && mod.getDataBefore() == null) {
- return mod.getDataAfter();
+ if (mod.modificationType() == ModificationType.WRITE && mod.dataBefore() == null) {
+ return mod.dataAfter();
}
return null;
}
public static Node getRemoved(final DataObjectModification<Node> mod) {
- if (mod.getModificationType() == ModificationType.DELETE) {
- return mod.getDataBefore();
+ if (mod.modificationType() == ModificationType.DELETE) {
+ return mod.dataBefore();
}
return null;
}
public static Node getUpdated(final DataObjectModification<Node> mod) {
Node node = null;
- switch (mod.getModificationType()) {
+ switch (mod.modificationType()) {
case SUBTREE_MODIFIED:
- node = mod.getDataAfter();
+ node = mod.dataAfter();
break;
case WRITE:
- if (mod.getDataBefore() != null) {
- node = mod.getDataAfter();
+ if (mod.dataBefore() != null) {
+ node = mod.dataAfter();
}
break;
default:
public static Node getOriginal(final DataObjectModification<Node> mod) {
Node node = null;
- switch (mod.getModificationType()) {
+ switch (mod.modificationType()) {
case SUBTREE_MODIFIED:
case DELETE:
- node = mod.getDataBefore();
+ node = mod.dataBefore();
break;
case WRITE:
- if (mod.getDataBefore() != null) {
- node = mod.getDataBefore();
+ if (mod.dataBefore() != null) {
+ node = mod.dataBefore();
}
break;
default:
final Collection<DataTreeModification<Node>> changes, final Class<Node> class1) {
Map<InstanceIdentifier<Node>, Node> result = new HashMap<>();
for (DataTreeModification<Node> change : changes) {
- final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
+ final InstanceIdentifier<Node> key = change.getRootPath().path();
final DataObjectModification<Node> mod = change.getRootNode();
Node created = getCreated(mod);
if (created != null) {
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.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
*/
@Singleton
@Component(service = TransactionInvoker.class)
-public final class TransactionInvokerImpl implements TransactionInvoker, TransactionChainListener, Runnable,
- AutoCloseable, UncaughtExceptionHandler {
+public final class TransactionInvokerImpl implements TransactionInvoker, Runnable, AutoCloseable,
+ UncaughtExceptionHandler {
private static final Logger LOG = LoggerFactory.getLogger(TransactionInvokerImpl.class);
private static final int QUEUE_SIZE = 10000;
@Activate
public TransactionInvokerImpl(@Reference final DataBroker db) {
this.db = db;
- chain = db.createTransactionChain(this);
+ chain = db.createTransactionChain();
ThreadFactory threadFact = new ThreadFactoryBuilder().setNameFormat("transaction-invoker-impl-%d")
.setUncaughtExceptionHandler(this).build();
executor = Executors.newSingleThreadExecutor(threadFact);
}
}
- @Override
- public void onTransactionChainFailed(final TransactionChain txChain,
- final Transaction transaction, final Throwable cause) {
- offerFailedTransaction(transaction);
- }
-
- @Override
- public void onTransactionChainSuccessful(final TransactionChain txChain) {
- // NO OP
- }
-
@Override
public void run() {
while (true) {
@Override
public void onFailure(final Throwable throwable) {
- // NOOP - handled by failure of transaction chain
+ offerFailedTransaction(transaction);
command.onFailure();
}
}, MoreExecutors.directExecutor());
private void resetTransactionQueue() {
chain.close();
- chain = db.createTransactionChain(this);
+ chain = db.createTransactionChain();
pendingTransactions.clear();
transactionToCommand.clear();
failedTransactionQueue.clear();
* 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.ovsdb.hwvtepsouthbound;
-import java.util.Collection;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import java.util.List;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
+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.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.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyAware;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class HwvtepOperationalDataChangeListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
-
- private static final Logger LOG = LoggerFactory.getLogger(HwvtepOperationalDataChangeListener.class);
- private final ListenerRegistration<HwvtepOperationalDataChangeListener> registration;
+public class HwvtepOperationalDataChangeListener implements DataTreeChangeListener<Node>, AutoCloseable {
+ private final Registration registration;
private final HwvtepConnectionManager hcm;
private final DataBroker db;
private final HwvtepConnectionInstance connectionInstance;
this.db = db;
this.hcm = hcm;
this.connectionInstance = connectionInstance;
- DataTreeIdentifier<Node> treeId = DataTreeIdentifier
- .create(LogicalDatastoreType.OPERATIONAL, getWildcardPath());
- registration = db.registerDataTreeChangeListener(treeId, HwvtepOperationalDataChangeListener.this);
+ DataTreeIdentifier<Node> treeId = DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, getWildcardPath());
+ registration = db.registerTreeChangeListener(treeId, this);
}
@Override
}
@Override
- public void onDataTreeChanged(Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(List<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
- final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
+ final InstanceIdentifier<Node> key = change.getRootPath().path();
final DataObjectModification<Node> mod = change.getRootNode();
- for (DataObjectModification<? extends DataObject> child : mod.getModifiedChildren()) {
+ for (DataObjectModification<? extends DataObject> child : mod.modifiedChildren()) {
updateDeviceOpData(key, child);
}
DataObjectModification<HwvtepGlobalAugmentation> aug =
mod.getModifiedAugmentation(HwvtepGlobalAugmentation.class);
if (aug != null) {
- for (DataObjectModification<? extends DataObject> child : aug.getModifiedChildren()) {
+ for (DataObjectModification<? extends DataObject> child : aug.modifiedChildren()) {
updateDeviceOpData(key, child);
}
}
}
private void updateDeviceOpData(InstanceIdentifier<Node> key, DataObjectModification<? extends DataObject> mod) {
- Class<? extends KeyAware> childClass = (Class<? extends KeyAware>) mod.getDataType();
- InstanceIdentifier instanceIdentifier = getKey(key, mod, mod.getDataAfter());
- switch (mod.getModificationType()) {
+ Class<? extends KeyAware> childClass = (Class<? extends KeyAware>) mod.dataType();
+ InstanceIdentifier instanceIdentifier = getKey(key, mod, mod.dataAfter());
+ switch (mod.modificationType()) {
case WRITE:
connectionInstance.getDeviceInfo().updateDeviceOperData(childClass, instanceIdentifier,
- new UUID("uuid"), mod.getDataAfter());
+ new UUID("uuid"), mod.dataAfter());
break;
case DELETE:
connectionInstance.getDeviceInfo().clearDeviceOperData(childClass, instanceIdentifier);
private static InstanceIdentifier getKey(InstanceIdentifier<Node> key,
DataObjectModification<? extends DataObject> child, DataObject data) {
- Class<? extends DataObject> childClass = child.getDataType();
+ Class<? extends DataObject> childClass = child.dataType();
InstanceIdentifier instanceIdentifier = null;
if (LogicalSwitches.class == childClass) {
LogicalSwitches ls = (LogicalSwitches)data;
</parent>
<modelVersion>4.0.0</modelVersion>
- <groupId>org.opendaylight.ovsdb</groupId>
<artifactId>hwvtepsouthbound-it</artifactId>
- <version>1.18.0-SNAPSHOT</version>
<packaging>jar</packaging>
<!-- <name> formatting is used by autorelease to parse and notify projects on
build failure. Please do not modify this unless you have a good reason. -->
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.UnknownHostException;
-import java.util.Collection;
import java.util.HashSet;
+import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
}
@Override
- public void onDataTreeChanged(Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(List<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
- final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
+ final InstanceIdentifier<Node> key = change.getRootPath().path();
final DataObjectModification<Node> mod = change.getRootNode();
- switch (mod.getModificationType()) {
+ switch (mod.modificationType()) {
case DELETE:
removedNodes.add(key);
break;
updatedNodes.add(key);
break;
case WRITE:
- if (mod.getDataBefore() == null) {
- LOG.trace("Data added: {}", mod.getDataAfter());
+ if (mod.dataBefore() == null) {
+ LOG.trace("Data added: {}", mod.dataAfter());
createdNodes.add(key);
} else {
updatedNodes.add(key);
}
break;
default:
- throw new IllegalArgumentException("Unhandled modification type " + mod.getModificationType());
+ throw new IllegalArgumentException("Unhandled modification type " + mod.modificationType());
}
}
}
return combinedOptions;
}
- private Option[] getOtherOptions() {
+ private static Option[] getOtherOptions() {
return new Option[] {
vmOption("-javaagent:../jars/org.jacoco.agent.jar=destfile=../../jacoco-it.exec"),
keepRuntimeFolder()
return option;
}
- private Option[] getPropertiesOptions() {
+ private static Option[] getPropertiesOptions() {
Properties props = new Properties(System.getProperties());
String ipAddressStr = props.getProperty(SERVER_IPADDRESS, DEFAULT_SERVER_IPADDRESS);
String portStr = props.getProperty(SERVER_PORT, DEFAULT_SERVER_PORT);
assertTrue("Did not find " + HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID.getValue(), getHwvtepTopology());
final ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portNumber);
final InstanceIdentifier<Node> iid = HwvtepSouthboundUtils.createInstanceIdentifier(connectionInfo);
- final DataTreeIdentifier<Node> treeId = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, iid);
+ final DataTreeIdentifier<Node> treeId = DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, iid);
dataBroker.registerDataTreeChangeListener(treeId, OPERATIONAL_LISTENER);
setup = true;
}
- private Boolean getHwvtepTopology() {
+ private static Boolean getHwvtepTopology() {
LOG.info("getHwvtepTopology: looking for {}...", HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID.getValue());
Boolean found = false;
final TopologyId topologyId = HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID;
return found;
}
- private Node connectHwvtepNode(ConnectionInfo connectionInfo) throws InterruptedException {
+ private static Node connectHwvtepNode(ConnectionInfo connectionInfo) throws InterruptedException {
final InstanceIdentifier<Node> iid = HwvtepSouthboundUtils.createInstanceIdentifier(connectionInfo);
Assert.assertTrue(mdsalUtils.put(LogicalDatastoreType.CONFIGURATION,
iid, HwvtepSouthboundUtils.createNode(connectionInfo)));
LOG.info("Disconnected from {}", HwvtepSouthboundUtils.connectionInfoToString(connectionInfo));
}
- private void waitForOperationalCreation(InstanceIdentifier<Node> iid) throws InterruptedException {
+ private static void waitForOperationalCreation(InstanceIdentifier<Node> iid) throws InterruptedException {
synchronized (OPERATIONAL_LISTENER) {
long start = System.currentTimeMillis();
LOG.info("Waiting for OPERATIONAL DataChanged creation on {}", iid);
}
}
- private ConnectionInfo getConnectionInfo(String ipAddressStr, Uint16 portNum) {
+ private static ConnectionInfo getConnectionInfo(String ipAddressStr, Uint16 portNum) {
InetAddress inetAddress = null;
try {
inetAddress = InetAddress.getByName(ipAddressStr);
}
}
- private PhysicalSwitchAugmentation getPhysicalSwitch(ConnectionInfo connectionInfo) {
+ private static PhysicalSwitchAugmentation getPhysicalSwitch(ConnectionInfo connectionInfo) {
return getPhysicalSwitch(connectionInfo, PS_NAME);
}
- private PhysicalSwitchAugmentation getPhysicalSwitch(ConnectionInfo connectionInfo, String psName) {
+ private static PhysicalSwitchAugmentation getPhysicalSwitch(ConnectionInfo connectionInfo, String psName) {
return getPhysicalSwitch(connectionInfo, psName, LogicalDatastoreType.OPERATIONAL);
}
- private PhysicalSwitchAugmentation getPhysicalSwitch(ConnectionInfo connectionInfo, String psName,
+ private static PhysicalSwitchAugmentation getPhysicalSwitch(ConnectionInfo connectionInfo, String psName,
LogicalDatastoreType dataStore) {
Node psNode = getPhysicalSwitchNode(connectionInfo, psName, dataStore);
Assert.assertNotNull(psNode);
return psAugmentation;
}
- private Node getPhysicalSwitchNode(ConnectionInfo connectionInfo, String psName, LogicalDatastoreType dataStore) {
+ private static Node getPhysicalSwitchNode(ConnectionInfo connectionInfo, String psName,
+ LogicalDatastoreType dataStore) {
InstanceIdentifier<Node> psIid =
HwvtepSouthboundUtils.createInstanceIdentifier(connectionInfo, new HwvtepNodeName(psName));
return mdsalUtils.read(dataStore, psIid);
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>odl-aaa-cert</artifactId>
- <version>0.18.4</version>
+ <version>0.19.1</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<feature name="odl-ovsdb-library" version="${project.version}">
<feature version="[13,14)">odl-jackson-2</feature>
<feature version="[13,14)">odl-netty-4</feature>
- <feature version="[0.18,1)">odl-aaa-cert</feature>
+ <feature version="[0.19,1)">odl-aaa-cert</feature>
<configfile finalname="etc/org.opendaylight.ovsdb.library.cfg">
mvn:org.opendaylight.ovsdb/library/${project.version}/cfg/config
</configfile>
org.opendaylight.ovsdb.lib.*,
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.library.impl.rev141210
</Export-Package>
-
- <!-- FIXME: AAA-268: remove this instruction once aaa-cert exposes Provide-Capability -->
- <_dsannotations-options>norequirements</_dsannotations-options>
</instructions>
</configuration>
</plugin>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>12.0.4</version>
+ <version>13.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-southbound-api-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-southbound-api" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
- <feature version="[12,13)">odl-mdsal-model-odl-l2-types</feature>
+ <feature version="[13,14)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[13,14)">odl-mdsal-model-odl-l2-types</feature>
</feature>
</features>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>netconf-artifacts</artifactId>
- <version>6.0.6</version>
+ <version>7.0.0</version>
<scope>import</scope>
<type>pom</type>
</dependency>
-->
<features name="odl-ovsdb-southbound-impl-rest-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-southbound-impl-rest" version="${project.version}">
- <feature version="[6,7)">odl-restconf</feature>
+ <feature version="[7,8)">odl-restconf</feature>
</feature>
</features>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>netconf-artifacts</artifactId>
- <version>6.0.6</version>
+ <version>7.0.0</version>
<scope>import</scope>
<type>pom</type>
</dependency>
-->
<features name="odl-ovsdb-southbound-impl-ui-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-southbound-impl-ui" version="${project.version}">
- <feature version="[6,7)">odl-restconf-openapi</feature>
+ <feature version="[7,8)">odl-restconf-openapi</feature>
</feature>
</features>
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
-import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
+import org.opendaylight.yangtools.yang.data.util.AbstractStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.util.LeafrefResolver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class InstanceIdentifierCodec extends AbstractModuleStringInstanceIdentifierCodec
- implements EffectiveModelContextListener {
+public class InstanceIdentifierCodec extends AbstractStringInstanceIdentifierCodec {
private static final Logger LOG = LoggerFactory.getLogger(InstanceIdentifierCodec.class);
private final BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer;
@SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "Non-final for mocking")
public InstanceIdentifierCodec(final DOMSchemaService schemaService,
final BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer) {
- schemaService.registerSchemaContextListener(this);
+ schemaService.registerSchemaContextListener(this::onModelContextUpdated);
this.bindingNormalizedNodeSerializer = bindingNormalizedNodeSerializer;
}
}
@Override
- protected Module moduleForPrefix(final String prefix) {
- return context.findModules(prefix).stream().findFirst().orElse(null);
+ protected QNameModule moduleForPrefix(final String prefix) {
+ return context.findModules(prefix).stream().findFirst().map(Module::getQNameModule).orElse(null);
}
@Override
}
@Override
- public void onModelContextUpdated(final EffectiveModelContext schemaContext) {
+ protected Object deserializeKeyValue(final DataSchemaNode schemaNode, final LeafrefResolver resolver,
+ final String value) {
+ throw new UnsupportedOperationException("Not implemented");
+ }
+
+ private void onModelContextUpdated(final EffectiveModelContext schemaContext) {
this.context = schemaContext;
this.dataSchemaContextTree = DataSchemaContextTree.from(schemaContext);
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.eos.binding.api.Entity;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.ovsdb.lib.LockAquisitionCallback;
import org.opendaylight.ovsdb.lib.LockStolenCallback;
import org.opendaylight.ovsdb.lib.MonitorCallBack;
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.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private InstanceIdentifier<Node> instanceIdentifier;
private volatile boolean hasDeviceOwnership = false;
private Entity connectedEntity;
- private EntityOwnershipCandidateRegistration deviceOwnershipCandidateRegistration;
+ private Registration deviceOwnershipCandidateRegistration;
private OvsdbNodeAugmentation initialCreateData = null;
private final Map<UUID, InstanceIdentifier<Node>> ports = new ConcurrentHashMap<>();
private final Map<String, InstanceIdentifier<Node>> portInterfaces = new ConcurrentHashMap<>();
}
}
- public void setDeviceOwnershipCandidateRegistration(
- @NonNull final EntityOwnershipCandidateRegistration registration) {
+ public void setDeviceOwnershipCandidateRegistration(final @NonNull Registration registration) {
deviceOwnershipCandidateRegistration = registration;
}
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.Entity;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListener;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListenerRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
+import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
import org.opendaylight.ovsdb.lib.OvsdbClient;
import org.opendaylight.ovsdb.lib.OvsdbConnection;
import org.opendaylight.ovsdb.lib.OvsdbConnectionListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
reconciliationManager.cancelTerminationPointReconciliation();
}
- private void handleOwnershipChanged(final EntityOwnershipChange ownershipChange) {
- OvsdbConnectionInstance ovsdbConnectionInstance = getConnectionInstanceFromEntity(ownershipChange.getEntity());
- LOG.debug("Ovsdb handleOwnershipChanged: {} event received for device {}",
- ownershipChange, ovsdbConnectionInstance != null ? ovsdbConnectionInstance.getConnectionInfo()
- : "that's currently NOT registered by *this* southbound plugin instance");
+ @VisibleForTesting
+ void handleOwnershipChanged(final Entity entity, final EntityOwnershipStateChange change) {
+ OvsdbConnectionInstance ovsdbConnectionInstance = getConnectionInstanceFromEntity(entity);
+ LOG.debug("Ovsdb handleOwnershipChanged: {} event received for device {}", change,
+ ovsdbConnectionInstance != null ? ovsdbConnectionInstance.getConnectionInfo()
+ : "that's currently NOT registered by *this* southbound plugin instance");
if (ovsdbConnectionInstance == null) {
- if (ownershipChange.getState().isOwner()) {
+ if (change.isOwner()) {
LOG.warn("Ovsdb handleOwnershipChanged: *this* instance is elected as an owner of the device {} but it "
- + "is NOT registered for ownership", ownershipChange.getEntity());
+ + "is NOT registered for ownership", entity);
} else {
// EntityOwnershipService sends notification to all the nodes, irrespective of whether
// that instance registered for the device ownership or not. It is to make sure that
// running instance can clear up the operational data store even though it was not
// connected to the device.
LOG.debug("Ovsdb handleOwnershipChanged: No connection instance found for {}",
- ownershipChange.getEntity());
+ entity);
}
// If entity has no owner, clean up the operational data store (it's possible because owner controller
// might went down abruptly and didn't get a chance to clean up the operational data store.
- if (!ownershipChange.getState().hasOwner()) {
- LOG.info("Ovsdb {} has no owner, cleaning up the operational data store", ownershipChange.getEntity());
- cleanEntityOperationalData(ownershipChange.getEntity());
+ if (!change.hasOwner()) {
+ LOG.info("Ovsdb {} has no owner, cleaning up the operational data store", entity);
+ cleanEntityOperationalData(entity);
}
return;
}
//Connection detail need to be cached, irrespective of ownership result.
putConnectionInstance(ovsdbConnectionInstance.getMDConnectionInfo(),ovsdbConnectionInstance);
- if (ownershipChange.getState().isOwner() == ovsdbConnectionInstance.getHasDeviceOwnership()) {
+ if (change.isOwner() == ovsdbConnectionInstance.getHasDeviceOwnership()) {
LOG.info("Ovsdb handleOwnershipChanged: no change in ownership for {}. Ownership status is : {}",
ovsdbConnectionInstance.getConnectionInfo(), ovsdbConnectionInstance.getHasDeviceOwnership()
? OwnershipStates.OWNER.getState()
return;
}
- ovsdbConnectionInstance.setHasDeviceOwnership(ownershipChange.getState().isOwner());
+ ovsdbConnectionInstance.setHasDeviceOwnership(change.isOwner());
// You were not an owner, but now you are
- if (ownershipChange.getState().isOwner()) {
+ if (change.isOwner()) {
LOG.info("Ovsdb handleOwnershipChanged: *this* southbound plugin instance is an OWNER of the device {}",
ovsdbConnectionInstance.getConnectionInfo());
entityConnectionMap.put(candidateEntity, ovsdbConnectionInstance);
ovsdbConnectionInstance.setConnectedEntity(candidateEntity);
try {
- EntityOwnershipCandidateRegistration registration =
- entityOwnershipService.registerCandidate(candidateEntity);
+ Registration registration = entityOwnershipService.registerCandidate(candidateEntity);
ovsdbConnectionInstance.setDeviceOwnershipCandidateRegistration(registration);
LOG.info("OVSDB entity {} is registered for ownership.", candidateEntity);
LOG.warn("OVSDB entity {} was already registered for ownership", candidateEntity, e);
}
//If entity already has owner, it won't get notification from EntityOwnershipService
- java.util.Optional<EntityOwnershipState> ownershipStateOpt =
- entityOwnershipService.getOwnershipState(candidateEntity);
+ Optional<EntityOwnershipState> ownershipStateOpt = entityOwnershipService.getOwnershipState(candidateEntity);
if (ownershipStateOpt.isPresent()) {
EntityOwnershipState ownershipState = ownershipStateOpt.orElseThrow();
if (ownershipState == EntityOwnershipState.OWNED_BY_OTHER) {
private static final class OvsdbDeviceEntityOwnershipListener implements EntityOwnershipListener {
private final OvsdbConnectionManager cm;
- private final EntityOwnershipListenerRegistration listenerRegistration;
+ private final Registration listenerRegistration;
OvsdbDeviceEntityOwnershipListener(final OvsdbConnectionManager cm,
final EntityOwnershipService entityOwnershipService) {
}
@Override
- public void ownershipChanged(final EntityOwnershipChange ownershipChange) {
- cm.handleOwnershipChanged(ownershipChange);
+ public void ownershipChanged(final Entity entity, final EntityOwnershipStateChange change,
+ final boolean inJeopardy) {
+ cm.handleOwnershipChanged(entity, change);
}
}
* 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.ovsdb.southbound;
import java.net.ConnectException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.eclipse.jdt.annotation.NonNull;
-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.DataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
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.Node;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Data-tree change listener for OVSDB.
*/
-public final class OvsdbDataTreeChangeListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
+public final class OvsdbDataTreeChangeListener implements DataTreeChangeListener<Node>, AutoCloseable {
/** Our registration. */
- private final ListenerRegistration<DataTreeChangeListener<Node>> registration;
+ private final Registration registration;
/** The connection manager. */
private final OvsdbConnectionManager cm;
* @param db The data broker.
* @param cm The connection manager.
*/
- OvsdbDataTreeChangeListener(DataBroker db, OvsdbConnectionManager cm,
- InstanceIdentifierCodec instanceIdentifierCodec) {
+ OvsdbDataTreeChangeListener(final DataBroker db, final OvsdbConnectionManager cm,
+ final InstanceIdentifierCodec instanceIdentifierCodec) {
this.cm = cm;
this.db = db;
this.instanceIdentifierCodec = instanceIdentifierCodec;
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
.child(Node.class);
- DataTreeIdentifier<Node> dataTreeIdentifier =
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, path);
- registration = db.registerDataTreeChangeListener(dataTreeIdentifier, this);
+ DataTreeIdentifier<Node> dataTreeIdentifier = DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, path);
+ registration = db.registerTreeChangeListener(dataTreeIdentifier, this);
LOG.info("OVSDB topology listener has been registered.");
}
}
@Override
- public void onDataTreeChanged(@NonNull Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(final List<DataTreeModification<Node>> changes) {
LOG.trace("onDataTreeChanged: {}", changes);
// Connect first if necessary
LOG.trace("onDataTreeChanged: exit");
}
- private void connect(@NonNull Collection<DataTreeModification<Node>> changes) {
+ private void connect(final @NonNull List<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
- if (change.getRootNode().getModificationType() == DataObjectModification.ModificationType.WRITE || change
- .getRootNode().getModificationType() == DataObjectModification.ModificationType.SUBTREE_MODIFIED) {
+ if (change.getRootNode().modificationType() == DataObjectModification.ModificationType.WRITE || change
+ .getRootNode().modificationType() == DataObjectModification.ModificationType.SUBTREE_MODIFIED) {
DataObjectModification<OvsdbNodeAugmentation> ovsdbNodeModification =
change.getRootNode().getModifiedAugmentation(OvsdbNodeAugmentation.class);
- if (ovsdbNodeModification != null && ovsdbNodeModification.getDataBefore() == null) {
- OvsdbNodeAugmentation ovsdbNode = ovsdbNodeModification.getDataAfter();
+ if (ovsdbNodeModification != null && ovsdbNodeModification.dataBefore() == null) {
+ OvsdbNodeAugmentation ovsdbNode = ovsdbNodeModification.dataAfter();
if (ovsdbNode != null) {
ConnectionInfo key = ovsdbNode.getConnectionInfo();
if (key != null) {
+ "connections to same device, hence dropping the request {}", key, ovsdbNode);
} else {
try {
- cm.connect(change.getRootPath().getRootIdentifier(), ovsdbNode);
+ cm.connect(change.getRootPath().path(), ovsdbNode);
LOG.info("OVSDB node has been connected: {}",ovsdbNode);
} catch (UnknownHostException | ConnectException e) {
LOG.warn("Failed to connect to ovsdbNode", e);
}
}
- private void disconnect(@NonNull Collection<DataTreeModification<Node>> changes) {
+ private void disconnect(final @NonNull List<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
- if (change.getRootNode().getModificationType() == DataObjectModification.ModificationType.DELETE) {
+ if (change.getRootNode().modificationType() == DataObjectModification.ModificationType.DELETE) {
DataObjectModification<OvsdbNodeAugmentation> ovsdbNodeModification =
change.getRootNode().getModifiedAugmentation(OvsdbNodeAugmentation.class);
if (ovsdbNodeModification != null) {
- OvsdbNodeAugmentation ovsdbNode = ovsdbNodeModification.getDataBefore();
+ OvsdbNodeAugmentation ovsdbNode = ovsdbNodeModification.dataBefore();
if (ovsdbNode != null) {
ConnectionInfo key = ovsdbNode.getConnectionInfo();
InstanceIdentifier<Node> iid = cm.getInstanceIdentifier(key);
}
}
- if (change.getRootNode().getModificationType() == DataObjectModification.ModificationType.WRITE) {
+ if (change.getRootNode().modificationType() == DataObjectModification.ModificationType.WRITE) {
DataObjectModification<OvsdbNodeAugmentation> ovsdbNodeModification =
change.getRootNode().getModifiedAugmentation(OvsdbNodeAugmentation.class);
if (ovsdbNodeModification != null) {
DataObjectModification<ConnectionInfo> connectionInfoDOM =
ovsdbNodeModification.getModifiedChildContainer(ConnectionInfo.class);
if (connectionInfoDOM != null) {
- if (connectionInfoDOM.getModificationType() == DataObjectModification.ModificationType.DELETE) {
- ConnectionInfo key = connectionInfoDOM.getDataBefore();
+ if (connectionInfoDOM.modificationType() == DataObjectModification.ModificationType.DELETE) {
+ ConnectionInfo key = connectionInfoDOM.dataBefore();
if (key != null) {
InstanceIdentifier<Node> iid = cm.getInstanceIdentifier(key);
try {
- OvsdbNodeAugmentation ovsdbNode = ovsdbNodeModification.getDataBefore();
+ OvsdbNodeAugmentation ovsdbNode = ovsdbNodeModification.dataBefore();
cm.disconnect(ovsdbNode);
LOG.warn("OVSDB node {} has been disconnected, because connection-info related to "
+ "the node is removed by user, but node still exist.", ovsdbNode);
}
}
- private void updateConnections(@NonNull Collection<DataTreeModification<Node>> changes) {
+ private void updateConnections(final @NonNull List<DataTreeModification<Node>> changes) {
for (DataTreeModification<Node> change : changes) {
- switch (change.getRootNode().getModificationType()) {
+ switch (change.getRootNode().modificationType()) {
case SUBTREE_MODIFIED:
case WRITE:
DataObjectModification<OvsdbNodeAugmentation> ovsdbNodeModification =
change.getRootNode().getModifiedAugmentation(OvsdbNodeAugmentation.class);
if (ovsdbNodeModification != null) {
- final OvsdbNodeAugmentation dataBefore = ovsdbNodeModification.getDataBefore();
+ final OvsdbNodeAugmentation dataBefore = ovsdbNodeModification.dataBefore();
if (dataBefore != null) {
- OvsdbNodeAugmentation dataAfter = ovsdbNodeModification.getDataAfter();
+ OvsdbNodeAugmentation dataAfter = ovsdbNodeModification.dataAfter();
if (dataAfter != null) {
ConnectionInfo connectionInfo = dataAfter.getConnectionInfo();
if (connectionInfo != null) {
if (dataBefore != null) {
try {
cm.disconnect(dataBefore);
- cm.connect(change.getRootPath().getRootIdentifier(), dataAfter);
+ cm.connect(change.getRootPath().path(), dataAfter);
} catch (UnknownHostException | ConnectException e) {
LOG.warn("Error disconnecting from or connecting to ovsdbNode", e);
}
}
}
- private void updateData(@NonNull Collection<DataTreeModification<Node>> changes) {
+ private void updateData(final @NonNull List<DataTreeModification<Node>> changes) {
for (Entry<OvsdbConnectionInstance, Collection<DataTreeModification<Node>>> connectionInstanceEntry :
changesPerConnectionInstance(changes).entrySet()) {
OvsdbConnectionInstance connectionInstance = connectionInstanceEntry.getKey();
}
private Map<OvsdbConnectionInstance, Collection<DataTreeModification<Node>>> changesPerConnectionInstance(
- @NonNull Collection<DataTreeModification<Node>> changes) {
+ final @NonNull List<DataTreeModification<Node>> changes) {
Map<OvsdbConnectionInstance, Collection<DataTreeModification<Node>>> result = new HashMap<>();
for (DataTreeModification<Node> change : changes) {
OvsdbConnectionInstance client = null;
- Node dataAfter = change.getRootNode().getDataAfter();
- Node node = dataAfter != null ? dataAfter : change.getRootNode().getDataBefore();
+ Node dataAfter = change.getRootNode().dataAfter();
+ Node node = dataAfter != null ? dataAfter : change.getRootNode().dataBefore();
if (node != null) {
OvsdbNodeAugmentation ovsdbNode = node.augmentation(OvsdbNodeAugmentation.class);
if (ovsdbNode != null) {
if (client == null) {
//Try getting from change root identifier
- client = cm.getConnectionInstance(change.getRootPath().getRootIdentifier());
+ client = cm.getConnectionInstance(change.getRootPath().path());
}
} else {
LOG.warn("Following change don't have after/before data {}", change);
*/
package org.opendaylight.ovsdb.southbound;
-import java.util.Collection;
+import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
-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.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.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
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.Node;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class OvsdbOperGlobalListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
+public final class OvsdbOperGlobalListener implements DataTreeChangeListener<Node>, AutoCloseable {
public static final ConcurrentMap<InstanceIdentifier<Node>, Node> OPER_NODE_CACHE = new ConcurrentHashMap<>();
private static final Logger LOG = LoggerFactory.getLogger(OvsdbOperGlobalListener.class);
- private ListenerRegistration<OvsdbOperGlobalListener> registration;
+ private Registration registration;
private final DataBroker db;
private final OvsdbConnectionManager ovsdbConnectionManager;
private final TransactionInvoker txInvoker;
}
public void registerListener() {
- DataTreeIdentifier<Node> treeId =
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, getWildcardPath());
- registration = db.registerDataTreeChangeListener(treeId, this);
+ registration = db.registerTreeChangeListener(DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class)
+ .build()), this);
}
@Override
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
- public void onDataTreeChanged(final Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(final List<DataTreeModification<Node>> changes) {
changes.forEach(change -> {
try {
- InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
+ InstanceIdentifier<Node> key = change.getRootPath().path();
DataObjectModification<Node> mod = change.getRootNode();
Node addNode = getCreated(mod);
if (addNode != null) {
}
private static Node getCreated(final DataObjectModification<Node> mod) {
- if (mod.getModificationType() == DataObjectModification.ModificationType.WRITE
- && mod.getDataBefore() == null) {
- return mod.getDataAfter();
+ if (mod.modificationType() == DataObjectModification.ModificationType.WRITE
+ && mod.dataBefore() == null) {
+ return mod.dataAfter();
}
return null;
}
private static Node getRemoved(final DataObjectModification<Node> mod) {
- if (mod.getModificationType() == DataObjectModification.ModificationType.DELETE) {
- return mod.getDataBefore();
+ if (mod.modificationType() == DataObjectModification.ModificationType.DELETE) {
+ return mod.dataBefore();
}
return null;
}
private static Node getUpdated(final DataObjectModification<Node> mod) {
Node node = null;
- switch (mod.getModificationType()) {
+ switch (mod.modificationType()) {
case SUBTREE_MODIFIED:
- node = mod.getDataAfter();
+ node = mod.dataAfter();
break;
case WRITE:
- if (mod.getDataBefore() != null) {
- node = mod.getDataAfter();
+ if (mod.dataBefore() != null) {
+ node = mod.dataAfter();
}
break;
default:
}
return node;
}
-
- private static InstanceIdentifier<Node> getWildcardPath() {
- return InstanceIdentifier.create(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
- .child(Node.class);
- }
}
}
public static InstanceIdentifier<Topology> createTopologyInstanceIdentifier() {
- return InstanceIdentifier
- .create(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));
+ return InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));
}
public static InstanceIdentifier<Node> createInstanceIdentifier(final NodeId nodeId) {
- return createTopologyInstanceIdentifier()
- .child(Node.class,new NodeKey(nodeId));
+ return createTopologyInstanceIdentifier().child(Node.class, new NodeKey(nodeId));
}
@SuppressWarnings("unchecked")
import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.FluentFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.util.Collection;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicBoolean;
import org.opendaylight.infrautils.diagstatus.DiagStatusService;
import org.opendaylight.infrautils.diagstatus.ServiceState;
import org.opendaylight.infrautils.ready.SystemReadyMonitor;
-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.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.eos.binding.api.Entity;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListener;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListenerRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
+import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
import org.opendaylight.ovsdb.lib.OvsdbConnection;
import org.opendaylight.ovsdb.southbound.transactions.md.TransactionInvoker;
import org.opendaylight.ovsdb.southbound.transactions.md.TransactionInvokerImpl;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
@Component(service = { }, configurationPid = "org.opendaylight.ovsdb.southbound")
@Designate(ocd = SouthboundProvider.Configuration.class)
// non-final for testing
-public class SouthboundProvider implements ClusteredDataTreeChangeListener<Topology>, AutoCloseable {
+public class SouthboundProvider implements DataTreeChangeListener<Topology>, AutoCloseable {
@ObjectClassDefinition
public @interface Configuration {
@AttributeDefinition
private final AtomicBoolean registered = new AtomicBoolean(false);
private final OvsdbDiagStatusProvider ovsdbStatusProvider;
- private EntityOwnershipCandidateRegistration registration;
- private ListenerRegistration<SouthboundProvider> operTopologyRegistration;
+ private Registration registration;
+ private Registration operTopologyRegistration;
@Inject
public SouthboundProvider(final DataBroker dataBroker,
InstanceIdentifier<Topology> path = InstanceIdentifier
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));
- DataTreeIdentifier<Topology> treeId =
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, path);
+ DataTreeIdentifier<Topology> treeId = DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, path);
LOG.trace("Registering listener for path {}", treeId);
- operTopologyRegistration = dataBroker.registerDataTreeChangeListener(treeId, this);
+ operTopologyRegistration = dataBroker.registerTreeChangeListener(treeId, this);
LOG.info("SouthboundProvider Session Initiated");
}
FluentFuture<Boolean> ovsdbTp = transaction.exists(type, path);
try {
if (!ovsdbTp.get().booleanValue()) {
- TopologyBuilder tpb = new TopologyBuilder();
- tpb.setTopologyId(SouthboundConstants.OVSDB_TOPOLOGY_ID);
- transaction.mergeParentStructurePut(type, path, tpb.build());
+ transaction.mergeParentStructurePut(type, path,
+ new TopologyBuilder().setTopologyId(SouthboundConstants.OVSDB_TOPOLOGY_ID).build());
transaction.commit();
} else {
transaction.cancel();
}
}
- public void handleOwnershipChange(final EntityOwnershipChange ownershipChange) {
- if (ownershipChange.getState().isOwner()) {
+ public void handleOwnershipChange(final EntityOwnershipStateChange change) {
+ if (change.isOwner()) {
LOG.info("*This* instance of OVSDB southbound provider is set as a MASTER instance");
LOG.info("Initialize OVSDB topology {} in operational and config data store if not already present",
SouthboundConstants.OVSDB_TOPOLOGY_ID);
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Topology>> collection) {
+ public void onDataTreeChanged(final List<DataTreeModification<Topology>> collection) {
if (!registered.getAndSet(true)) {
LOG.info("Starting the ovsdb port");
ovsdbConnection.registerConnectionListener(cm);
private static final class SouthboundPluginInstanceEntityOwnershipListener implements EntityOwnershipListener {
private final SouthboundProvider sp;
- private final EntityOwnershipListenerRegistration listenerRegistration;
+ private final Registration listenerRegistration;
SouthboundPluginInstanceEntityOwnershipListener(final SouthboundProvider sp,
final EntityOwnershipService entityOwnershipService) {
}
@Override
- public void ownershipChanged(final EntityOwnershipChange ownershipChange) {
- sp.handleOwnershipChange(ownershipChange);
+ public void ownershipChanged(final Entity entity, final EntityOwnershipStateChange change,
+ final boolean inJeopardy) {
+ sp.handleOwnershipChange(change);
}
}
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.Key;
import org.opendaylight.yangtools.yang.binding.KeyAware;
+import org.opendaylight.yangtools.yang.binding.KeyStep;
// This class needs to be mocked
@SuppressWarnings("checkstyle:FinalClass")
}
private static <T extends DataObject> Predicate<DataObjectModification<T>> hasDataBefore() {
- return input -> input != null && input.getDataBefore() != null;
+ return input -> input != null && input.dataBefore() != null;
}
private static <T extends DataObject> Predicate<DataObjectModification<T>> hasDataBeforeAndDataAfter() {
- return input -> input != null && input.getDataBefore() != null && input.getDataAfter() != null;
+ return input -> input != null && input.dataBefore() != null && input.dataAfter() != null;
}
private static <T extends DataObject> Predicate<DataObjectModification<T>> hasNoDataBefore() {
- return input -> input != null && input.getDataBefore() == null;
+ return input -> input != null && input.dataBefore() == null;
}
private static <T extends DataObject> Predicate<DataObjectModification<T>> hasDataAfterAndMatchesFilter(
final Predicate<DataObjectModification<T>> filter) {
- return input -> input != null && input.getDataAfter() != null && filter.test(input);
+ return input -> input != null && input.dataAfter() != null && filter.test(input);
}
private static <T extends DataObject> Predicate<DataObjectModification<T>> matchesEverything() {
}
private static <T extends DataObject> Predicate<DataObjectModification<T>> modificationIsDeletion() {
- return input -> input != null && input.getModificationType() == DataObjectModification
- .ModificationType.DELETE;
+ return input -> input != null && input.modificationType() == DataObjectModification.ModificationType.DELETE;
}
private static <T extends DataObject> Predicate<DataObjectModification<T>>
modificationIsDeletionAndHasDataBefore() {
- return input -> input != null && input.getModificationType() == DataObjectModification
- .ModificationType.DELETE && input.getDataBefore() != null;
+ return input -> input != null && input.modificationType() == DataObjectModification.ModificationType.DELETE
+ && input.dataBefore() != null;
}
- public static Map<InstanceIdentifier<Node>,Node> extractNode(
- Map<InstanceIdentifier<?>, DataObject> changes) {
+ public static Map<InstanceIdentifier<Node>,Node> extractNode(final Map<InstanceIdentifier<?>, DataObject> changes) {
Map<InstanceIdentifier<Node>,Node> result
= new HashMap<>();
if (changes != null) {
}
public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractCreated(
- DataChangeEvent changes, Class<T> klazz) {
+ final DataChangeEvent changes, final Class<T> klazz) {
return extract(changes.getCreatedData(),klazz);
}
* @return The created instances, mapped by instance identifier.
*/
public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractCreated(
- Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+ final Collection<DataTreeModification<U>> changes, final Class<T> clazz) {
return extractCreatedOrUpdated(changes, clazz, hasNoDataBefore());
}
public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractUpdated(
- DataChangeEvent changes, Class<T> klazz) {
+ final DataChangeEvent changes, final Class<T> klazz) {
return extract(changes.getUpdatedData(),klazz);
}
* @return The updated instances, mapped by instance identifier.
*/
public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractUpdated(
- Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+ final Collection<DataTreeModification<U>> changes, final Class<T> clazz) {
return extractCreatedOrUpdated(changes, clazz, hasDataBeforeAndDataAfter());
}
* @return The created or updated instances which satisfy the filter, mapped by instance identifier.
*/
public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractCreatedOrUpdated(
- Collection<DataTreeModification<U>> changes, Class<T> clazz,
- Predicate<DataObjectModification<T>> filter) {
+ final Collection<DataTreeModification<U>> changes, final Class<T> clazz,
+ final Predicate<DataObjectModification<T>> filter) {
Map<InstanceIdentifier<T>, T> result = new HashMap<>();
for (Map.Entry<InstanceIdentifier<T>, DataObjectModification<T>> entry : extractDataObjectModifications(changes,
clazz, hasDataAfterAndMatchesFilter(filter)).entrySet()) {
- result.put(entry.getKey(), entry.getValue().getDataAfter());
+ result.put(entry.getKey(), entry.getValue().dataAfter());
}
return result;
}
public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractCreatedOrUpdated(
- DataChangeEvent changes,Class<T> klazz) {
+ final DataChangeEvent changes,final Class<T> klazz) {
Map<InstanceIdentifier<T>,T> result = extractUpdated(changes,klazz);
result.putAll(extractCreated(changes,klazz));
return result;
* @return The created or updated instances, mapped by instance identifier.
*/
public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractCreatedOrUpdated(
- Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+ final Collection<DataTreeModification<U>> changes, final Class<T> clazz) {
return extractCreatedOrUpdated(changes, clazz, matchesEverything());
}
public static <T extends DataObject> Map<InstanceIdentifier<T>, T> extractCreatedOrUpdatedOrRemoved(
- DataChangeEvent changes, Class<T> klazz) {
+ final DataChangeEvent changes, final Class<T> klazz) {
Map<InstanceIdentifier<T>,T> result = extractCreatedOrUpdated(changes,klazz);
result.putAll(extractRemovedObjects(changes, klazz));
return result;
*/
public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T>
extractCreatedOrUpdatedOrRemoved(
- Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+ final Collection<DataTreeModification<U>> changes, final Class<T> clazz) {
Map<InstanceIdentifier<T>, T> result = extractCreatedOrUpdated(changes, clazz);
result.putAll(extractRemovedObjects(changes, clazz));
return result;
}
public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractOriginal(
- DataChangeEvent changes, Class<T> klazz) {
+ final DataChangeEvent changes, final Class<T> klazz) {
return extract(changes.getOriginalData(),klazz);
}
* @return The original instances, mapped by instance identifier.
*/
public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractOriginal(
- Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+ final Collection<DataTreeModification<U>> changes, final Class<T> clazz) {
Map<InstanceIdentifier<T>, T> result = new HashMap<>();
for (Map.Entry<InstanceIdentifier<T>, DataObjectModification<T>> entry :
extractDataObjectModifications(changes, clazz, hasDataBefore()).entrySet()) {
- result.put(entry.getKey(), entry.getValue().getDataBefore());
+ result.put(entry.getKey(), entry.getValue().dataBefore());
}
return result;
}
public static <T extends DataObject> Set<InstanceIdentifier<T>> extractRemoved(
- DataChangeEvent changes, Class<T> klazz) {
+ final DataChangeEvent changes, final Class<T> klazz) {
Set<InstanceIdentifier<T>> result = new HashSet<>();
if (changes != null && changes.getRemovedPaths() != null) {
for (InstanceIdentifier<?> iid : changes.getRemovedPaths()) {
* @return The instance identifiers of removed instances.
*/
public static <T extends DataObject, U extends DataObject> Set<InstanceIdentifier<T>> extractRemoved(
- Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+ final Collection<DataTreeModification<U>> changes, final Class<T> clazz) {
return extractDataObjectModifications(changes, clazz, modificationIsDeletion()).keySet();
}
* @return The modifications, mapped by instance identifier.
*/
private static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, DataObjectModification<T>>
- extractDataObjectModifications(Collection<DataTreeModification<U>> changes, Class<T> clazz,
- Predicate<DataObjectModification<T>> filter) {
+ extractDataObjectModifications(final Collection<DataTreeModification<U>> changes, final Class<T> clazz,
+ final Predicate<DataObjectModification<T>> filter) {
List<DataObjectModification<? extends DataObject>> dataObjectModifications = new ArrayList<>();
List<InstanceIdentifier<? extends DataObject>> paths = new ArrayList<>();
if (changes != null) {
for (DataTreeModification<? extends DataObject> change : changes) {
dataObjectModifications.add(change.getRootNode());
- paths.add(change.getRootPath().getRootIdentifier());
+ paths.add(change.getRootPath().path());
}
}
return extractDataObjectModifications(dataObjectModifications, paths, clazz, filter);
*/
private static <T extends DataObject> Map<InstanceIdentifier<T>, DataObjectModification<T>>
extractDataObjectModifications(
- Collection<DataObjectModification<? extends DataObject>> changes,
- Collection<InstanceIdentifier<? extends DataObject>> paths, Class<T> clazz,
- Predicate<DataObjectModification<T>> filter) {
+ final Collection<DataObjectModification<? extends DataObject>> changes,
+ final Collection<InstanceIdentifier<? extends DataObject>> paths, final Class<T> clazz,
+ final Predicate<DataObjectModification<T>> filter) {
Map<InstanceIdentifier<T>, DataObjectModification<T>> result = new HashMap<>();
Queue<DataObjectModification<? extends DataObject>> remainingChanges = new LinkedList<>(changes);
Queue<InstanceIdentifier<? extends DataObject>> remainingPaths = new LinkedList<>(paths);
DataObjectModification<? extends DataObject> change = remainingChanges.remove();
InstanceIdentifier<? extends DataObject> path = remainingPaths.remove();
// Is the change relevant?
- if (clazz.isAssignableFrom(change.getDataType())) {
+ if (clazz.isAssignableFrom(change.dataType())) {
@SuppressWarnings("unchecked")
final DataObjectModification<T> dao = (DataObjectModification<T>) change;
if (filter.test(dao)) {
}
}
// Add any children to the queue
- for (DataObjectModification<? extends DataObject> child : change.getModifiedChildren()) {
+ for (DataObjectModification<? extends DataObject> child : change.modifiedChildren()) {
remainingChanges.add(child);
remainingPaths.add(extendPath(path, child));
}
*/
private static <N extends KeyAware<K> & ChildOf<? super T>, K extends Key<N>, T extends DataObject>
InstanceIdentifier<? extends DataObject> extendPath(
- InstanceIdentifier<T> path,
- DataObjectModification<?> child) {
+ final InstanceIdentifier<T> path,
+ final DataObjectModification<?> child) {
@SuppressWarnings("unchecked")
- final Class<N> item = (Class<N>) child.getDataType();
- if (child.getIdentifier() instanceof InstanceIdentifier.IdentifiableItem) {
- return path.child(item, ((InstanceIdentifier.IdentifiableItem<N, K>) child.getIdentifier()).getKey());
+ final Class<N> item = (Class<N>) child.dataType();
+ if (child.step() instanceof KeyStep<?, ?> keyStep) {
+ return path.child(item, (K) keyStep.key());
}
return path.child(item);
}
public static <T extends DataObject> Map<InstanceIdentifier<T>, T> extractRemovedObjects(
- DataChangeEvent changes, Class<T> klazz) {
+ final DataChangeEvent changes, final Class<T> klazz) {
Set<InstanceIdentifier<T>> iids = extractRemoved(changes, klazz);
return Maps.filterKeys(extractOriginal(changes, klazz),Predicates.in(iids));
}
* @return The removed instances, keyed by instance identifier.
*/
public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractRemovedObjects(
- Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+ final Collection<DataTreeModification<U>> changes, final Class<T> clazz) {
Map<InstanceIdentifier<T>, T> result = new HashMap<>();
for (Map.Entry<InstanceIdentifier<T>, DataObjectModification<T>> entry :
extractDataObjectModifications(changes, clazz, modificationIsDeletionAndHasDataBefore()).entrySet()) {
- result.put(entry.getKey(), entry.getValue().getDataBefore());
+ result.put(entry.getKey(), entry.getValue().dataBefore());
}
return result;
}
public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extract(
- Map<InstanceIdentifier<?>, DataObject> changes, Class<T> klazz) {
+ final Map<InstanceIdentifier<?>, DataObject> changes, final Class<T> klazz) {
Map<InstanceIdentifier<T>,T> result = new HashMap<>();
if (changes != null) {
for (Entry<InstanceIdentifier<?>, DataObject> created : changes.entrySet()) {
return result;
}
- public static List<Insert> extractInsert(TransactionBuilder transaction, GenericTableSchema schema) {
+ public static List<Insert> extractInsert(final TransactionBuilder transaction, final GenericTableSchema schema) {
List<Operation> operations = transaction.getOperations();
List<Insert> inserts = new ArrayList<>();
for (Operation operation : operations) {
* @param insert - Insert from which to extract the NamedUuid
* @return UUID - NamedUUID of the Insert
*/
- public static UUID extractNamedUuid(Insert insert) {
+ public static UUID extractNamedUuid(final Insert insert) {
String uuidString = insert.getUuidName() != null
? insert.getUuidName() : SouthboundMapper.getRandomUuid();
insert.setUuidName(uuidString);
return new UUID(uuidString);
}
- public static <T extends TableSchema<T>> void stampInstanceIdentifier(TransactionBuilder transaction,
- InstanceIdentifier<?> iid, TableSchema<T> tableSchema, ColumnSchema<T, Map<String, String>> columnSchema,
- InstanceIdentifierCodec instanceIdentifierCodec) {
+ public static <T extends TableSchema<T>> void stampInstanceIdentifier(final TransactionBuilder transaction,
+ final InstanceIdentifier<?> iid, final TableSchema<T> tableSchema,
+ final ColumnSchema<T, Map<String, String>> columnSchema,
+ final InstanceIdentifierCodec instanceIdentifierCodec) {
transaction.add(
- stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema, instanceIdentifierCodec));
+ stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema, instanceIdentifierCodec));
}
- public static <T extends TableSchema<T>> Mutate<T> stampInstanceIdentifierMutation(TransactionBuilder transaction,
- InstanceIdentifier<?> iid, TableSchema<T> tableSchema, ColumnSchema<T, Map<String, String>> columnSchema,
- InstanceIdentifierCodec instanceIdentifierCodec) {
+ public static <T extends TableSchema<T>> Mutate<T> stampInstanceIdentifierMutation(
+ final TransactionBuilder transaction, final InstanceIdentifier<?> iid, final TableSchema<T> tableSchema,
+ final ColumnSchema<T, Map<String, String>> columnSchema,
+ final InstanceIdentifierCodec instanceIdentifierCodec) {
Map<String,String> externalIdsMap = ImmutableMap.of(SouthboundConstants.IID_EXTERNAL_ID_KEY,
instanceIdentifierCodec.serialize(iid));
Mutate<T> mutate = op.mutate(tableSchema)
* @return The hexadecimal representation of the byte array. If bytes is
* null, the string "" is returned
*/
- public static String bytesToHexString(byte[] bytes) {
+ public static String bytesToHexString(final byte[] bytes) {
if (bytes == null) {
return "";
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.google.common.util.concurrent.UncheckedExecutionException;
-import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
-import org.eclipse.jdt.annotation.NonNull;
-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.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
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.NodeKey;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.util.concurrent.SpecialExecutors;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
private LoadingCache<NodeKey, NodeConnectionMetadata> bridgeNodeCache = null;
// Listens for new bridge creations in the operational DS
- private ListenerRegistration<BridgeCreatedDataTreeChangeListener> bridgeCreatedDataTreeChangeRegistration = null;
+ private Registration bridgeCreatedDataTreeChangeRegistration = null;
private final ReconciliationTaskManager reconTaskManager = new ReconciliationTaskManager();
new BridgeCreatedDataTreeChangeListener();
InstanceIdentifier<Node> path = SouthboundMapper.createTopologyInstanceIdentifier()
.child(Node.class);
- DataTreeIdentifier<Node> dataTreeIdentifier =
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, path);
+ DataTreeIdentifier<Node> dataTreeIdentifier = DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, path);
- bridgeCreatedDataTreeChangeRegistration = db.registerDataTreeChangeListener(dataTreeIdentifier,
+ bridgeCreatedDataTreeChangeRegistration = db.registerTreeChangeListener(dataTreeIdentifier,
bridgeCreatedDataTreeChangeListener);
}
}
* is triggered and the bridge entry is removed from the cache.
* Once cache is empty, either being removed explicitly or expired, the the listener de-registered.
*/
- class BridgeCreatedDataTreeChangeListener implements ClusteredDataTreeChangeListener<Node> {
+ class BridgeCreatedDataTreeChangeListener implements DataTreeChangeListener<Node> {
@Override
- public void onDataTreeChanged(@NonNull Collection<DataTreeModification<Node>> changes) {
+ public void onDataTreeChanged(List<DataTreeModification<Node>> changes) {
bridgeNodeCache.cleanUp();
if (!bridgeNodeCache.asMap().isEmpty()) {
Map<InstanceIdentifier<OvsdbBridgeAugmentation>, OvsdbBridgeAugmentation> nodes =
NodeId nodeId = new NodeId(new Uri(nodeString));
NodeKey nodeKey = new NodeKey(nodeId);
InstanceIdentifier<Node> bridgeIid = InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class,new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
- .child(Node.class,nodeKey)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, nodeKey)
.build();
return bridgeIid
@Override
public void execute(ReadWriteTransaction transaction) {
- for (OpenVSwitch openVSwitch : updatedOpenVSwitchRows.values()) {
- InstanceIdentifier<Node> ovsdbNodeIid =
- SouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance().getNodeId());
- deleteManagers(transaction, managerEntriesToRemove(ovsdbNodeIid,openVSwitch));
+ for (var openVSwitch : updatedOpenVSwitchRows.values()) {
+ deleteManagers(transaction, managerEntriesToRemove(
+ SouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance().getNodeId()), openVSwitch));
}
}
@VisibleForTesting
void deleteManagers(ReadWriteTransaction transaction,
List<InstanceIdentifier<ManagerEntry>> managerEntryIids) {
- for (InstanceIdentifier<ManagerEntry> managerEntryIid: managerEntryIids) {
+ for (var managerEntryIid : managerEntryIids) {
transaction.delete(LogicalDatastoreType.OPERATIONAL, managerEntryIid);
}
}
return result;
}
- private boolean checkIfManagerPresentInUpdatedManagersList(Manager removedManager) {
+ @VisibleForTesting
+ boolean checkIfManagerPresentInUpdatedManagersList(Manager removedManager) {
for (Map.Entry<UUID, Manager> updatedManager : updatedManagerRows.entrySet()) {
if (updatedManager.getValue().getTargetColumn().getData()
.equals(removedManager.getTargetColumn().getData())) {
}
return false;
}
-
}
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class TransactionInvokerImpl implements TransactionInvoker,TransactionChainListener, Runnable,
- AutoCloseable {
+public final class TransactionInvokerImpl implements TransactionInvoker, Runnable, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(TransactionInvokerImpl.class);
private static final int QUEUE_SIZE = 10000;
public TransactionInvokerImpl(final DataBroker db) {
this.db = db;
- this.chain = db.createTransactionChain(this);
+ chain = db.createTransactionChain();
ThreadFactory threadFact = new ThreadFactoryBuilder().setNameFormat("transaction-invoker-impl-%d").build();
executor = Executors.newSingleThreadExecutor(threadFact);
executor.execute(this);
@VisibleForTesting
TransactionInvokerImpl(final DataBroker db, final ExecutorService executor) {
this.db = db;
- this.chain = db.createTransactionChain(this);
this.executor = executor;
+ this.chain = db.createTransactionChain();
}
@VisibleForTesting
}
}
- @Override
- public void onTransactionChainFailed(final TransactionChain chainArg,
- final Transaction transaction, final Throwable cause) {
- LOG.error("Failed to write operational topology", cause);
- offerFailedTransaction(transaction);
- }
-
- @Override
- public void onTransactionChainSuccessful(final TransactionChain chainArg) {
- // NO OP
- }
-
@Override
public void run() {
while (runTask.get()) {
@Override
public void onFailure(final Throwable throwable) {
+ LOG.error("Failed to write operational topology", throwable);
+ offerFailedTransaction(transaction);
command.onFailure(throwable);
- // NOOP - handled by failure of transaction chain
}
}, MoreExecutors.directExecutor());
} catch (IllegalStateException e) {
@VisibleForTesting
synchronized void resetTransactionQueue() {
chain.close();
- chain = db.createTransactionChain(this);
+ chain = db.createTransactionChain();
pendingTransactions.clear();
failedTransactionQueue.clear();
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
+import static org.mockito.ArgumentMatchers.any;
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 static org.powermock.reflect.Whitebox.getField;
-import com.google.common.collect.ImmutableSet;
-import java.util.Collections;
+import java.util.List;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
@RunWith(MockitoJUnitRunner.class)
public class InstanceIdentifierCodecTest {
-
- private InstanceIdentifierCodec instanceIdCodec;
- private DataSchemaContextTree dataSchemaContextTree;
-
@Mock
private EffectiveModelContext context;
@Mock
@Mock
private DOMSchemaService schemaService;
+ private InstanceIdentifierCodec instanceIdCodec;
+ private DataSchemaContextTree dataSchemaContextTree;
+
@Before
public void setUp() throws IllegalAccessException {
when(context.getQName()).thenReturn(SchemaContext.NAME);
@Test
public void testInstanceIdentifierCodec() throws Exception {
InstanceIdentifierCodec codec = new InstanceIdentifierCodec(schemaService, bindingNormalizedNodeSerializer);
- verify(schemaService).registerSchemaContextListener(codec);
+ verify(schemaService).registerSchemaContextListener(any());
}
@Test
@Test
public void testModuleForPrefix() {
Module module = mock(Module.class);
- doReturn(ImmutableSet.of(module)).when(context).findModules("");
- assertEquals("Found Module", module, instanceIdCodec.moduleForPrefix(""));
- doReturn(ImmutableSet.of(module, mock(Module.class))).when(context).findModules("foo");
- assertEquals("Found Module", module, instanceIdCodec.moduleForPrefix("foo"));
-
- when(context.findModules("bar")).thenReturn(Collections.emptySet());
+ QNameModule mod = QNameModule.create(XMLNamespace.of("test"));
+ doReturn(List.of(module)).when(context).findModules("");
+ doReturn(mod).when(module).getQNameModule();
+ assertEquals(mod, instanceIdCodec.moduleForPrefix(""));
+ doReturn(List.of(module, mock(Module.class))).when(context).findModules("foo");
+ assertEquals(mod, instanceIdCodec.moduleForPrefix("foo"));
+
+ when(context.findModules("bar")).thenReturn(List.of());
assertNull(instanceIdCodec.moduleForPrefix("bar"));
}
when(module.getName()).thenReturn(prefix);
XMLNamespace namespace = XMLNamespace.of("foo");
- when(context.findModules(namespace)).thenReturn(Collections.emptySet());
+ when(context.findModules(namespace)).thenReturn(List.of());
assertNull(instanceIdCodec.prefixForNamespace(namespace));
- doReturn(ImmutableSet.of(module)).when(context).findModules(namespace);
+ doReturn(List.of(module)).when(context).findModules(namespace);
assertEquals("Found prefix", prefix, instanceIdCodec.prefixForNamespace(namespace));
- doReturn(ImmutableSet.of(module, mock(Module.class))).when(context).findModules(namespace);
+ doReturn(List.of(module, mock(Module.class))).when(context).findModules(namespace);
assertEquals("Found prefix", prefix, instanceIdCodec.prefixForNamespace(namespace));
}
import org.opendaylight.ovsdb.southbound.ovsdb.transact.TransactInvoker;
import org.opendaylight.ovsdb.southbound.transactions.md.TransactionInvoker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
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;
+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.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Mock private TransactionInvoker txInvoker;
@Mock private MonitorCallBack callback;
@Mock private ConnectionInfo key;
- @Mock private InstanceIdentifier<Node> instanceIdentifier;
- private Map<DatabaseSchema,TransactInvoker> transactInvokers;
+
+ private final InstanceIdentifier<Node> instanceIdentifier = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode")));
+ private Map<DatabaseSchema, TransactInvoker> transactInvokers;
@Before
public void setUp() throws Exception {
* 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.ovsdb.southbound;
import static org.junit.Assert.assertEquals;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import java.net.InetAddress;
-import java.util.Collections;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.Entity;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChangeState;
+import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
import org.opendaylight.ovsdb.lib.OvsdbClient;
import org.opendaylight.ovsdb.lib.OvsdbConnection;
import org.opendaylight.ovsdb.lib.OvsdbConnectionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAttributes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+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;
+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.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.powermock.api.mockito.PowerMockito;
@RunWith(PowerMockRunner.class)
@PrepareForTest({
- SouthboundMapper.class, OvsdbConnectionManager.class, OvsdbConnectionService.class, InstanceIdentifier.class,
- SouthboundUtil.class, Optional.class
+ SouthboundMapper.class, OvsdbConnectionManager.class, OvsdbConnectionService.class, SouthboundUtil.class,
+ Optional.class
})
public class OvsdbConnectionManagerTest {
@Mock private OvsdbConnection ovsdbConnection;
@Mock private OvsdbClient externalClient;
@Mock private ReconciliationManager reconciliationManager;
- private Map<ConnectionInfo,OvsdbConnectionInstance> clients;
- private Map<ConnectionInfo,InstanceIdentifier<Node>> instanceIdentifiers;
+ private Map<ConnectionInfo, OvsdbConnectionInstance> clients;
+ private Map<ConnectionInfo, InstanceIdentifier<Node>> instanceIdentifiers;
private Map<Entity, OvsdbConnectionInstance> entityConnectionMap;
- @Mock private InstanceIdentifier<Node> iid;
+ private final InstanceIdentifier<Node> iid = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode")));
@Before
public void setUp() throws Exception {
externalClient = mock(OvsdbClient.class, Mockito.RETURNS_DEEP_STUBS);
doReturn(info).when(externalClient).getConnectionInfo();
- doReturn(Futures.immediateFuture(Collections.singletonList("Open_vSwitch"))).when(externalClient)
- .getDatabases();
+ doReturn(Futures.immediateFuture(List.of("Open_vSwitch"))).when(externalClient).getDatabases();
PowerMockito.mockStatic(SouthboundUtil.class);
when(SouthboundUtil.connectionInfoToString(any(ConnectionInfo.class))).thenReturn("192.18.120.31:8080");
doNothing().when(client).registerCallbacks(any());
//TODO: Write unit tests for EntityOwnershipService
- when(client.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
+ when(client.getInstanceIdentifier()).thenReturn(InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode"))));
field(OvsdbConnectionManager.class, "entityConnectionMap").set(ovsdbConnManager, entityConnectionMap);
suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getEntityFromConnectionInstance",
OvsdbConnectionInstance.class));
when(db.newReadOnlyTransaction()).thenReturn(tx);
when(tx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
.thenReturn(mock(FluentFuture.class));
- when(client.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
+ when(client.getInstanceIdentifier()).thenReturn(InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode"))));
ovsdbConnManager.connected(externalClient);
}
- @SuppressWarnings("unchecked")
@Test
public void testConnectedButCallBacksNotRegistered() throws Exception {
ConnectionInfo key = mock(ConnectionInfo.class);
when(SouthboundMapper.createConnectionInfo(any(OvsdbClient.class))).thenReturn(key);
suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getInstanceIdentifier", ConnectionInfo.class));
- when(ovsdbConnManager.getInstanceIdentifier(key)).thenReturn(mock(InstanceIdentifier.class));
+ when(ovsdbConnManager.getInstanceIdentifier(key)).thenReturn(InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode"))));
suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getConnectionInstance", ConnectionInfo.class));
when(ovsdbConnManager.getConnectionInstance(key)).thenReturn(null);
.thenReturn(mock(FluentFuture.class));
when(tx.exists(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
.thenReturn(mock(FluentFuture.class));
- when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
+ when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(
+ InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode"))));
ovsdbConnManager.disconnected(externalClient);
Map<ConnectionInfo, OvsdbConnectionInstance> testClients = Whitebox.getInternalState(ovsdbConnManager,
"clients");
suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getConnectionInstance", ConnectionInfo.class));
OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
when(ovsdbConnManager.getConnectionInstance(any(ConnectionInfo.class))).thenReturn(ovsdbConnectionInstance);
- when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
+ when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(
+ InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode"))));
suppress(MemberMatcher.method(OvsdbConnectionManager.class, "removeInstanceIdentifier", ConnectionInfo.class));
when(ovsdbConnManager.connectedButCallBacksNotRegistered(any(OvsdbClient.class)))
.thenReturn(ovsdbConnectionInstance);
- when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
+ when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(
+ InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode"))));
field(OvsdbConnectionManager.class, "entityConnectionMap").set(ovsdbConnManager, entityConnectionMap);
suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getEntityFromConnectionInstance",
OvsdbConnectionInstance.class));
//TODO: Write unit tests for entity ownership service related code.
suppress(MemberMatcher.method(OvsdbConnectionManager.class, "registerEntityForOwnership",
OvsdbConnectionInstance.class));
- assertEquals("ERROR", client, ovsdbConnManager.connect(PowerMockito.mock(InstanceIdentifier.class), ovsdbNode));
+ assertEquals("ERROR", client, ovsdbConnManager.connect(InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode"))), ovsdbNode));
}
@Test
field(OvsdbConnectionManager.class, "entityConnectionMap").set(ovsdbConnManager, entityConnectionMap);
doNothing().when(ovsdbConnManager).putConnectionInstance(any(ConnectionInfo.class),
any(OvsdbConnectionInstance.class));
- EntityOwnershipChange ownershipChange = new EntityOwnershipChange(entity,
- EntityOwnershipChangeState.from(true, false, false));
- Whitebox.invokeMethod(ovsdbConnManager, "handleOwnershipChanged", ownershipChange);
+ ovsdbConnManager.handleOwnershipChanged(entity, EntityOwnershipStateChange.from(true, false, false));
verify(ovsdbConnManager).putConnectionInstance(key, ovsdbConnInstance);
}
}
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.eos.binding.api.Entity;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListener;
-import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListenerRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChangeState;
import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
+import org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange;
import org.opendaylight.ovsdb.lib.OvsdbConnection;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
public void setUp() throws CandidateAlreadyRegisteredException {
entityOwnershipService = mock(EntityOwnershipService.class);
when(entityOwnershipService.registerListener(anyString(), any(EntityOwnershipListener.class))).thenReturn(
- mock(EntityOwnershipListenerRegistration.class));
- when(entityOwnershipService.registerCandidate(any(Entity.class))).thenReturn(mock(
- EntityOwnershipCandidateRegistration.class));
+ mock(Registration.class));
+ when(entityOwnershipService.registerCandidate(any(Entity.class))).thenReturn(mock(Registration.class));
diagStatusService = Mockito.mock(DiagStatusService.class);
when(diagStatusService.register(any())).thenReturn(Mockito.mock(ServiceRegistration.class));
topologyIid).get().isPresent());
// Become owner
- southboundProvider.handleOwnershipChange(new EntityOwnershipChange(entity,
- EntityOwnershipChangeState.from(false, true, true)));
+ southboundProvider.handleOwnershipChange(EntityOwnershipStateChange.from(false, true, true));
// Up to 3 seconds for DTCL to settle
final Stopwatch sw = Stopwatch.createStarted();
topologyIid).get().isPresent());
// Verify idempotency
- southboundProvider.handleOwnershipChange(new EntityOwnershipChange(entity,
- EntityOwnershipChangeState.from(false, true, true)));
+ southboundProvider.handleOwnershipChange(EntityOwnershipStateChange.from(false, true, true));
// The OVSDB topology must be present in both trees
assertTrue(getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION,
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+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;
+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.Node;
-import org.opendaylight.yangtools.yang.binding.DataObject;
+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;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
when(db.newReadOnlyTransaction()).thenReturn(transaction);
when(mn.getManagedBy()).thenReturn(ref);
when(ref.getValue()).thenAnswer(
- (Answer<InstanceIdentifier<Node>>) invocation -> (InstanceIdentifier<Node>) mock(
- InstanceIdentifier.class));
+ (Answer<InstanceIdentifier<Node>>) invocation -> InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode"))));
FluentFuture<Optional<Node>> nf = mock(FluentFuture.class);
when(transaction.read(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class))).thenReturn(nf);
doNothing().when(transaction).close();
SouthboundUtil.getManagingNode(db, mn));
}
- @SuppressWarnings("unchecked")
@Test
public void testReadNode() throws Exception {
- Optional<DataObject> node = Optional.of(mock(DataObject.class));
+ final var node = Optional.of(mock(Node.class));
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
- InstanceIdentifier<DataObject> connectionIid = mock(InstanceIdentifier.class);
- FluentFuture<Optional<DataObject>> value = mock(FluentFuture.class);
+ InstanceIdentifier<Node> connectionIid = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode")));
+ FluentFuture<Optional<Node>> value = FluentFutures.immediateFluentFuture(node);
when(transaction.read(LogicalDatastoreType.OPERATIONAL, connectionIid)).thenReturn(value);
- when(value.get()).thenReturn(node);
assertEquals("Incorrect Optional object received", node, SouthboundUtil.readNode(transaction, connectionIid));
}
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.powermock.reflect.Whitebox;
@RunWith(MockitoJUnitRunner.class)
public class DataChangesManagedByOvsdbNodeEventTest {
+ private final InstanceIdentifier<?> iid = InstanceIdentifier.create(NetworkTopology.class);
- @Mock private InstanceIdentifier<?> iid;
@Mock private DataBroker db;
@Mock private DataChangeEvent event;
private Set<InstanceIdentifier<?>> removedPaths;
* 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.ovsdb.southbound.ovsdb.transact;
import static org.mockito.ArgumentMatchers.any;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIdsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+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.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+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.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.api.support.membermodification.MemberMatcher;
import org.powermock.modules.junit4.PowerMockRunner;
@RunWith(PowerMockRunner.class)
-@PrepareForTest({TransactUtils.class, OvsdbNodeUpdateCommand.class, InstanceIdentifier.class, Operations.class})
+@PrepareForTest({TransactUtils.class, OvsdbNodeUpdateCommand.class, Operations.class})
public class OvsdbNodeUpdateCommandTest {
-
private static final String EXTERNAL_ID_KEY = "external id key";
private static final String EXTERNAL_ID_VALUE = "external id value";
private static final String OTHER_CONFIG_KEY = "other config key";
@Test
public void testExecute() throws Exception {
Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> updated = new HashMap<>();
- InstanceIdentifier<OvsdbNodeAugmentation> iid = mock(InstanceIdentifier.class);
+ InstanceIdentifier<OvsdbNodeAugmentation> iid = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")))
+ .augmentation(OvsdbNodeAugmentation.class);
OvsdbNodeAugmentation ovsdbNode = mock(OvsdbNodeAugmentation.class);
updated.put(iid, ovsdbNode);
PowerMockito.mockStatic(TransactUtils.class);
import org.opendaylight.ovsdb.schema.openvswitch.Port;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+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.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+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.Node;
+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.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.powermock.api.mockito.PowerMockito;
when(transaction.add(any(Operation.class))).thenReturn(transaction);
String interfaceName = INTERFACE_NAME;
- InstanceIdentifier<OvsdbTerminationPointAugmentation> iid = mock(InstanceIdentifier.class);
+ InstanceIdentifier<OvsdbTerminationPointAugmentation> iid = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")))
+ .child(TerminationPoint.class, new TerminationPointKey(new TpId("testTp")))
+ .augmentation(OvsdbTerminationPointAugmentation.class);
TerminationPointCreateCommand.stampInstanceIdentifier(transaction, iid, interfaceName,
mock(InstanceIdentifierCodec.class));
verify(port).setName(anyString());
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+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.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+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.Node;
+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.yang.binding.InstanceIdentifier;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.api.support.membermodification.MemberMatcher;
@RunWith(PowerMockRunner.class)
@PrepareForTest({
TerminationPointUpdateCommand.class, TransactUtils.class, VlanMode.class, TerminationPointCreateCommand.class,
- InstanceIdentifier.class, Operations.class
+ Operations.class
})
public class TerminationPointUpdateCommandTest {
public void testExecute() {
Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation> created
= new HashMap<>();
- created.put(mock(InstanceIdentifier.class), mock(OvsdbTerminationPointAugmentation.class));
+ created.put(InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")))
+ .child(TerminationPoint.class, new TerminationPointKey(new TpId("testTp")))
+ .augmentation(OvsdbTerminationPointAugmentation.class), mock(OvsdbTerminationPointAugmentation.class));
PowerMockito.mockStatic(TransactUtils.class);
PowerMockito.when(TransactUtils.extractCreated(any(DataChangeEvent.class),
eq(OvsdbTerminationPointAugmentation.class))).thenReturn(created);
any(BridgeOperationalState.class), any(InstanceIdentifier.class),
any(OvsdbTerminationPointAugmentation.class), any(InstanceIdentifierCodec.class));
- Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation> updated
- = new HashMap<>();
- updated.put(mock(InstanceIdentifier.class), mock(OvsdbTerminationPointAugmentation.class));
+ Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation> updated =
+ new HashMap<>();
+ updated.put(InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")))
+ .child(TerminationPoint.class, new TerminationPointKey(new TpId("testTp2")))
+ .augmentation(OvsdbTerminationPointAugmentation.class), mock(OvsdbTerminationPointAugmentation.class));
PowerMockito.when(TransactUtils.extractUpdated(any(DataChangeEvent.class),
eq(OvsdbTerminationPointAugmentation.class))).thenReturn(updated);
when(op.update(any(Port.class))).thenReturn(update);
when(extraPort.getNameColumn()).thenReturn(column);
- InstanceIdentifier<OvsdbTerminationPointAugmentation> iid = mock(InstanceIdentifier.class);
- terminationPointUpdateCommand.updateTerminationPoint(transaction, state, iid, terminationPoint,
+ terminationPointUpdateCommand.updateTerminationPoint(transaction, state,
+ InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")))
+ .child(TerminationPoint.class, new TerminationPointKey(new TpId("testTp")))
+ .augmentation(OvsdbTerminationPointAugmentation.class), terminationPoint,
mock(InstanceIdentifierCodec.class));
verify(transaction, times(1)).add(any(Operation.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.ovsdb.southbound.ovsdb.transact;
import static org.junit.Assert.assertEquals;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.powermock.api.mockito.PowerMockito;
assertEquals(map, TransactUtils.extractUpdated(changes, klazz));
}
- @SuppressWarnings("unchecked")
@Test
public void testExtractCreatedOrUpdated() {
Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
PowerMockito.doReturn(result).when(TransactUtils.class);
- TransactUtils.extractUpdated(any(DataChangeEvent.class), eq(DataObject.class));
+ TransactUtils.extractUpdated(any(DataChangeEvent.class), eq(NetworkTopology.class));
- Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
- InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
+ Map<InstanceIdentifier<NetworkTopology>, NetworkTopology> map = new HashMap<>();
+ InstanceIdentifier<NetworkTopology> iid = InstanceIdentifier.create(NetworkTopology.class);
- DataObject db = mock(DataObject.class);
+ NetworkTopology db = mock(NetworkTopology.class);
map.put(iid, db);
PowerMockito.doReturn(map).when(TransactUtils.class);
- TransactUtils.extractCreated(any(DataChangeEvent.class), eq(DataObject.class));
+ TransactUtils.extractCreated(any(DataChangeEvent.class), eq(NetworkTopology.class));
- Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
+ Map<InstanceIdentifier<NetworkTopology>, NetworkTopology> testResult = new HashMap<>();
testResult.put(iid, db);
- Class<DataObject> klazz = DataObject.class;
DataChangeEvent changes = mock(DataChangeEvent.class);
- assertEquals(testResult, TransactUtils.extractCreatedOrUpdated(changes, klazz));
+ assertEquals(testResult, TransactUtils.extractCreatedOrUpdated(changes, NetworkTopology.class));
}
@Test
- @SuppressWarnings("unchecked")
public void testExtractCreatedOrUpdatedOrRemoved() {
- Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
+ Map<InstanceIdentifier<NetworkTopology>, NetworkTopology> result = new HashMap<>();
PowerMockito.doReturn(result).when(TransactUtils.class);
- TransactUtils.extractCreatedOrUpdated(any(DataChangeEvent.class), eq(DataObject.class));
+ TransactUtils.extractCreatedOrUpdated(any(DataChangeEvent.class), eq(NetworkTopology.class));
- Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
- InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
- DataObject db = mock(DataObject.class);
+ Map<InstanceIdentifier<NetworkTopology>, NetworkTopology> map = new HashMap<>();
+ InstanceIdentifier<NetworkTopology> iid = InstanceIdentifier.create(NetworkTopology.class);
+ NetworkTopology db = mock(NetworkTopology.class);
map.put(iid, db);
PowerMockito.doReturn(map).when(TransactUtils.class);
- TransactUtils.extractRemovedObjects(any(DataChangeEvent.class), eq(DataObject.class));
+ TransactUtils.extractRemovedObjects(any(DataChangeEvent.class), eq(NetworkTopology.class));
- Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
+ Map<InstanceIdentifier<NetworkTopology>, NetworkTopology> testResult = new HashMap<>();
testResult.put(iid, db);
- Class<DataObject> klazz = DataObject.class;
DataChangeEvent changes = mock(DataChangeEvent.class);
- assertEquals(testResult, TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, klazz));
+ assertEquals(testResult, TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, NetworkTopology.class));
}
@SuppressWarnings("unchecked")
@Test
public void testExtractOriginal() {
DataChangeEvent changes = mock(DataChangeEvent.class);
- Class<DataObject> klazz = DataObject.class;
Map<InstanceIdentifier<?>, DataObject> map = new HashMap<>();
when(changes.getOriginalData()).thenReturn(map);
- when(TransactUtils.extract(any(Map.class),eq(DataObject.class))).thenReturn(new HashMap<>());
+ when(TransactUtils.extract(any(Map.class), eq(DataObject.class))).thenReturn(new HashMap<>());
//test extractOriginal()
- assertEquals(map, TransactUtils.extractCreated(changes, klazz));
+ assertEquals(map, TransactUtils.extractCreated(changes, DataObject.class));
}
@Test
public void testExtractRemoved() {
DataChangeEvent changes = mock(DataChangeEvent.class);
- Class<DataObject> klazz = DataObject.class;
- assertEquals(HashSet.class, TransactUtils.extractRemoved(changes, klazz).getClass());
+ assertEquals(HashSet.class, TransactUtils.extractRemoved(changes, DataObject.class).getClass());
}
@Test
@Test
public void testStampInstanceIdentifier() {
TransactionBuilder transaction = mock(TransactionBuilder.class);
- InstanceIdentifier<?> iid = mock(InstanceIdentifier.class);
+ InstanceIdentifier<?> iid = InstanceIdentifier.create(NetworkTopology.class);
TableSchema<GenericTableSchema> tableSchema = mock(TableSchema.class);
- ColumnSchema<GenericTableSchema, Map<String,String>> columnSchema = mock(ColumnSchema.class);
+ ColumnSchema<GenericTableSchema, Map<String, String>> columnSchema = mock(ColumnSchema.class);
InstanceIdentifierCodec instanceIdentifierCodec = mock(InstanceIdentifierCodec.class);
PowerMockito.doReturn(mock(Mutate.class)).when(TransactUtils.class);
verify(transaction).add(any(Operation.class));
}
- @SuppressWarnings({ "unchecked" })
+ @SuppressWarnings("unchecked")
@Test
public void testStampInstanceIdentifierMutation() throws Exception {
InstanceIdentifierCodec instanceIdentifierCodec = Mockito.mock(InstanceIdentifierCodec.class);
when(mutate.getMutations()).thenReturn(listMutations);
doNothing().when(mutate).setMutations(any(List.class));
- InstanceIdentifier<?> iid = mock(InstanceIdentifier.class);
+ InstanceIdentifier<?> iid = InstanceIdentifier.create(NetworkTopology.class);
TransactionBuilder transaction = mock(TransactionBuilder.class);
TableSchema<GenericTableSchema> tableSchema = mock(TableSchema.class);
assertEquals(mutate, TransactUtils.stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema,
public class BridgeConfigReconciliationTaskTest {
private static final String BR_INT = "br-int";
private static final String NODE_ID = "ovsdb://uuid/6ff3d0cf-4102-429d-b41c-f8027a0fd7f4";
- private BridgeConfigReconciliationTask configurationReconciliationTask;
@Mock private OvsdbConnectionManager ovsdbConnectionManager;
@Mock private OvsdbConnectionInstance ovsdbConnectionInstance;
@Mock private DataBroker db;
@Mock private ReconciliationManager reconciliationManager;
@Mock private Topology topology;
- @Mock private InstanceIdentifier<Node> iid;
@Mock private SouthboundProvider provider;
+ private BridgeConfigReconciliationTask configurationReconciliationTask;
+ private InstanceIdentifier<Node> iid;
+
@Before
public void setUp() throws Exception {
NodeKey nodeKey = new NodeKey(new NodeId(new Uri(NODE_ID)));
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
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.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+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.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.api.support.membermodification.MemberMatcher;
@RunWith(PowerMockRunner.class)
@PrepareForTest({
- TyperUtils.class, OvsdbBridgeUpdateCommand.class, SouthboundUtil.class, InstanceIdentifier.class,
- SouthboundMapper.class, NetworkInterface.class
+ TyperUtils.class, OvsdbBridgeUpdateCommand.class, SouthboundUtil.class, SouthboundMapper.class,
+ NetworkInterface.class
})
public class OvsdbBridgeUpdateCommandTest {
private final Map<UUID,Bridge> updatedBridgeRows = new HashMap<>();
OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
- InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
+ InstanceIdentifier<Node> connectionIId = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")));
when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(connectionIId);
Optional<Node> connection = Optional.of(mock(Node.class));
PowerMockito.mockStatic(SouthboundUtil.class);
Bridge.class));
Bridge bridge = mock(Bridge.class);
- InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
+ InstanceIdentifier<Node> connectionIId = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")));
Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "updateBridge", transaction, bridge, connectionIId);
verify(ovsdbBridgeUpdateCommand, times(3)).deleteEntries(any(ReadWriteTransaction.class), eq(null));
}
- @SuppressWarnings("unchecked")
@Test
public void testDeleteEntries() throws Exception {
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
- List<InstanceIdentifier<DataObject>> entryIids = new ArrayList<>();
- InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
- entryIids.add(iid);
doNothing().when(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "deleteEntries", transaction, entryIids);
+ ovsdbBridgeUpdateCommand.deleteEntries(transaction, List.of(InstanceIdentifier.create(NetworkTopology.class)));
verify(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
}
//test bridgeOtherConfigsToRemove()
when(oldBridge.getOtherConfigColumn()).thenReturn(column);
when(bridge.getOtherConfigColumn()).thenReturn(column);
- InstanceIdentifier<Node> bridgeIid = PowerMockito.mock(InstanceIdentifier.class);
+ InstanceIdentifier<Node> bridgeIid = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")));
List<InstanceIdentifier<BridgeOtherConfigs>> resultBridgeOtherConfigs = Whitebox
.invokeMethod(ovsdbBridgeUpdateCommand, "bridgeOtherConfigsToRemove", bridgeIid, bridge);
assertEquals(ArrayList.class, resultBridgeOtherConfigs.getClass());
PowerMockito.whenNew(OvsdbNodeAugmentationBuilder.class).withNoArguments()
.thenReturn(ovsdbConnectionAugmentationBuilder);
PowerMockito.mockStatic(SouthboundMapper.class);
- InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
+ InstanceIdentifier<Node> bridgeIid = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")));
when(SouthboundMapper.createInstanceIdentifier(any(InstanceIdentifierCodec.class),
any(OvsdbConnectionInstance.class), any(Bridge.class)))
.thenReturn(bridgeIid);
ManagedNodeEntry managedBridge = new ManagedNodeEntryBuilder()
- .setBridgeRef(new OvsdbBridgeRef(mock(InstanceIdentifier.class)))
+ .setBridgeRef(new OvsdbBridgeRef(InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")))))
.build();
ManagedNodeEntryBuilder managedNodeEntryBuilder = mock(ManagedNodeEntryBuilder.class);
assertEquals(node, Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "buildBridgeNode", bridge));
}
- @SuppressWarnings("unchecked")
@Test
public void testSetManagedByAndSetDataPathType() throws Exception {
OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
- when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
+ when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(
+ InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode"))));
PowerMockito.whenNew(OvsdbNodeRef.class).withAnyArguments().thenReturn(mock(OvsdbNodeRef.class));
when(ovsdbBridgeAugmentationBuilder.setManagedBy(any(OvsdbNodeRef.class)))
.thenReturn(ovsdbBridgeAugmentationBuilder);
OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
- when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
+ when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(
+ InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode"))));
OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
Bridge bridge = mock(Bridge.class);
when(ovsdbBridgeAugmentationBuilder.setBridgeOpenflowNodeRef(any(InstanceIdentifier.class)))
import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
import org.opendaylight.ovsdb.schema.openvswitch.Controller;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
+import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
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.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
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;
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.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.powermock.reflect.Whitebox;
@RunWith(PowerMockRunner.class)
-@PrepareForTest({
- OvsdbControllerUpdateCommand.class, SouthboundMapper.class, SouthboundUtil.class, InstanceIdentifier.class
-})
+@PrepareForTest({ OvsdbControllerUpdateCommand.class, SouthboundMapper.class, SouthboundUtil.class })
public class OvsdbControllerUpdateCommandTest {
private static final String BRIDGE_NAME = "br-int";
private static final String NODE_ID = "OF|00:00:00:0c:29:70:45:9b";
// suppress call to getControllerEntryIid()
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
Map<UUID, Controller> updatedControllerRows = new HashMap<>();
- doReturn(mock(InstanceIdentifier.class)).when(ovsdbControllerUpdateCommand).getControllerEntryIid(
- any(ControllerEntry.class), any(String.class));
+ doReturn(InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode")))
+ .augmentation(OvsdbBridgeAugmentation.class)
+ .child(ControllerEntry.class, new ControllerEntryKey(new Uri("testEntry"))))
+ .when(ovsdbControllerUpdateCommand).getControllerEntryIid(any(ControllerEntry.class), any(String.class));
doNothing().when(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
any(ControllerEntry.class));
Whitebox.invokeMethod(ovsdbControllerUpdateCommand, "updateController", transaction, updatedControllerRows,
verify(bridge).getNameColumn();
}
- @SuppressWarnings("unchecked")
@Test
public void testUpdateController2() throws Exception {
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
Map<UUID, Controller> updatedControllerRows = new HashMap<>();
Map<InstanceIdentifier<Node>, Node> bridgeNodes = new HashMap<>();
Node node = mock(Node.class);
- InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
+ InstanceIdentifier<Node> bridgeIid = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode")));
bridgeNodes.put(bridgeIid, node);
PowerMockito.doReturn(bridgeNodes).when(ovsdbControllerUpdateCommand, "getBridgeNodes",
any(ReadWriteTransaction.class));
any(ReadWriteTransaction.class));
}
- @SuppressWarnings("unchecked")
@Test
public void testGetBridgeNodes() throws Exception {
OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
when(ovsdbControllerUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
- InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
+ InstanceIdentifier<Node> connectionIId = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testConnection")));
when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(connectionIId);
PowerMockito.mockStatic(SouthboundUtil.class);
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
when(node.augmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNodeAugmentation);
- InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
+ InstanceIdentifier<Node> bridgeIid = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testBridge")));
ManagedNodeEntry managedNodeEntry = new ManagedNodeEntryBuilder()
.setBridgeRef(new OvsdbBridgeRef(bridgeIid))
.build();
* 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.ovsdb.southbound.transactions.md;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeOtherConfigs;
+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.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryKey;
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.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
-
-@PrepareForTest({SouthboundMapper.class, OvsdbManagersRemovedCommand.class})
+@PrepareForTest(OvsdbManagersRemovedCommand.class)
@RunWith(PowerMockRunner.class)
public class OvsdbManagersRemovedCommandTest {
-
private static final String TARGET_COLUMN_DATA = "Target Column Data";
+
private OvsdbManagersRemovedCommand ovsdbManagersRemovedCommand;
private Map<UUID, OpenVSwitch> updatedOpenVSwitchRows;
private Map<UUID, OpenVSwitch> oldOpenVSwitchRows;
updatedOpenVSwitchRows.put(uuid, openVSwitch);
MemberModifier.field(OvsdbManagersRemovedCommand.class, "updatedOpenVSwitchRows")
.set(ovsdbManagersRemovedCommand, updatedOpenVSwitchRows);
- PowerMockito.mockStatic(SouthboundMapper.class);
OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
when(ovsdbManagersRemovedCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
when(ovsdbConnectionInstance.getNodeId()).thenReturn(mock(NodeId.class));
- when(SouthboundMapper.createInstanceIdentifier(any(NodeId.class))).thenReturn(mock(InstanceIdentifier.class));
doNothing().when(ovsdbManagersRemovedCommand).deleteManagers(any(ReadWriteTransaction.class), any(List.class));
doReturn(mock(List.class)).when(ovsdbManagersRemovedCommand).managerEntriesToRemove(
any(OpenVSwitch.class));
}
- @SuppressWarnings("unchecked")
@Test
public void testDeleteManagers() throws Exception {
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
List<InstanceIdentifier<ManagerEntry>> managerEntryIids = new ArrayList<>();
- managerEntryIids.add(mock(InstanceIdentifier.class));
+ managerEntryIids.add(SouthboundMapper.createInstanceIdentifier(new NodeId("test"))
+ .augmentation(OvsdbNodeAugmentation.class)
+ .child(ManagerEntry.class, new ManagerEntryKey(new Uri("testUri"))));
doNothing().when(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- Whitebox.invokeMethod(ovsdbManagersRemovedCommand, "deleteManagers", transaction, managerEntryIids);
+ ovsdbManagersRemovedCommand.deleteManagers(transaction, managerEntryIids);
verify(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
}
- @SuppressWarnings("unchecked")
@Test
public void testManagerEntriesToRemove() throws Exception {
OpenVSwitch openVSwitch = mock(OpenVSwitch.class);
when(openVSwitch.getUuid()).thenReturn(uuid);
MemberModifier.field(OvsdbManagersRemovedCommand.class, "oldOpenVSwitchRows").set(ovsdbManagersRemovedCommand,
oldOpenVSwitchRows);
+ @SuppressWarnings("unchecked")
Column<GenericTableSchema, Set<UUID>> column = mock(Column.class);
Set<UUID> set = new HashSet<>();
UUID controllerUuid = mock(UUID.class);
when(oldOvsdbNode.getManagerOptionsColumn()).thenReturn(column);
when(column.getData()).thenReturn(set);
when(openVSwitch.getManagerOptionsColumn()).thenReturn(column);
- InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
- List<InstanceIdentifier<BridgeOtherConfigs>> resultManagerEntries = Whitebox
- .invokeMethod(ovsdbManagersRemovedCommand, "managerEntriesToRemove", bridgeIid, openVSwitch);
+ InstanceIdentifier<Node> bridgeIid = SouthboundMapper.createInstanceIdentifier(new NodeId("test"));
+
+ List<InstanceIdentifier<ManagerEntry>> resultManagerEntries =
+ ovsdbManagersRemovedCommand.managerEntriesToRemove(bridgeIid, openVSwitch);
assertEquals(ArrayList.class, resultManagerEntries.getClass());
verify(oldOvsdbNode, times(2)).getManagerOptionsColumn();
}
- @SuppressWarnings("unchecked")
@Test
public void testCheckIfManagerPresentInUpdatedManagersList() throws Exception {
Manager updatedManager = mock(Manager.class);
updatedManagerRows.put(uuid, updatedManager);
MemberModifier.field(OvsdbManagersRemovedCommand.class, "updatedManagerRows").set(ovsdbManagersRemovedCommand,
updatedManagerRows);
+ @SuppressWarnings("unchecked")
Column<GenericTableSchema, String> column = mock(Column.class);
Manager removedManager = mock(Manager.class);
when(removedManager.getTargetColumn()).thenReturn(column);
when(updatedManager.getTargetColumn()).thenReturn(column);
when(column.getData()).thenReturn(TARGET_COLUMN_DATA);
- assertEquals(true, Whitebox.invokeMethod(ovsdbManagersRemovedCommand,
- "checkIfManagerPresentInUpdatedManagersList", removedManager));
+ assertTrue(ovsdbManagersRemovedCommand.checkIfManagerPresentInUpdatedManagersList(removedManager));
}
}
import org.opendaylight.ovsdb.schema.openvswitch.Manager;
import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
+import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
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.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+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;
+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.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.powermock.api.mockito.PowerMockito;
// mock getManagerEntryIid()
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
Map<UUID, Manager> updatedManagerRows = new HashMap<>();
- PowerMockito.doReturn(mock(InstanceIdentifier.class)).when(ovsdbManagersUpdateCommand, "getManagerEntryIid",
- any(ManagerEntry.class));
+ PowerMockito.doReturn(InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode"))).augmentation(OvsdbNodeAugmentation.class)
+ .child(ManagerEntry.class, new ManagerEntryKey(new Uri("testUri"))))
+ .when(ovsdbManagersUpdateCommand, "getManagerEntryIid", any(ManagerEntry.class));
doNothing().when(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
any(ManagerEntry.class));
Whitebox.invokeMethod(ovsdbManagersUpdateCommand, "updateManagers", transaction, updatedManagerRows,
public void testUpdateManagers1() throws Exception {
OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
when(ovsdbManagersUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
- InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
- when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(connectionIId);
+ when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(
+ InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode"))));
Optional<Node> ovsdbNode = Optional.of(mock(Node.class));
PowerMockito.mockStatic(SouthboundUtil.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.ovsdb.southbound.transactions.md;
import static org.junit.Assert.assertEquals;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
+import org.opendaylight.ovsdb.southbound.SouthboundConstants;
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.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+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;
+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.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.powermock.reflect.Whitebox;
@RunWith(MockitoJUnitRunner.class)
public class OvsdbNodeRemoveCommandTest {
-
private static final long ONE_CONNECTED_MANAGER = 1;
private static final long ONE_ACTIVE_CONNECTION_IN_PASSIVE_MODE = 1;
+
private OvsdbNodeRemoveCommand ovsdbNodeRemoveCommand;
@Before
FluentFuture<Optional<Node>> ovsdbNodeFuture = mock(FluentFuture.class);
OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
when(ovsdbNodeRemoveCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
- when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
+ when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(
+ InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testConnection"))));
when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
.thenReturn(ovsdbNodeFuture);
doReturn(true).when(ovsdbNodeRemoveCommand).checkIfOnlyConnectedManager(any(OvsdbNodeAugmentation.class));
ManagedNodeEntry managedNode = new ManagedNodeEntryBuilder()
- .setBridgeRef(new OvsdbBridgeRef(mock(InstanceIdentifier.class)))
+ .setBridgeRef(new OvsdbBridgeRef(InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testBridge")))))
.build();
when(ovsdbNodeAugmentation.getManagedNodeEntry()).thenReturn(Map.of(managedNode.key(), managedNode));
* 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.ovsdb.southbound.transactions.md;
import static org.junit.Assert.assertEquals;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+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.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+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.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.api.support.membermodification.MemberModifier;
import org.powermock.reflect.Whitebox;
@RunWith(PowerMockRunner.class)
-@PrepareForTest({TyperUtils.class, SouthboundMapper.class, InstanceIdentifier.class})
+@PrepareForTest({ TyperUtils.class, SouthboundMapper.class })
public class OvsdbPortRemoveCommandTest {
-
private static final String PORT_NAME = "port0";
+
private OvsdbPortRemoveCommand ovsdbPortRemoveCommand;
@Before
when(uuidColumn.getData()).thenReturn(uuid);
when(port.getName()).thenReturn(PORT_NAME);
- InstanceIdentifier<Node> nodeIID = mock(InstanceIdentifier.class);
+ InstanceIdentifier<Node> nodeIID = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode2")));
doReturn(mock(OvsdbConnectionInstance.class)).when(ovsdbPortRemoveCommand).getOvsdbConnectionInstance();
PowerMockito.mockStatic(SouthboundMapper.class);
doNothing().when(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
ovsdbPortRemoveCommand.execute(transaction);
- verify(transaction).delete(any(LogicalDatastoreType.class), eq(null));
+ verify(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
}
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
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.TopologyId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.powermock.reflect.Whitebox;
@RunWith(PowerMockRunner.class)
-@PrepareForTest({TyperUtils.class, OvsdbPortUpdateCommand.class, SouthboundUtil.class, SouthboundMapper.class})
+@PrepareForTest({ TyperUtils.class, OvsdbPortUpdateCommand.class, SouthboundUtil.class, SouthboundMapper.class })
public class OvsdbPortUpdateCommandTest {
-
private static final String OTHER_CONFIG_KEY = "key";
private static final String OTHER_CONFIG_VALUE = "value";
private static final String EXTERNAL_ID_KEY = "key";
OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
when(ovsdbPortUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
- InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
- when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(connectionIId);
+ when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(
+ InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode"))));
//case 1: portUpdatedRows & interfaceOldRows not null, not empty
Optional<Node> node = Optional.of(mock(Node.class));
when(tpBuilder.withKey(any(TerminationPointKey.class))).thenReturn(tpBuilder);
when(tpKey.getTpId()).thenReturn(mock(TpId.class));
when(tpBuilder.setTpId(any(TpId.class))).thenReturn(tpBuilder);
- InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
+ InstanceIdentifier<TerminationPoint> tpPath = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")))
+ .child(TerminationPoint.class, new TerminationPointKey(new TpId("testTp")));
PowerMockito.doReturn(tpPath).when(ovsdbPortUpdateCommand, "getInstanceIdentifier",
any(InstanceIdentifier.class), any(Port.class));
Node node = mock(Node.class);
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
- InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
+ InstanceIdentifier<TerminationPoint> tpPath = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")))
+ .child(TerminationPoint.class, new TerminationPointKey(new TpId("testTp")));
Whitebox.invokeMethod(ovsdbPortUpdateCommand, "buildTerminationPoint", transaction, tpPath,
tpAugmentationBuilder, node, portEntry);
any(OvsdbTerminationPointAugmentationBuilder.class));
}
- @SuppressWarnings("unchecked")
@Test
public void testReadNode() throws Exception {
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
- InstanceIdentifier<Node> nodePath = mock(InstanceIdentifier.class);
+ InstanceIdentifier<Node> nodePath = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode")));
Optional<Node> node = Optional.of(mock(Node.class));
FluentFuture<Optional<Node>> fluentFuture = mock(FluentFuture.class);
when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
assertEquals(node, Whitebox.invokeMethod(ovsdbPortUpdateCommand, "readNode", transaction, nodePath));
}
- @SuppressWarnings("unchecked")
@Test
public void testGetTerminationPointBridge1() throws Exception {
Node node = mock(Node.class);
OvsdbNodeAugmentation ovsdbNode = mock(OvsdbNodeAugmentation.class);
when(node.augmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNode);
- InstanceIdentifier<Node> iidNode = mock(InstanceIdentifier.class);
+ InstanceIdentifier<Node> iidNode = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode")));
ManagedNodeEntry managedNodeEntry = new ManagedNodeEntryBuilder()
.setBridgeRef(new OvsdbBridgeRef(iidNode))
OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
OvsdbTerminationPointAugmentationBuilder.class);
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
- InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
+ InstanceIdentifier<TerminationPoint> tpPath = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")))
+ .child(TerminationPoint.class, new TerminationPointKey(new TpId("testTp")));
Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updatePort", transaction, node, tpPath, port,
ovsdbTerminationPointBuilder);
when(column.getData()).thenReturn(map);
PowerMockito.mockStatic(SouthboundUtil.class);
- InstanceIdentifier<TerminationPoint> terminationPointIId = mock(InstanceIdentifier.class);
+ InstanceIdentifier<TerminationPoint> terminationPointIId = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("testTopo")))
+ .child(Node.class, new NodeKey(new NodeId("testNode")))
+ .child(TerminationPoint.class, new TerminationPointKey(new TpId("testTp")));
// PowerMockito
// .when((InstanceIdentifier<TerminationPoint>) SouthboundUtil.deserializeInstanceIdentifier(
// any(InstanceIdentifierCodec.class), anyString()))
// .thenReturn(terminationPointIId);
- InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
+ InstanceIdentifier<Node> bridgeIid = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(new NodeId("testNode")));
assertEquals(terminationPointIId,
Whitebox.invokeMethod(ovsdbPortUpdateCommand, "getInstanceIdentifier", bridgeIid, port));
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.List;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.concurrent.ExecutorService;
import org.mockito.junit.MockitoJUnitRunner;
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.TransactionChainListener;
@RunWith(MockitoJUnitRunner.class)
public class TransactionInvokerImplTest {
@Before
public void setUp() {
- doReturn(chain).when(db).createTransactionChain(any(TransactionChainListener.class));
+ doReturn(chain).when(db).createTransactionChain();
doNothing().when(chain).close();
}
@Test
public void testConstructor() throws InterruptedException {
try (TransactionInvokerImpl invoker = new TransactionInvokerImpl(db)) {
- verify(db).createTransactionChain(any(TransactionChainListener.class));
+ verify(db).createTransactionChain();
assertNotNull(getInternalState(invoker, "executor"));
}
}
assertTrue(inputQueue.contains(command));
}
- @Test
- public void testOnTransactionChainFailed() {
- final TransactionInvokerImpl invoker = new TransactionInvokerImpl(db, new ArrayList<>());
-
- final Transaction transaction = mock(Transaction.class);
- invoker.onTransactionChainFailed(chain, transaction, new Throwable());
-
- final Queue<?> failedQueue = getInternalState(invoker, "failedTransactionQueue");
- assertEquals(1, failedQueue.size());
- assertTrue(failedQueue.contains(transaction));
- }
@Test
public void testExtractResubmitCommands() {
// Given pending transaction order ...
ImmutableList.of(entry(tx1, cmd1), entry(tx2, cmd2), entry(tx3, cmd3)),
// .. if tx2 fails ...
- Collections.singletonList(tx2));
+ List.of(tx2));
+
+ final Queue<?> failedQueue = getInternalState(invoker, "failedTransactionQueue");
+ assertEquals(1, failedQueue.size());
+ assertTrue(failedQueue.contains(tx2));
// .. we want to replay tx2 and tx3
assertEquals(ImmutableList.of(cmd2, cmd3), invoker.extractResubmitCommands());
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<DataObject>> changes) {
+ public void onDataTreeChanged(final List<DataTreeModification<DataObject>> changes) {
for (DataTreeModification<DataObject> change: changes) {
DataObjectModification<DataObject> rootNode = change.getRootNode();
final InstanceIdentifier<DataObject> identifier = change.getRootPath().getRootIdentifier();
package org.opendaylight.ovsdb.utils.mdsal.utils;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
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.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
private final Set<InstanceIdentifier<?>> removedIids = ConcurrentHashMap.newKeySet();
private final Set<InstanceIdentifier<?>> updatedIids = ConcurrentHashMap.newKeySet();
private final List<NotifyingDataChangeListener> waitList;
- private ListenerRegistration<?> listenerRegistration;
+ private Registration listenerRegistration;
private int mdsalTimeout = MDSAL_TIMEOUT_OPERATIONAL;
private volatile InstanceIdentifier<?> iid;
private volatile LogicalDatastoreType type;
this.mask = mask;
}
- @Override
@SuppressFBWarnings("NN_NAKED_NOTIFY")
- public void onDataTreeChanged(Collection<DataTreeModification<DataObject>> changes) {
+ @Override
+ public void onDataTreeChanged(List<DataTreeModification<DataObject>> changes) {
if (!listen) {
return;
}
for (DataTreeModification<DataObject> change: changes) {
DataObjectModification<DataObject> rootNode = change.getRootNode();
- final InstanceIdentifier<DataObject> identifier = change.getRootPath().getRootIdentifier();
- switch (rootNode.getModificationType()) {
+ final InstanceIdentifier<DataObject> identifier = change.getRootPath().path();
+ switch (rootNode.modificationType()) {
case SUBTREE_MODIFIED:
case WRITE:
- if (rootNode.getDataBefore() == null) {
+ if (rootNode.dataBefore() == null) {
if ((mask & BIT_CREATE) == BIT_CREATE) {
LOG.info("{} DataTreeChanged: created {}", type, identifier);
createdIids.add(identifier);
@SuppressWarnings({ "rawtypes", "unchecked" })
public void registerDataChangeListener(DataBroker dataBroker) {
- listenerRegistration = dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(type,
+ listenerRegistration = dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.of(type,
(InstanceIdentifier)iid), this);
}
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.node.attributes.SupportingNodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.node.attributes.SupportingNodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
@RunWith(MockitoJUnitRunner.class)
public class MdsalUtilsAsyncTest extends AbstractDataBrokerTest {
final SupportingNode supportingNodeBuilder2 = new SupportingNodeBuilder().withKey(
new SupportingNodeKey(new NodeId("id2"), TOPOLOGY_TEST)).build();
- final Node data1 = new NodeBuilder(DATA).setSupportingNode(
- Collections.singletonMap(supportingNodeBuilder1.key(), supportingNodeBuilder1)).build();
- final Node data2 = new NodeBuilder(DATA).setSupportingNode(
- Collections.singletonMap(supportingNodeBuilder2.key(), supportingNodeBuilder2)).build();
+ final Node data1 = new NodeBuilder(DATA).setSupportingNode(BindingMap.of(supportingNodeBuilder1)).build();
+ final Node data2 = new NodeBuilder(DATA).setSupportingNode(BindingMap.of(supportingNodeBuilder2)).build();
mdsalUtilsAsync.put(LogicalDatastoreType.CONFIGURATION, TEST_IID, data1, operationDesc);
assertEquals(data1, readDS());
@Override
public void onSuccess(final CommitInfo result) {
- assertEquals(1, readDS().getSupportingNode().size());
+ assertEquals(1, readDS().nonnullSupportingNode().size());
}
@Override
@Override
public void onSuccess(final CommitInfo result) {
- assertEquals(2, readDS().getSupportingNode().size());
+ assertEquals(2, readDS().nonnullSupportingNode().size());
}
@Override
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>controller-artifacts</artifactId>
- <version>8.0.4</version>
+ <version>9.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-utils-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-utils" version="${project.version}">
- <feature version="[8,9)">odl-mdsal-broker</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
</feature>
</features>
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyStep;
+import org.opendaylight.yangtools.yang.binding.NodeStep;
import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
// see OVSDB-470 for background
private static boolean matchesBridgeName(ManagedNodeEntry managedNode, String bridgeName) {
InstanceIdentifier<?> bridgeIid = managedNode.getBridgeRef().getValue();
- for (PathArgument bridgeIidPathArg : bridgeIid.getPathArguments()) {
- if (bridgeIidPathArg instanceof IdentifiableItem<?, ?> identifiableItem) {
- Key<?> key = identifiableItem.getKey();
+ for (var bridgeIidPathArg : bridgeIid.getPathArguments()) {
+ if (bridgeIidPathArg instanceof KeyStep<?, ?> identifiableItem) {
+ Key<?> key = identifiableItem.key();
if (key instanceof NodeKey nodeKey) {
if (nodeKey.getNodeId().getValue().contains(bridgeName)) {
return true;
} else if (key.toString().contains(bridgeName)) {
return true;
}
- } else if (bridgeIidPathArg instanceof Item<?> item) {
- if (item.getType().getName().contains(bridgeName)) {
+ } else if (bridgeIidPathArg instanceof NodeStep<?> item) {
+ if (item.type().getName().contains(bridgeName)) {
return true;
}
} else {
Code Review / ovsdb.git / commitdiff