Migrate all code to use MD-SAL APIs from the mdsal project, not controller.
Also remove dependencies on org.opendaylight.controller where not appropriate.
JIRA: OVSDB-487
Change-Id: I5ed9e800420887bc6b453f23eb77bcd54d9c27a9
Signed-off-by: Chetan Arakere Gowdru <chetan.arakere@altencalsoftlabs.com>
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
Signed-off-by: Chetan Arakere Gowdru <chetan.arakere@altencalsoftlabs.com>
<dependencyManagement>
<dependencies>
- <dependency>
+ <!--<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>mdsal-artifacts</artifactId>
<version>1.11.0</version>
<type>pom</type>
<scope>import</scope>
- </dependency>
+ </dependency>-->
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
<version>${sonar-jacoco-listeners.version}</version>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-artifacts</artifactId>
+ <version>5.0.9</version>
+ <type>pom</type>
+ <scope>import</scope>
+ </dependency>
</dependencies>
</dependencyManagement>
<name>ODL :: ovsdb :: ${project.artifactId}</name>
<dependencies>
- <dependency>
+ <!--<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>odl-mdsal-broker</artifactId>
<version>1.11.0</version>
<type>xml</type>
<classifier>features</classifier>
- </dependency>
+ </dependency>-->
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>odl-ovsdb-hwvtepsouthbound-api</artifactId>
<artifactId>org.osgi.core</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-core-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-dom-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<groupId>org.opendaylight.serviceutils</groupId>
<artifactId>upgrade</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-spi</artifactId>
+ </dependency>
<!-- Testing Dependencies -->
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-simple</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
- <type>test-jar</type>
</dependency>
<dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-simple</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
+ <type>test-jar</type>
</dependency>
-
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-reflect</artifactId>
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+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 static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.net.ConnectException;
import java.net.InetAddress;
import java.util.Collections;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
reconciliationManager.enqueueForRetry(task);
break;
case ON_DISCONNECT: {
- ReadOnlyTransaction tx = db.newReadOnlyTransaction();
- CheckedFuture<Optional<Node>, ReadFailedException> readNodeFuture =
+ ReadTransaction tx = db.newReadOnlyTransaction();
+ FluentFuture<Optional<Node>> readNodeFuture =
tx.read(LogicalDatastoreType.CONFIGURATION, iid);
- Futures.addCallback(readNodeFuture, new FutureCallback<Optional<Node>>() {
+ readNodeFuture.addCallback(new FutureCallback<Optional<Node>>() {
@Override
public void onSuccess(final Optional<Node> node) {
if (node.isPresent()) {
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.transact.HwvtepOperationalState;
import org.opendaylight.ovsdb.hwvtepsouthbound.transact.TransactCommandAggregator;
import org.opendaylight.ovsdb.lib.OvsdbClient;
private void registerListener() {
final DataTreeIdentifier<Node> treeId =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, getWildcardPath());
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, getWildcardPath());
LOG.trace("Registering on path: {}", treeId);
registration = db.registerDataTreeChangeListener(treeId, HwvtepDataChangeListener.this);
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.utils.mdsal.utils.Scheduler;
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.hwvtep.global.attributes.ConnectionInfo;
private void registerListener() {
final DataTreeIdentifier<Node> treeId =
- new DataTreeIdentifier<Node>(LogicalDatastoreType.OPERATIONAL, getWildcardPath());
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, getWildcardPath());
registration = db.registerDataTreeChangeListener(treeId, HwvtepOperGlobalListener.this);
}
*/
package org.opendaylight.ovsdb.hwvtepsouthbound;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.Collection;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+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.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+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;
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID));
DataTreeIdentifier<Topology> treeId =
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, path);
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, path);
LOG.trace("Registering listener for path {}", treeId);
operTopologyRegistration = dataBroker.registerDataTreeChangeListener(treeId, this);
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID));
ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
- CheckedFuture<Optional<Topology>, ReadFailedException> hwvtepTp = transaction.read(type, path);
+ FluentFuture<Optional<Topology>> hwvtepTp = transaction.read(type, path);
try {
if (!hwvtepTp.get().isPresent()) {
TopologyBuilder tpb = new TopologyBuilder();
tpb.setTopologyId(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID);
transaction.put(type, path, tpb.build(), true);
- transaction.submit();
+ transaction.commit();
} else {
transaction.cancel();
}
package org.opendaylight.ovsdb.hwvtepsouthbound;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.Collection;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.opendaylight.ovsdb.utils.mdsal.utils.ControllerMdsalUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
}
public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> Optional<D> readNode(
- ReadWriteTransaction transaction, final InstanceIdentifier<D> connectionIid) {
+ DataBroker db,
+ LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> connectionIid) {
+ if (logicalDatastoreType == LogicalDatastoreType.OPERATIONAL) {
+ Node node = HwvtepOperGlobalListener.getNode((InstanceIdentifier<Node>) connectionIid);
+ if (node != null) {
+ return Optional.of((D)node);
+ } else {
+ LOG.debug("Node not available in cache. Read from datastore - {}", connectionIid);
+ }
+ }
+ try (ReadTransaction transaction = db.newReadOnlyTransaction()) {
+ return transaction.read(logicalDatastoreType, connectionIid).get();
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Read failed from datastore for Node : {}",connectionIid,e);
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> Optional<D> readNode(
+ ReadTransaction transaction,
+ LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> connectionIid) {
+ if (logicalDatastoreType == LogicalDatastoreType.OPERATIONAL) {
+ Node node = HwvtepOperGlobalListener.getNode((InstanceIdentifier<Node>) connectionIid);
+ if (node != null) {
+ return Optional.of((D)node);
+ } else {
+ LOG.debug("Node not available in cache. Read from datastore - {}", connectionIid);
+ }
+ }
+ try {
+ return transaction.read(logicalDatastoreType, connectionIid).get();
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Read failed from datastore for Node : {}",connectionIid,e);
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> Optional<D> readNode(
+ ReadWriteTransaction transaction, final InstanceIdentifier<D> connectionIid) {
return readNode(transaction, LogicalDatastoreType.OPERATIONAL, connectionIid);
}
- public static <D extends DataObject> Optional<D> readNode(ReadTransaction transaction,
+ public static <D extends DataObject> Optional<D> readNode(ReadWriteTransaction transaction,
LogicalDatastoreType logicalDatastoreType,
InstanceIdentifier<D> connectionIid) {
if (logicalDatastoreType == LogicalDatastoreType.OPERATIONAL) {
- if (HwvtepOperGlobalListener.getNode((InstanceIdentifier<Node>) connectionIid) != null) {
- return Optional.of((D)HwvtepOperGlobalListener.getNode((InstanceIdentifier<Node>)connectionIid));
+ Node node = HwvtepOperGlobalListener.getNode((InstanceIdentifier<Node>) connectionIid);
+ if (node != null) {
+ return Optional.of((D)node);
} else {
LOG.debug("Node not available in cache. Read from datastore - {}", connectionIid);
}
}
try {
- return transaction.read(logicalDatastoreType, connectionIid).checkedGet();
- } catch (ReadFailedException e) {
+ return transaction.read(logicalDatastoreType, connectionIid).get();
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Read failed from datastore for Node : {}",connectionIid,e);
throw new RuntimeException(e);
}
result = getManagingNode(db, ref);
} else {
LOG.warn("Cannot find client for PhysicalSwitch without a specified ManagedBy {}", node);
- return Optional.absent();
+ return Optional.empty();
}
if (!result.isPresent()) {
LOG.warn("Failed to find managing node for PhysicalSwitch {}", node);
} else {
LOG.warn("Hwvtep switch claims to be managed by {} but " + "that HwvtepNode does not exist",
ref.getValue());
- return Optional.absent();
+ return Optional.empty();
}
} else {
LOG.warn("Mysteriously got back a thing which is *not* a topology Node: {}", optional);
- return Optional.absent();
+ return Optional.empty();
}
} catch (RuntimeException e) {
LOG.warn("Failed to get HwvtepNode {}", ref, e);
- return Optional.absent();
+ return Optional.empty();
}
}
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yangtools.util.concurrent.SpecialExecutors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.ChildOf;
+import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.Identifier;
return childNodesCache;
}
+ @Override
+ public <H extends ChoiceIn<? super T> & DataObject, C extends ChildOf<? super H>>
+ Collection<DataObjectModification<C>> getModifiedChildren(Class<H> caseType, Class<C> childType) {
+ return null;
+ }
+
+ @Override
+ public <C extends ChildOf<? super T>> Collection<DataObjectModification<C>> getModifiedChildren(
+ Class<C> childType) {
+ return null;
+ }
+
@Override
public DataObjectModification<? extends DataObject> getModifiedChild(final InstanceIdentifier.PathArgument arg) {
return null;
return (DataObjectModification<C>) getModifiedChild(InstanceIdentifier.IdentifiableItem.of(listItem, listKey));
}
+ @Override
+ public <H extends ChoiceIn<? super T> & DataObject, C extends Identifiable<K> & ChildOf<? super H>,
+ K extends Identifier<C>> DataObjectModification<C> getModifiedChildListItem(Class<H> caseType,
+ Class<C> listItem, K listKey) {
+ return null;
+ }
+
@Override
@SuppressWarnings("unchecked")
public <C extends ChildOf<? super T>> DataObjectModification<C> getModifiedChildContainer(final Class<C> arg) {
return (DataObjectModification<C>) getModifiedChild(InstanceIdentifier.Item.of(arg));
}
+ @Override
+ public <H extends ChoiceIn<? super T> & DataObject, C extends ChildOf<? super H>> DataObjectModification<C>
+ getModifiedChildContainer(Class<H> caseType, Class<C> child) {
+ return null;
+ }
+
@Override
@SuppressWarnings("unchecked")
public <C extends Augmentation<T> & DataObject> DataObjectModification<C> getModifiedAugmentation(
*/
package org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation.configuration;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Override
public DataTreeIdentifier<T> getRootPath() {
- return new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, nodeId);
+ return DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, nodeId);
}
@Override
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
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.HwvtepGlobalAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalMcastMacs;
package org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation.configuration;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionManager;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
public HwvtepReconciliationManager(DataBroker db, HwvtepConnectionManager hcm) {
this.hcm = hcm;
- InstanceIdentifier<Node> iid = HwvtepSouthboundMapper.createInstanceIdentifier();
- DataTreeIdentifier<Node> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, iid);
+ final InstanceIdentifier<Node> iid = HwvtepSouthboundMapper.createInstanceIdentifier();
+ final DataTreeIdentifier<Node> treeId = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, iid);
LOG.trace("Registering listener for path {}", treeId);
registration = db.registerDataTreeChangeListener(treeId, HwvtepReconciliationManager.this);
}
*/
package org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation.configuration;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
-
-import com.google.common.base.Optional;
-
import java.util.ArrayList;
import java.util.Collection;
+import java.util.Optional;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionManager;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
InstanceIdentifier<Node> psNodeIid = HwvtepSouthboundMapper.createInstanceIdentifier(psNode.getNodeId());
InstanceIdentifier<Node> nodeId = (InstanceIdentifier<Node>)nodeIid;
- ReadOnlyTransaction tx = reconciliationManager.getDb().newReadOnlyTransaction();
- Node globalConfigNode = readNode(tx, CONFIGURATION, nodeId);
- Node globalOpNode = readNode(tx, OPERATIONAL, nodeId);
- Node psConfigNode = readNode(tx, CONFIGURATION, psNodeIid);
+ ReadTransaction tx = reconciliationManager.getDb().newReadOnlyTransaction();
+ Node globalConfigNode = readNode(tx, LogicalDatastoreType.CONFIGURATION, nodeId);
+ Node globalOpNode = readNode(tx, LogicalDatastoreType.OPERATIONAL, nodeId);
+ Node psConfigNode = readNode(tx, LogicalDatastoreType.CONFIGURATION, psNodeIid);
DataTreeModification<Node> change = null;
Collection<DataTreeModification<Node>> changes = new ArrayList<>();
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalPortAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalPortAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
package org.opendaylight.ovsdb.hwvtepsouthbound.transact;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.commons.lang3.tuple.Pair;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
public Optional<Node> getGlobalNode(InstanceIdentifier<?> iid) {
InstanceIdentifier<Node> nodeIid = iid.firstIdentifierOf(Node.class);
- return Optional.fromNullable(operationalNodes.get(nodeIid));
+ return Optional.ofNullable(operationalNodes.get(nodeIid));
}
public Optional<HwvtepGlobalAugmentation> getHwvtepGlobalAugmentation(InstanceIdentifier<?> iid) {
Preconditions.checkNotNull(iid);
Optional<Node> nodeOptional = getGlobalNode(iid);
if (nodeOptional.isPresent()) {
- return Optional.fromNullable(nodeOptional.get().augmentation(HwvtepGlobalAugmentation.class));
+ return Optional.ofNullable(nodeOptional.get().augmentation(HwvtepGlobalAugmentation.class));
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<PhysicalSwitchAugmentation> getPhysicalSwitchAugmentation(InstanceIdentifier<?> iid) {
Preconditions.checkNotNull(iid);
Optional<Node> nodeOptional = getGlobalNode(iid);
if (nodeOptional.isPresent()) {
- return Optional.fromNullable(nodeOptional.get().augmentation(PhysicalSwitchAugmentation.class));
+ return Optional.ofNullable(nodeOptional.get().augmentation(PhysicalSwitchAugmentation.class));
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<List<TerminationPoint>> getTerminationPointList(InstanceIdentifier<?> iid) {
Preconditions.checkNotNull(iid);
Optional<Node> nodeOptional = getGlobalNode(iid);
if (nodeOptional.isPresent() && nodeOptional.get().getTerminationPoint() != null) {
- return Optional.fromNullable(nodeOptional.get().getTerminationPoint());
+ return Optional.ofNullable(nodeOptional.get().getTerminationPoint());
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<LogicalSwitches> getLogicalSwitches(InstanceIdentifier<?> iid,
if (lswitchList != null) {
for (LogicalSwitches lswitch: lswitchList) {
if (lswitch.key().equals(logicalSwitchesKey)) {
- return Optional.fromNullable(lswitch);
+ return Optional.ofNullable(lswitch);
}
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<LogicalSwitches> getLogicalSwitches(InstanceIdentifier<LogicalSwitches> iid) {
if (tunnelList != null) {
for (Tunnels tunnel: tunnelList) {
if (tunnel.key().equals(tunnelsKey)) {
- return Optional.fromNullable(tunnel);
+ return Optional.ofNullable(tunnel);
}
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<Tunnels> getTunnels(InstanceIdentifier<Tunnels> iid) {
HwvtepPhysicalPortAugmentation hppAugmentation =
tp.augmentation(HwvtepPhysicalPortAugmentation.class);
if (hppAugmentation != null && hppAugmentation.getHwvtepNodeName().equals(hwvtepNodeName)) {
- return Optional.fromNullable(hppAugmentation);
+ return Optional.ofNullable(hppAugmentation);
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<HwvtepPhysicalLocatorAugmentation> getPhysicalLocatorAugmentation(InstanceIdentifier<?> iid,
tp.augmentation(HwvtepPhysicalLocatorAugmentation.class);
if (hppAugmentation != null && hppAugmentation.getDstIp().equals(dstIp)
&& hppAugmentation.getEncapsulationType().equals(encapType)) {
- return Optional.fromNullable(hppAugmentation);
+ return Optional.ofNullable(hppAugmentation);
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<HwvtepPhysicalLocatorAugmentation>
Optional<TerminationPoint> tp =
new ControllerMdsalUtils(db).readOptional(LogicalDatastoreType.OPERATIONAL, iid);
if (tp.isPresent()) {
- return Optional.fromNullable(tp.get().augmentation(HwvtepPhysicalLocatorAugmentation.class));
+ return Optional.ofNullable(tp.get().augmentation(HwvtepPhysicalLocatorAugmentation.class));
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<LocalMcastMacs> getLocalMcastMacs(InstanceIdentifier<?> iid, LocalMcastMacsKey key) {
if (macList != null) {
for (LocalMcastMacs mac: macList) {
if (mac.key().equals(key)) {
- return Optional.fromNullable(mac);
+ return Optional.ofNullable(mac);
}
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<RemoteMcastMacs> getRemoteMcastMacs(InstanceIdentifier<?> iid, RemoteMcastMacsKey key) {
if (macList != null) {
for (RemoteMcastMacs mac: macList) {
if (mac.key().equals(key)) {
- return Optional.fromNullable(mac);
+ return Optional.ofNullable(mac);
}
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<LocalUcastMacs> getLocalUcastMacs(InstanceIdentifier<?> iid, LocalUcastMacsKey key) {
if (macList != null) {
for (LocalUcastMacs mac: macList) {
if (mac.key().equals(key)) {
- return Optional.fromNullable(mac);
+ return Optional.ofNullable(mac);
}
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<RemoteUcastMacs> getRemoteUcastMacs(InstanceIdentifier<?> iid, RemoteUcastMacsKey key) {
if (macList != null) {
for (RemoteUcastMacs mac: macList) {
if (mac.key().equals(key)) {
- return Optional.fromNullable(mac);
+ return Optional.ofNullable(mac);
}
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<LogicalRouters> getLogicalRouters(final InstanceIdentifier<?> iid,
if (hgAugmentation != null && hgAugmentation.getLogicalRouters() != null) {
for (LogicalRouters lrouter: hgAugmentation.getLogicalRouters()) {
if (lrouter.key().equals(logicalRoutersKey)) {
- return Optional.fromNullable(lrouter);
+ return Optional.ofNullable(lrouter);
}
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<Acls> getAcls(InstanceIdentifier<Acls> iid) {
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
import org.opendaylight.ovsdb.lib.notation.UUID;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.schema.hardwarevtep.LogicalRouter;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
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.hwvtep.global.attributes.LogicalSwitches;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.lib.notation.UUID;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.opendaylight.ovsdb.lib.notation.UUID;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.schema.hardwarevtep.McastMacsLocal;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
import org.opendaylight.ovsdb.lib.notation.UUID;
import java.util.Objects;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
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.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalPort;
import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionType;
import java.util.Map.Entry;
import java.util.Objects;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
import org.opendaylight.ovsdb.lib.notation.UUID;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import static org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil.schemaMismatchLog;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
* 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.transact;
import java.util.ArrayList;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;
-
import org.apache.commons.lang3.tuple.Pair;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.slf4j.Logger;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.slf4j.Logger;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.schema.hardwarevtep.UcastMacsLocal;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.schema.hardwarevtep.UcastMacsLocal;
import java.util.Map.Entry;
import java.util.Objects;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import java.util.Map.Entry;
import java.util.Objects;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
package org.opendaylight.ovsdb.hwvtepsouthbound.transact;
-import com.google.common.base.Optional;
-
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
Class<? extends Identifiable> cls,
InstanceIdentifier<? extends DataObject> key) {
DataBroker db = opState.getConnectionInstance().getDataBroker();
- ReadOnlyTransaction tx = db.newReadOnlyTransaction();
- Optional data = HwvtepSouthboundUtil.readNode(tx, LogicalDatastoreType.CONFIGURATION, key);
- tx.close();
+ Optional data = HwvtepSouthboundUtil.readNode(db, LogicalDatastoreType.CONFIGURATION, key);
if (data.isPresent()) {
opState.getDeviceInfo().updateConfigData(cls, key, data.get());
return true;
import java.util.HashSet;
import java.util.Set;
import org.apache.commons.lang3.tuple.Pair;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import java.util.Map;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSchemaConstants;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
@Override
public void execute(ReadWriteTransaction transaction) {
- CheckedFuture<Optional<Node>, ReadFailedException> hwvtepGlobalFuture = transaction.read(
+ FluentFuture<Optional<Node>> hwvtepGlobalFuture = transaction.read(
LogicalDatastoreType.OPERATIONAL, nodeInstanceIdentifier);
try {
Optional<Node> hwvtepGlobalOptional = hwvtepGlobalFuture.get();
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import java.util.List;
import java.util.NoSuchElementException;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
-import com.google.common.base.Optional;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
import java.util.Collection;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.hwvtepsouthbound.events.PortEvent;
*/
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
updatedPhysicalSwitch));
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static Optional<InstanceIdentifier<Node>> getTerminationPointSwitch(final ReadWriteTransaction transaction,
} else {
LOG.trace("PhyscialSwitch not present for the Port {}", tpName);
}
- return Optional.absent();
+ return Optional.empty();
}
private static void setPortFaultStatus(final HwvtepPhysicalPortAugmentationBuilder tpAugmentationBuilder,
if (terminationPointIid != null) {
return Optional.of(terminationPointIid.firstIdentifierOf(Node.class));
}
- return Optional.absent();
+ return Optional.empty();
}
}
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
import java.util.Collection;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import java.util.Collection;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
-import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import com.google.common.util.concurrent.FluentFuture;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
public interface TransactionCommand {
/**
* Sets the result future of the executed/submitted transaction.
*/
- default void setTransactionResultFuture(ListenableFuture future) {
+ default void setTransactionResultFuture(FluentFuture future) {
}
- default ListenableFuture getTransactionResultFuture() {
+ default FluentFuture getTransactionResultFuture() {
return null;
}
}
*/
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.ArrayList;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import org.checkerframework.checker.lock.qual.GuardedBy;
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.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;
private final DataBroker db;
private final BlockingQueue<TransactionCommand> inputQueue = new LinkedBlockingQueue<>(QUEUE_SIZE);
- private final BlockingQueue<AsyncTransaction<?, ?>> failedTransactionQueue = new LinkedBlockingQueue<>(QUEUE_SIZE);
+ private final BlockingQueue<Transaction> failedTransactionQueue = new LinkedBlockingQueue<>(QUEUE_SIZE);
private final ExecutorService executor;
@GuardedBy("this")
@GuardedBy("this")
private final List<ReadWriteTransaction> pendingTransactions = new ArrayList<>();
- private BindingTransactionChain chain;
+ private TransactionChain chain;
//This is made volatile as it is accessed from uncaught exception handler thread also
private volatile ReadWriteTransaction transactionInFlight = null;
private Iterator<TransactionCommand> commandIterator = null;
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> txChain,
- final AsyncTransaction<?, ?> transaction, final Throwable cause) {
+ public void onTransactionChainFailed(final TransactionChain txChain,
+ final Transaction transaction, final Throwable cause) {
offerFailedTransaction(transaction);
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> txChain) {
+ public void onTransactionChainSuccessful(final TransactionChain txChain) {
// NO OP
}
transactionInFlight = transaction;
recordPendingTransaction(command, transaction);
command.execute(transaction);
- ListenableFuture<Void> ft = transaction.submit();
+ FluentFuture<?> ft = transaction.commit();
command.setTransactionResultFuture(ft);
- Futures.addCallback(ft, new FutureCallback<Void>() {
+ ft.addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final Object result) {
forgetSuccessfulTransaction(transaction);
}
}, MoreExecutors.directExecutor());
}
- private void offerFailedTransaction(final AsyncTransaction<?, ?> transaction) {
+ private void offerFailedTransaction(final Transaction transaction) {
if (!failedTransactionQueue.offer(transaction)) {
LOG.warn("failedTransactionQueue is full (size: {})", failedTransactionQueue.size());
}
private List<TransactionCommand> extractResubmitCommands() {
List<TransactionCommand> commands = new ArrayList<>();
synchronized (this) {
- AsyncTransaction<?, ?> transaction = failedTransactionQueue.poll();
+ Transaction transaction = failedTransactionQueue.poll();
if (transaction != null) {
int index = pendingTransactions.lastIndexOf(transaction);
//This logic needs to be revisited. Is it ok to resubmit these things again ?
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.After;
import org.junit.Before;
import org.mockito.ArgumentCaptor;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTest;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md.TransactionInvoker;
import org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md.TransactionInvokerImpl;
mockConnectionManager();
mockOperations();
- addNode(OPERATIONAL);
- addNode(CONFIGURATION);
+ addNode(LogicalDatastoreType.OPERATIONAL);
+ addNode(LogicalDatastoreType.CONFIGURATION);
hwvtepDataChangeListener = new HwvtepDataChangeListener(dataBroker, hwvtepConnectionManager);
}
@After
public void tearDown() throws Exception {
hwvtepDataChangeListener.close();
- deleteNode(OPERATIONAL);
- deleteNode(CONFIGURATION);
+ deleteNode(LogicalDatastoreType.OPERATIONAL);
+ deleteNode(LogicalDatastoreType.CONFIGURATION);
}
static final void setFinalStatic(final Class<?> cls, final String fieldName, final Object newValue)
nodeBuilder.addAugmentation(HwvtepGlobalAugmentation.class, builder.build());
WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
transaction.put(logicalDatastoreType, nodeIid, nodeBuilder.build(), WriteTransaction.CREATE_MISSING_PARENTS);
- transaction.submit();
+ transaction.commit();
}
void deleteNode(final LogicalDatastoreType logicalDatastoreType) {
ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
tx.delete(logicalDatastoreType, nodeIid);
- tx.submit();
+ tx.commit();
}
Node addData(final LogicalDatastoreType logicalDatastoreType, final Class<? extends DataObject> dataObject,
tx.delete(logicalDatastoreType, key);
}
}
- tx.submit();
+ tx.commit();
}
NodeBuilder prepareNode(final InstanceIdentifier<Node> iid) {
Node node = nodeBuilder.build();
WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
transaction.merge(datastoreType, id, node, WriteTransaction.CREATE_MISSING_PARENTS);
- transaction.submit();
+ transaction.commit();
return node;
}
package org.opendaylight.ovsdb.hwvtepsouthbound;
import static org.junit.Assert.assertEquals;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
import java.util.List;
import java.util.Map;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.transact.DependencyQueue;
import org.opendaylight.ovsdb.hwvtepsouthbound.transact.DependentJob;
import org.opendaylight.ovsdb.hwvtepsouthbound.transact.HwvtepOperationalState;
}
});
assertEquals(1, latch.getCount());
- addData(CONFIGURATION, LogicalSwitches.class, new String[]{"ls0", "100"});
- addData(CONFIGURATION, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, new String[]{"ls0", "100"});
+ addData(LogicalDatastoreType.CONFIGURATION, TerminationPoint.class, terminationPoints);
assertEquals(0, latch.getCount());
}
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
import com.google.common.collect.Lists;
import java.util.Iterator;
import org.mockito.ArgumentMatchers;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.transact.DependencyQueue;
import org.opendaylight.ovsdb.lib.operations.Operations;
import org.opendaylight.ovsdb.lib.schema.typed.TypedBaseTable;
@Test
public <T extends DataObject> void testLogicalSwitchAdd() throws Exception {
- addData(CONFIGURATION, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, logicalSwitches);
verifyThatLogicalSwitchCreated();
}
@Test
public <T extends DataObject> void testLogicalSwitchDelete() throws Exception {
- addData(CONFIGURATION, LogicalSwitches.class, logicalSwitches);
- addData(OPERATIONAL, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.OPERATIONAL, LogicalSwitches.class, logicalSwitches);
resetOperations();
- deleteData(CONFIGURATION, LogicalSwitches.class, logicalSwitches);
+ deleteData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, logicalSwitches);
verify(Operations.op, times(10)).delete(any());
}
@Test
public <T extends DataObject> void testUcastMacAdd() throws Exception {
- addData(CONFIGURATION, LogicalSwitches.class, logicalSwitches);
- addData(OPERATIONAL, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.OPERATIONAL, LogicalSwitches.class, logicalSwitches);
resetOperations();
- addData(CONFIGURATION, TerminationPoint.class, terminationPoints);
- addData(CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
+ addData(LogicalDatastoreType.CONFIGURATION, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
//4 ucast macs + 2 termination points
verify(Operations.op, times(4)).insert(any(UcastMacsRemote.class));
//TODO add finer grained validation
@Test
public <T extends DataObject> void testUcastMacAddWithoutConfigTep() throws Exception {
- addData(CONFIGURATION, LogicalSwitches.class, logicalSwitches);
- addData(OPERATIONAL, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.OPERATIONAL, LogicalSwitches.class, logicalSwitches);
resetOperations();
- addData(CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
//4 ucast macs + 2 termination points
verify(Operations.op, times(4)).insert(any(UcastMacsRemote.class));
//TODO add finer grained validation
@Test
public <T extends DataObject> void testUcastMacDelete() throws Exception {
- addData(CONFIGURATION, LogicalSwitches.class, logicalSwitches);
- addData(OPERATIONAL, LogicalSwitches.class, logicalSwitches);
- addData(CONFIGURATION, TerminationPoint.class, terminationPoints);
- addData(CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
- addData(OPERATIONAL, RemoteUcastMacs.class, ucastMacs);
- addData(OPERATIONAL, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.OPERATIONAL, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.CONFIGURATION, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
+ addData(LogicalDatastoreType.OPERATIONAL, RemoteUcastMacs.class, ucastMacs);
+ addData(LogicalDatastoreType.OPERATIONAL, TerminationPoint.class, terminationPoints);
resetOperations();
- deleteData(CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
+ deleteData(LogicalDatastoreType.CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
verify(Operations.op, times(4)).delete(any());
//TODO add finer grained validation
}
@Test
public <T extends DataObject> void testMcastMacAdd() throws Exception {
- addData(CONFIGURATION, LogicalSwitches.class, logicalSwitches);
- addData(OPERATIONAL, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.OPERATIONAL, LogicalSwitches.class, logicalSwitches);
resetOperations();
- addData(CONFIGURATION, TerminationPoint.class, terminationPoints);
- addData(CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
+ addData(LogicalDatastoreType.CONFIGURATION, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
//2 mcast macs + 2 locator sets + 3 termination points
verify(Operations.op, times(7)).insert(ArgumentMatchers.<McastMacsRemote>any());
}
@Test
public <T extends DataObject> void testMcastMacAddWithoutConfigTep() throws Exception {
- addData(CONFIGURATION, LogicalSwitches.class, logicalSwitches);
- addData(OPERATIONAL, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.OPERATIONAL, LogicalSwitches.class, logicalSwitches);
resetOperations();
- addData(CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
//2 mcast macs + 2 locator sets + 3 termination points
verify(Operations.op, times(7)).insert(ArgumentMatchers.<McastMacsRemote>any());
}
@Test
public <T extends DataObject> void testMcastMacDelete() throws Exception {
- addData(CONFIGURATION, LogicalSwitches.class, logicalSwitches);
- addData(OPERATIONAL, LogicalSwitches.class, logicalSwitches);
- addData(CONFIGURATION, TerminationPoint.class, terminationPoints);
- addData(CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
- addData(OPERATIONAL, TerminationPoint.class, terminationPoints);
- addData(OPERATIONAL, RemoteMcastMacs.class, mcastMacs);
+ addData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.OPERATIONAL, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.CONFIGURATION, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
+ addData(LogicalDatastoreType.OPERATIONAL, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.OPERATIONAL, RemoteMcastMacs.class, mcastMacs);
resetOperations();
- deleteData(CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
+ deleteData(LogicalDatastoreType.CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
verify(Operations.op, times(2)).delete(ArgumentMatchers.any());
}
@Test
public <T extends DataObject> void testAddMacs() throws Exception {
- addData(CONFIGURATION, LogicalSwitches.class, logicalSwitches);
- addData(OPERATIONAL, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.OPERATIONAL, LogicalSwitches.class, logicalSwitches);
resetOperations();
- addData(CONFIGURATION, TerminationPoint.class, terminationPoints);
- addData(CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
+ addData(LogicalDatastoreType.CONFIGURATION, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
verify(Operations.op, times(4)).insert(any(UcastMacsRemote.class));
- addData(OPERATIONAL, TerminationPoint.class, terminationPoints);
- addData(OPERATIONAL, RemoteUcastMacs.class, ucastMacs);
+ addData(LogicalDatastoreType.OPERATIONAL, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.OPERATIONAL, RemoteUcastMacs.class, ucastMacs);
resetOperations();
- addData(CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
//2 mcast mac + 2 locator sets ( termination point already added )
verify(Operations.op, times(4)).insert(ArgumentMatchers.<McastMacsRemote>any());
}
@Test
public <T extends DataObject> void testUpdateMacs() throws Exception {
- addData(CONFIGURATION, LogicalSwitches.class, logicalSwitches);
- addData(OPERATIONAL, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.OPERATIONAL, LogicalSwitches.class, logicalSwitches);
resetOperations();
- addData(CONFIGURATION, TerminationPoint.class, terminationPoints);
- addData(CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
+ addData(LogicalDatastoreType.CONFIGURATION, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
verify(Operations.op, times(4)).insert(any(UcastMacsRemote.class));
- addData(OPERATIONAL, TerminationPoint.class, terminationPoints);
- addData(OPERATIONAL, RemoteUcastMacs.class, ucastMacs);
+ addData(LogicalDatastoreType.OPERATIONAL, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.OPERATIONAL, RemoteUcastMacs.class, ucastMacs);
resetOperations();
- addData(CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
verify(Operations.op, times(4)).insert(ArgumentMatchers.<McastMacsRemote>any());
- addData(OPERATIONAL, RemoteMcastMacs.class, mcastMacs);
+ addData(LogicalDatastoreType.OPERATIONAL, RemoteMcastMacs.class, mcastMacs);
resetOperations();
- addData(CONFIGURATION, RemoteMcastMacs.class, mcastMac2);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteMcastMacs.class, mcastMac2);
verify(Operations.op, times(2)).insert(ArgumentMatchers.<McastMacsRemote>any());
verify(Operations.op, times(2)).update(ArgumentMatchers.<McastMacsRemote>any());
verify(Operations.op, times(0)).delete(ArgumentMatchers.any());
@Test
public <T extends DataObject> void testUpdateMacsWithZeroLocators() throws Exception {
- addData(CONFIGURATION, LogicalSwitches.class, logicalSwitches);
- addData(OPERATIONAL, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.OPERATIONAL, LogicalSwitches.class, logicalSwitches);
resetOperations();
- addData(CONFIGURATION, TerminationPoint.class, terminationPoints);
- addData(CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
+ addData(LogicalDatastoreType.CONFIGURATION, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
verify(Operations.op, times(4)).insert(any(UcastMacsRemote.class));
- addData(OPERATIONAL, TerminationPoint.class, terminationPoints);
- addData(OPERATIONAL, RemoteUcastMacs.class, ucastMacs);
+ addData(LogicalDatastoreType.OPERATIONAL, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.OPERATIONAL, RemoteUcastMacs.class, ucastMacs);
resetOperations();
- addData(CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
verify(Operations.op, times(4)).insert(ArgumentMatchers.<McastMacsRemote>any());
- addData(OPERATIONAL, RemoteMcastMacs.class, mcastMacs);
+ addData(LogicalDatastoreType.OPERATIONAL, RemoteMcastMacs.class, mcastMacs);
resetOperations();
- addData(CONFIGURATION, RemoteMcastMacs.class, mcastMac3WithZeroLocators);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteMcastMacs.class, mcastMac3WithZeroLocators);
verify(Operations.op, times(2)).delete(ArgumentMatchers.any());
}
@Test
public <T extends DataObject> void testBackToBackMacsUpdate() throws Exception {
- addData(CONFIGURATION, LogicalSwitches.class, logicalSwitches);
- addData(OPERATIONAL, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.CONFIGURATION, LogicalSwitches.class, logicalSwitches);
+ addData(LogicalDatastoreType.OPERATIONAL, LogicalSwitches.class, logicalSwitches);
resetOperations();
- addData(CONFIGURATION, TerminationPoint.class, terminationPoints);
- addData(CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
+ addData(LogicalDatastoreType.CONFIGURATION, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteUcastMacs.class, ucastMacs);
verify(Operations.op, times(4)).insert(any(UcastMacsRemote.class));
resetOperations();
- addData(CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteMcastMacs.class, mcastMacs);
//2 mcast mac + 2 locator sets ( termination point already added )
verify(Operations.op, times(0)).insert(ArgumentMatchers.<McastMacsRemote>any());
resetOperations();
- addData(OPERATIONAL, TerminationPoint.class, terminationPoints);
- addData(OPERATIONAL, RemoteUcastMacs.class, ucastMacs);
+ addData(LogicalDatastoreType.OPERATIONAL, TerminationPoint.class, terminationPoints);
+ addData(LogicalDatastoreType.OPERATIONAL, RemoteUcastMacs.class, ucastMacs);
connectionInstance.getDeviceInfo().onOperDataAvailable();
//2 mcast mac + 2 locator sets ( termination point already added )
verify(Operations.op, times(4)).insert(ArgumentMatchers.<McastMacsRemote>any());
resetOperations();
- addData(CONFIGURATION, RemoteMcastMacs.class, mcastMac2);
+ addData(LogicalDatastoreType.CONFIGURATION, RemoteMcastMacs.class, mcastMac2);
verify(Operations.op, times(0)).insert(ArgumentMatchers.<McastMacsRemote>any());
- addData(OPERATIONAL, RemoteMcastMacs.class, mcastMacs);
+ addData(LogicalDatastoreType.OPERATIONAL, RemoteMcastMacs.class, mcastMacs);
connectionInstance.getDeviceInfo().onOperDataAvailable();
verify(Operations.op, times(2)).insert(ArgumentMatchers.<McastMacsRemote>any());
verify(Operations.op, times(2)).update(ArgumentMatchers.<McastMacsRemote>any());
package org.opendaylight.ovsdb.hwvtepsouthbound;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.notation.UUID;
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.hwvtep.global.attributes.LogicalSwitches;
this.db = db;
this.hcm = hcm;
this.connectionInstance = connectionInstance;
- DataTreeIdentifier<Node> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, getWildcardPath());
+ DataTreeIdentifier<Node> treeId = DataTreeIdentifier
+ .create(LogicalDatastoreType.OPERATIONAL, getWildcardPath());
registration = db.registerDataTreeChangeListener(treeId, HwvtepOperationalDataChangeListener.this);
}
package org.opendaylight.ovsdb.hwvtepsouthbound;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
import java.util.concurrent.CountDownLatch;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md.TransactionCommand;
import org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md.TransactionInvokerImpl;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
private void deleteNode(InstanceIdentifier<Node> iid) {
ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
tx.delete(LogicalDatastoreType.CONFIGURATION, iid);
- tx.submit();
+ tx.commit();
}
@Test
}
@Override
- public void setTransactionResultFuture(ListenableFuture future) {
- Futures.addCallback(future, new FutureCallback<Void>() {
+ public void setTransactionResultFuture(FluentFuture future) {
+ future.addCallback(new FutureCallback<Object>() {
@Override
- public void onSuccess(Void notUsed) {
+ public void onSuccess(Object notUsed) {
ft.set(null);
}
<type>pom</type>
<scope>import</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>mdsal-artifacts</artifactId>
- <version>1.11.0</version>
- <type>pom</type>
- <scope>import</scope>
- </dependency>
</dependencies>
</dependencyManagement>
<type>xml</type>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-common-api</artifactId>
</dependency>
<dependency>
<groupId>${project.groupId}</groupId>
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.mdsal.it.base.AbstractMdsalTestBase;
+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.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.utils.hwvtepsouthbound.utils.HwvtepSouthboundUtils;
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 = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, iid);
+ final DataTreeIdentifier<Node> treeId = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, iid);
dataBroker.registerDataTreeChangeListener(treeId, OPERATIONAL_LISTENER);
<type>xml</type>
<classifier>features</classifier>
</dependency>
- <dependency>
+ <!--<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>odl-mdsal-broker</artifactId>
<version>1.11.0</version>
<type>xml</type>
<classifier>features</classifier>
- </dependency>
+ </dependency>-->
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>odl-infrautils-diagstatus</artifactId>
<dependencies>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>slf4j-simple</artifactId>
<scope>test</scope>
</dependency>
-
<dependency>
- <groupId>org.powermock</groupId>
- <artifactId>powermock-api-mockito2</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <scope>test</scope>
</dependency>
<dependency>
- <groupId>org.powermock</groupId>
- <artifactId>powermock-module-junit4</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <scope>test</scope>
+ <type>test-jar</type>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
- <scope>test</scope>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-api-mockito2</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
- <type>test-jar</type>
- <scope>test</scope>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-module-junit4</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.ovsdb</groupId>
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+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 static org.opendaylight.ovsdb.lib.operations.Operations.op;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.net.ConnectException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
return nodeIdVsConnectionInstance.get(nodePath);
}
try {
- ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
- CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture = transaction.read(
+ ReadTransaction transaction = db.newReadOnlyTransaction();
+ FluentFuture<Optional<Node>> nodeFuture = transaction.read(
LogicalDatastoreType.OPERATIONAL, nodePath);
transaction.close();
Optional<Node> optional = nodeFuture.get();
reconciliationManager.enqueueForRetry(task);
break;
case ON_DISCONNECT: {
- CheckedFuture<Optional<Node>, ReadFailedException> readNodeFuture;
- try (ReadOnlyTransaction tx = db.newReadOnlyTransaction()) {
+ FluentFuture<Optional<Node>> readNodeFuture;
+ try (ReadTransaction tx = db.newReadOnlyTransaction()) {
readNodeFuture = tx.read(LogicalDatastoreType.CONFIGURATION, iid);
}
- Futures.addCallback(readNodeFuture, new FutureCallback<Optional<Node>>() {
+ readNodeFuture.addCallback(new FutureCallback<Optional<Node>>() {
@Override
public void onSuccess(final Optional<Node> node) {
if (node.isPresent()) {
import java.util.Map;
import java.util.Map.Entry;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.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.ovsdb.lib.OvsdbClient;
import org.opendaylight.ovsdb.southbound.ovsdb.transact.BridgeOperationalState;
import org.opendaylight.ovsdb.southbound.ovsdb.transact.TransactCommandAggregator;
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
.child(Node.class);
DataTreeIdentifier<Node> dataTreeIdentifier =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, path);
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, path);
registration = db.registerDataTreeChangeListener(dataTreeIdentifier, this);
LOG.info("OVSDB topology listener has been registered.");
}
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.southbound.transactions.md.TransactionInvoker;
import org.opendaylight.ovsdb.utils.mdsal.utils.Scheduler;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
public void registerListener() {
DataTreeIdentifier<Node> treeId =
- new DataTreeIdentifier<Node>(LogicalDatastoreType.OPERATIONAL, getWildcardPath());
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, getWildcardPath());
registration = db.registerDataTreeChangeListener(treeId, this);
}
package org.opendaylight.ovsdb.southbound;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+
import org.opendaylight.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.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+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;
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));
DataTreeIdentifier<Topology> treeId =
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, path);
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, path);
LOG.trace("Registering listener for path {}", treeId);
operTopologyRegistration = db.registerDataTreeChangeListener(treeId, this);
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));
ReadWriteTransaction transaction = db.newReadWriteTransaction();
- CheckedFuture<Optional<Topology>, ReadFailedException> ovsdbTp = transaction.read(type, path);
+ FluentFuture<Optional<Topology>> ovsdbTp = transaction.read(type, path);
try {
if (!ovsdbTp.get().isPresent()) {
TopologyBuilder tpb = new TopologyBuilder();
tpb.setTopologyId(SouthboundConstants.OVSDB_TOPOLOGY_ID);
transaction.put(type, path, tpb.build(), true);
- transaction.submit();
+ transaction.commit();
} else {
transaction.cancel();
}
package org.opendaylight.ovsdb.southbound;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
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;
try {
OvsdbNodeRef ref = mn.getManagedBy();
if (ref != null && ref.getValue() != null) {
- ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
+ ReadTransaction transaction = db.newReadOnlyTransaction();
@SuppressWarnings("unchecked")
// Note: erasure makes this safe in combination with the typecheck below
InstanceIdentifier<Node> path = (InstanceIdentifier<Node>) ref.getValue();
- CheckedFuture<Optional<Node>, ReadFailedException> nf = transaction.read(
+ FluentFuture<Optional<Node>> nf = transaction.read(
LogicalDatastoreType.OPERATIONAL, path);
transaction.close();
Optional<Node> optional = nf.get();
} else {
LOG.warn("OvsdbManagedNode {} claims to be managed by {} but "
+ "that OvsdbNode does not exist", mn, ref.getValue());
- return Optional.absent();
+ return Optional.empty();
}
} else {
LOG.warn("Mysteriously got back a thing which is *not* a topology Node: {}", optional);
- return Optional.absent();
+ return Optional.empty();
}
} else {
LOG.warn("Cannot find client for OvsdbManagedNode without a specified ManagedBy {}", mn);
- return Optional.absent();
+ return Optional.empty();
}
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to get OvsdbNode that manages OvsdbManagedNode {}", mn, e);
- return Optional.absent();
+ return Optional.empty();
}
}
+ public static <D extends DataObject> Optional<D> readNode(ReadWriteTransaction transaction,
+ InstanceIdentifier<D> connectionIid) {
+ Optional<D> node;
+ try {
+ Node cachedNode = OvsdbOperGlobalListener.OPER_NODE_CACHE.get(connectionIid);
+ if (cachedNode != null) {
+ node = Optional.of((D)cachedNode);
+ } else {
+ node = transaction.read(LogicalDatastoreType.OPERATIONAL, connectionIid).get();
+ }
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.warn("Read Operational/DS for Node failed! {}", connectionIid, e);
+ throw new RuntimeException(e);
+ }
+ return node;
+ }
+
public static <D extends DataObject> Optional<D> readNode(ReadTransaction transaction,
InstanceIdentifier<D> connectionIid) {
Optional<D> node;
try {
- if (OvsdbOperGlobalListener.OPER_NODE_CACHE.containsKey(connectionIid)) {
- node = Optional.of((D)OvsdbOperGlobalListener.OPER_NODE_CACHE.get(connectionIid));
+ Node cachedNode = OvsdbOperGlobalListener.OPER_NODE_CACHE.get(connectionIid);
+ if (cachedNode != null) {
+ node = Optional.of((D)cachedNode);
} else {
- node = transaction.read(LogicalDatastoreType.OPERATIONAL, connectionIid).checkedGet();
+ node = transaction.read(LogicalDatastoreType.OPERATIONAL, connectionIid).get();
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Read Operational/DS for Node failed! {}", connectionIid, e);
throw new RuntimeException(e);
}
return node;
-
}
@VisibleForTesting
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
}
OvsdbBridgeAugmentation bridge = null;
final InstanceIdentifier<Node> nodeIid = key.firstIdentifierOf(Node.class);
- try (ReadOnlyTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction()) {
+ try (ReadTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction()) {
final Optional<Node> nodeOptional = SouthboundUtil.readNode(transaction, nodeIid);
if (nodeOptional.isPresent()) {
final List<ManagedNodeEntry> managedNodes =
.firstIdentifierOf(Node.class).augmentation(OvsdbBridgeAugmentation.class);
final Optional<OvsdbBridgeAugmentation> optionalBridge =
transaction.read(LogicalDatastoreType.OPERATIONAL, brIid).get();
- bridge = optionalBridge.orNull();
+ bridge = optionalBridge.get();
if (bridge != null && bridge.getAutoAttach() != null
&& bridge.getAutoAttach().equals(aaUuid)) {
return bridge;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
.augmentation(OvsdbBridgeAugmentation.class);
OvsdbBridgeAugmentation bridge = null;
- try (ReadOnlyTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction()) {
+ try (ReadTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction()) {
final Optional<OvsdbBridgeAugmentation> bridgeOptional =
transaction.read(LogicalDatastoreType.OPERATIONAL, bridgeIid).get();
if (bridgeOptional.isPresent()) {
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
-import com.google.common.base.Optional;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import java.util.Optional;
+
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
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.OvsdbTerminationPointAugmentation;
@SuppressWarnings("IllegalCatch")
public Optional<Node> getBridgeNode(InstanceIdentifier<?> iid) {
InstanceIdentifier<Node> nodeIid = iid.firstIdentifierOf(Node.class);
- Optional<Node> bridgeNode = Optional.absent();
- try (ReadOnlyTransaction transaction = db.newReadOnlyTransaction()) {
+ Optional<Node> bridgeNode = Optional.empty();
+ try (ReadTransaction transaction = db.newReadOnlyTransaction()) {
bridgeNode = SouthboundUtil.readNode(transaction, nodeIid);
} catch (Exception exp) {
LOG.error("Error in getting the brideNode for {}", iid, exp);
public Optional<OvsdbBridgeAugmentation> getOvsdbBridgeAugmentation(InstanceIdentifier<?> iid) {
Optional<Node> nodeOptional = getBridgeNode(iid);
if (nodeOptional.isPresent()) {
- return Optional.fromNullable(nodeOptional.get().augmentation(OvsdbBridgeAugmentation.class));
+ return Optional.ofNullable(nodeOptional.get().augmentation(OvsdbBridgeAugmentation.class));
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<TerminationPoint> getBridgeTerminationPoint(InstanceIdentifier<?> iid) {
LOG.debug("TerminationPoints or Operational BridgeNode missing for {}", iid);
}
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<OvsdbTerminationPointAugmentation> getOvsdbTerminationPointAugmentation(InstanceIdentifier<?> iid) {
Optional<TerminationPoint> tpOptional = getBridgeTerminationPoint(iid);
if (tpOptional.isPresent()) {
- return Optional.fromNullable(tpOptional.get().augmentation(OvsdbTerminationPointAugmentation.class));
+ return Optional.ofNullable(tpOptional.get().augmentation(OvsdbTerminationPointAugmentation.class));
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<ControllerEntry> getControllerEntry(InstanceIdentifier<?> iid) {
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
public Optional<ProtocolEntry> getProtocolEntry(InstanceIdentifier<ProtocolEntry> iid) {
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
}
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.Insert;
import org.opendaylight.ovsdb.lib.operations.Mutate;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
entry.getKey().firstIdentifierOf(OvsdbBridgeAugmentation.class);
Optional<OvsdbBridgeAugmentation> bridgeOptional =
state.getOvsdbBridgeAugmentation(bridgeIid);
- OvsdbBridgeAugmentation ovsdbBridge = bridgeOptional.or(bridges.get(bridgeIid));
+ OvsdbBridgeAugmentation ovsdbBridge = bridgeOptional.isPresent()
+ ? bridgeOptional.get() : bridges.get(bridgeIid);
if (ovsdbBridge != null
&& ovsdbBridge.getBridgeName() != null
&& entry.getValue() != null
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
-import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
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.OvsdbNodeAugmentation;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.operations.Insert;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.operations.Mutate;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import java.util.Collection;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.schema.openvswitch.Qos;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.schema.openvswitch.Qos;
import java.util.Collection;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.schema.openvswitch.Queue;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.schema.openvswitch.Queue;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
-import com.google.common.base.Optional;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
@SuppressWarnings("unchecked")
InstanceIdentifier<Node> iidNode = (InstanceIdentifier<Node>)operBridge.getManagedBy().getValue();
OvsdbNodeAugmentation operNode = null;
- try (ReadOnlyTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction()) {
+ try (ReadTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction()) {
Optional<Node> nodeOptional = SouthboundUtil.readNode(transaction, iidNode);
if (nodeOptional.isPresent()) {
operNode = nodeOptional.get().augmentation(OvsdbNodeAugmentation.class);
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import java.util.Collection;
import java.util.function.Supplier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import java.util.List;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.operations.OperationResult;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import java.util.Queue;
import java.util.Set;
import java.util.function.Predicate;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.Mutation;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.OvsdbSet;
import java.util.Collection;
import java.util.Map;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.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.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
public OvsdbUpgradeStateListener(final DataBroker db, OvsdbConnectionManager cm) {
DataTreeIdentifier<UpgradeConfig> dataTreeIdentifier =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.create(UpgradeConfig.class));
registration = db.registerDataTreeChangeListener(dataTreeIdentifier, this);
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionManager;
InstanceIdentifier<Node> path = SouthboundMapper.createTopologyInstanceIdentifier()
.child(Node.class);
DataTreeIdentifier<Node> dataTreeIdentifier =
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, path);
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, path);
bridgeCreatedDataTreeChangeRegistration = db.registerDataTreeChangeListener(dataTreeIdentifier,
bridgeCreatedDataTreeChangeListener);
*/
package org.opendaylight.ovsdb.southbound.reconciliation.configuration;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionManager;
if (reconcileAllBridges) {
// case 1, 3 & 4
LOG.trace("Reconciling all bridges with exclusion list {}", bridgeReconcileExcludeList);
- CheckedFuture<Optional<Topology>, ReadFailedException> readTopologyFuture;
+ FluentFuture<Optional<Topology>> readTopologyFuture;
InstanceIdentifier<Topology> topologyInstanceIdentifier = SouthboundMapper
.createTopologyInstanceIdentifier();
- try (ReadOnlyTransaction tx = reconciliationManager.getDb().newReadOnlyTransaction()) {
+ try (ReadTransaction tx = reconciliationManager.getDb().newReadOnlyTransaction()) {
// find all bridges of the specific device in the config data store
// TODO: this query is not efficient. It retrieves all the Nodes in the datastore, loop over them and
// look for the bridges of specific device. It is mre efficient if MDSAL allows query nodes using
// wildcard on node id (ie: ovsdb://uuid/<device uuid>/bridge/*) r attributes
- readTopologyFuture = tx.read(CONFIGURATION, topologyInstanceIdentifier);
+ readTopologyFuture = tx.read(LogicalDatastoreType.CONFIGURATION, topologyInstanceIdentifier);
}
- Futures.addCallback(readTopologyFuture, new FutureCallback<Optional<Topology>>() {
+ readTopologyFuture.addCallback(new FutureCallback<Optional<Topology>>() {
@Override
public void onSuccess(@Nullable final Optional<Topology> optionalTopology) {
if (optionalTopology != null && optionalTopology.isPresent()) {
} else {
// Case 3
// Reconciling Specific set of bridges in order to avoid full Topology Read.
- CheckedFuture<Optional<Node>, ReadFailedException> readNodeFuture;
+ FluentFuture<Optional<Node>> readNodeFuture;
LOG.trace("Reconcile Bridge from InclusionList {} only", bridgeReconcileIncludeList);
for (String bridgeNodeIid : bridgeReconcileIncludeList) {
- try (ReadOnlyTransaction tx = reconciliationManager.getDb().newReadOnlyTransaction()) {
+ try (ReadTransaction tx = reconciliationManager.getDb().newReadOnlyTransaction()) {
InstanceIdentifier<Node> nodeInstanceIdentifier =
SouthboundMapper.createInstanceIdentifier(new NodeId(bridgeNodeIid));
- readNodeFuture = tx.read(CONFIGURATION, nodeInstanceIdentifier);
+ readNodeFuture = tx.read(LogicalDatastoreType.CONFIGURATION, nodeInstanceIdentifier);
}
- Futures.addCallback(readNodeFuture, new FutureCallback<Optional<Node>>() {
+ readNodeFuture.addCallback(new FutureCallback<Optional<Node>>() {
@Override
public void onSuccess(@Nullable final Optional<Node> optionalTopology) {
if (optionalTopology != null && optionalTopology.isPresent()) {
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
package org.opendaylight.ovsdb.southbound.transactions.md;
-import com.google.common.base.Optional;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
package org.opendaylight.ovsdb.southbound.transactions.md;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
// .getExternalIdsColumn().getData()
// .get(SouthboundConstants.AUTOATTACH_ID_EXTERNAL_ID_KEY))));
final Optional<Autoattach> optionalAutoattach =
- transaction.read(LogicalDatastoreType.OPERATIONAL, currentIid).checkedGet();
+ transaction.read(LogicalDatastoreType.OPERATIONAL, currentIid).get();
if (optionalAutoattach.isPresent()) {
currentAutoattach = optionalAutoattach.get();
}
- } catch (final ReadFailedException e) {
+ } catch (final InterruptedException | ExecutionException e) {
LOG.debug("AutoAttach table entries not found in operational datastore, need to create it.", e);
}
}
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.net.InetAddresses;
import java.net.InetAddress;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import org.apache.commons.lang3.math.NumberUtils;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
package org.opendaylight.ovsdb.southbound.transactions.md;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
*/
package org.opendaylight.ovsdb.southbound.transactions.md;
-import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
package org.opendaylight.ovsdb.southbound.transactions.md;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
@Override
public void execute(ReadWriteTransaction transaction) {
- CheckedFuture<Optional<Node>, ReadFailedException> ovsdbNodeFuture = transaction.read(
+ FluentFuture<Optional<Node>> ovsdbNodeFuture = transaction.read(
LogicalDatastoreType.OPERATIONAL, getOvsdbConnectionInstance().getInstanceIdentifier());
Optional<Node> ovsdbNodeOptional;
try {
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.Version;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
+
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.error.ColumnSchemaNotFoundException;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
}
for (Entry<UUID, Interface> interfaceUpdate : interfaceUpdatedRows.entrySet()) {
String interfaceName = null;
- Optional<InstanceIdentifier<Node>> bridgeIid = Optional.absent();
+ Optional<InstanceIdentifier<Node>> bridgeIid = Optional.empty();
interfaceName = interfaceUpdatedRows.get(interfaceUpdate.getKey()).getNameColumn().getData();
if (getOvsdbConnectionInstance().getPortInterface(interfaceName) != null) {
bridgeIid = Optional.of(getOvsdbConnectionInstance().getPortInterface(interfaceName));
@SuppressWarnings("IllegalCatch")
private Optional<Node> readNode(final ReadWriteTransaction transaction, final InstanceIdentifier<Node> nodePath) {
- Optional<Node> node = Optional.absent();
+ Optional<Node> node = Optional.empty();
try {
node = SouthboundUtil.readNode(transaction, nodePath);
} catch (Exception exp) {
if (getOvsdbConnectionInstance().getPort(portUuid) != null) {
return Optional.of(getOvsdbConnectionInstance().getPort(portUuid));
}
- return Optional.absent();
+ return Optional.empty();
}
@SuppressWarnings("unchecked")
}
}
- return Optional.absent();
+ return Optional.empty();
}
@VisibleForTesting
package org.opendaylight.ovsdb.southbound.transactions.md;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
package org.opendaylight.ovsdb.southbound.transactions.md;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
package org.opendaylight.ovsdb.southbound.transactions.md;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
package org.opendaylight.ovsdb.southbound.transactions.md;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
package org.opendaylight.ovsdb.southbound.transactions.md;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
public interface TransactionCommand {
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import org.checkerframework.checker.lock.qual.GuardedBy;
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.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;
private final DataBroker db;
private final BlockingQueue<TransactionCommand> inputQueue = new LinkedBlockingQueue<>(QUEUE_SIZE);
- private final BlockingQueue<AsyncTransaction<?, ?>> failedTransactionQueue = new LinkedBlockingQueue<>(QUEUE_SIZE);
+ private final BlockingQueue<Transaction> failedTransactionQueue = new LinkedBlockingQueue<>(QUEUE_SIZE);
private final ExecutorService executor;
private final AtomicBoolean runTask = new AtomicBoolean(true);
@GuardedBy("this")
private final Queue<Entry<ReadWriteTransaction, TransactionCommand>> pendingTransactions = new ArrayDeque<>();
@GuardedBy("this")
- private BindingTransactionChain chain;
+ private TransactionChain chain;
public TransactionInvokerImpl(final DataBroker db) {
this.db = db;
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chainArg,
- final AsyncTransaction<?, ?> transaction, final Throwable cause) {
+ 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) {
+ public void onTransactionChainSuccessful(final TransactionChain chainArg) {
// NO OP
}
transactionInFlight = transaction;
recordPendingTransaction(command, transaction);
command.execute(transaction);
- Futures.addCallback(transaction.submit(), new FutureCallback<Void>() {
+ Futures.addCallback(transaction.commit(), new FutureCallback<Object>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final Object result) {
forgetSuccessfulTransaction(transaction);
command.onSuccess();
}
}
}
- private void offerFailedTransaction(final AsyncTransaction<?, ?> transaction) {
+ private void offerFailedTransaction(final Transaction transaction) {
if (!failedTransactionQueue.offer(transaction)) {
LOG.warn("failedTransactionQueue is full (size: {})", failedTransactionQueue.size());
}
@VisibleForTesting
synchronized List<TransactionCommand> extractResubmitCommands() {
- AsyncTransaction<?, ?> transaction = failedTransactionQueue.poll();
+ Transaction transaction = failedTransactionQueue.poll();
List<TransactionCommand> commands = new ArrayList<>();
if (transaction != null) {
// Process all pending transactions, looking for the failed one...
import static org.powermock.api.support.membermodification.MemberMatcher.field;
import static org.powermock.api.support.membermodification.MemberModifier.suppress;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+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.Map;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
suppress(MemberMatcher.method(OvsdbConnectionManager.class, "registerEntityForOwnership",
OvsdbConnectionInstance.class));
- ReadOnlyTransaction tx = mock(ReadOnlyTransaction.class);
+ ReadTransaction tx = mock(ReadTransaction.class);
when(db.newReadOnlyTransaction()).thenReturn(tx);
when(tx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
- .thenReturn(mock(CheckedFuture.class));
+ .thenReturn(mock(FluentFuture.class));
when(client.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
ovsdbConnManager.connected(externalClient);
MemberModifier.suppress(MemberMatcher.method(OvsdbConnectionManager.class, "reconcileConnection",
InstanceIdentifier.class, OvsdbNodeAugmentation.class));
- ReadOnlyTransaction tx = mock(ReadOnlyTransaction.class);
+ ReadTransaction tx = mock(ReadTransaction.class);
when(db.newReadOnlyTransaction()).thenReturn(tx);
when(tx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
- .thenReturn(mock(CheckedFuture.class));
+ .thenReturn(mock(FluentFuture.class));
when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
ovsdbConnManager.disconnected(externalClient);
Map<ConnectionInfo, OvsdbConnectionInstance> testClients = Whitebox.getInternalState(ovsdbConnManager,
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.ovsdb.lib.OvsdbConnection;
import org.opendaylight.ovsdb.southbound.transactions.md.TransactionInvokerImpl;
.setRemotePort(portNumber)
.build();
final InstanceIdentifier<Node> iid = SouthboundUtils.createInstanceIdentifier(connectionInfo);
- WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction transaction = dataBroker.newReadWriteTransaction();
transaction.put(LogicalDatastoreType.CONFIGURATION, iid, SouthboundUtils.createNode(connectionInfo),
WriteTransaction.CREATE_MISSING_PARENTS);
- transaction.submit().get();
+ transaction.commit().get();
// Then the listener tries to open a connection
Mockito.verify(ovsdbConnection, Mockito.timeout(5000)).connect(inetAddress, port);
import com.google.common.base.Stopwatch;
import com.google.common.util.concurrent.Uninterruptibles;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.infrautils.diagstatus.DiagStatusService;
import org.opendaylight.infrautils.ready.testutils.TestSystemReadyMonitor;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+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;
}
@Test
- public void testHandleOwnershipChange() throws ReadFailedException {
+ public void testHandleOwnershipChange() throws ExecutionException, InterruptedException {
when(entityOwnershipService.getOwnershipState(any(Entity.class))).thenReturn(
java.util.Optional.of(EntityOwnershipState.from(false, true)));
Entity entity = new Entity("ovsdb-southbound-provider", "ovsdb-southbound-provider");
// At this point the OVSDB topology must not be present in either tree
assertFalse(getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION,
- topologyIid).checkedGet().isPresent());
+ topologyIid).get().isPresent());
assertFalse(getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL,
- topologyIid).checkedGet().isPresent());
+ topologyIid).get().isPresent());
// Become owner
southboundProvider.handleOwnershipChange(new EntityOwnershipChange(entity,
// Now the OVSDB topology must be present in both trees
assertTrue(getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION,
- topologyIid).checkedGet().isPresent());
+ topologyIid).get().isPresent());
assertTrue(getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL,
- topologyIid).checkedGet().isPresent());
+ topologyIid).get().isPresent());
// Verify idempotency
southboundProvider.handleOwnershipChange(new EntityOwnershipChange(entity,
// The OVSDB topology must be present in both trees
assertTrue(getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION,
- topologyIid).checkedGet().isPresent());
+ topologyIid).get().isPresent());
assertTrue(getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL,
- topologyIid).checkedGet().isPresent());
+ topologyIid).get().isPresent());
}
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import com.google.common.collect.Iterators;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.net.InetAddress;
import java.net.NetworkInterface;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.stubbing.Answer;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAttributes;
OvsdbBridgeAttributes mn = mock(OvsdbBridgeAttributes.class);
DataBroker db = mock(DataBroker.class);
OvsdbNodeRef ref = mock(OvsdbNodeRef.class);
- ReadOnlyTransaction transaction = mock(ReadOnlyTransaction.class);
+ ReadTransaction transaction = mock(ReadTransaction.class);
when(db.newReadOnlyTransaction()).thenReturn(transaction);
when(mn.getManagedBy()).thenReturn(ref);
when(ref.getValue()).thenAnswer(
(Answer<InstanceIdentifier<Node>>) invocation -> (InstanceIdentifier<Node>) mock(
InstanceIdentifier.class));
- CheckedFuture<Optional<Node>, ReadFailedException> nf = mock(CheckedFuture.class);
+ 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));
//node not null, ovsdbNode null
- when(nf.get()).thenReturn(Optional.absent());
- assertEquals("Failed to return correct Optional object", Optional.absent(),
+ when(nf.get()).thenReturn(Optional.empty());
+ assertEquals("Failed to return correct Optional object", Optional.empty(),
SouthboundUtil.getManagingNode(db, mn));
//optional null
when(nf.get()).thenReturn(null);
- assertEquals("Failed to return correct Optional object", Optional.absent(),
+ assertEquals("Failed to return correct Optional object", Optional.empty(),
SouthboundUtil.getManagingNode(db, mn));
//ref null
when(mn.getManagedBy()).thenReturn(null);
- assertEquals("Failed to return correct Optional object", Optional.absent(),
+ assertEquals("Failed to return correct Optional object", Optional.empty(),
SouthboundUtil.getManagingNode(db, mn));
}
Optional<DataObject> node = Optional.of(mock(DataObject.class));
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
InstanceIdentifier<DataObject> connectionIid = mock(InstanceIdentifier.class);
- CheckedFuture<Optional<DataObject>, ReadFailedException> value = mock(CheckedFuture.class);
+ FluentFuture<Optional<DataObject>> value = mock(FluentFuture.class);
when(transaction.read(LogicalDatastoreType.OPERATIONAL, connectionIid)).thenReturn(value);
- when(value.checkedGet()).thenReturn(node);
+ when(value.get()).thenReturn(node);
assertEquals("Incorrect Optional object received", node, SouthboundUtil.readNode(transaction, connectionIid));
}
import static org.mockito.Mockito.when;
import static org.powermock.reflect.Whitebox.getField;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.ovsdb.southbound.OvsdbOperGlobalListener;
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.OvsdbTerminationPointAugmentation;
@Mock private BridgeOperationalState briOperationState;
@Mock private DataBroker db;
- @Mock ReadOnlyTransaction mockReadTx;
+ @Mock ReadTransaction mockReadTx;
private InstanceIdentifier<ProtocolEntry> protocolEntry;
private InstanceIdentifier<Node> iidNode;
private Map<InstanceIdentifier<Node>, Node> operationalNodes;
Optional<OvsdbBridgeAugmentation> optOvsdbBri = briOperationState.getOvsdbBridgeAugmentation(nodeIid);
verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
assertNotNull(optOvsdbBri);
- assertTrue(optOvsdbBri.equals(Optional.absent()));
+ assertTrue(optOvsdbBri.equals(Optional.empty()));
Node node = mock(Node.class);
Optional<Node> optNode = Optional.of(node);
Optional<TerminationPoint> optTerm = briOperationState.getBridgeTerminationPoint(nodeIid);
verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
assertNotNull(optTerm);
- assertTrue(optTerm.equals(Optional.absent()));
+ assertTrue(optTerm.equals(Optional.empty()));
TerminationPoint termPnt = mock(TerminationPoint.class);
List<TerminationPoint> termPntList = new ArrayList<>();
assertNotNull(optOvsdbTermPoint);
verify(briOperationState, times(1)).getBridgeTerminationPoint(any(InstanceIdentifier.class));
verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
- assertTrue(optOvsdbTermPoint.equals(Optional.absent()));
+ assertTrue(optOvsdbTermPoint.equals(Optional.empty()));
TerminationPoint termPoint = mock(TerminationPoint.class);
Optional<TerminationPoint> termPntOptional = Optional.of(termPoint);
verify(briOperationState, times(1)).getOvsdbBridgeAugmentation(any(InstanceIdentifier.class));
verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
assertNotNull(optController);
- assertTrue(optController.equals(Optional.absent()));
+ assertTrue(optController.equals(Optional.empty()));
}
@Test
verify(briOperationState, times(1)).getOvsdbBridgeAugmentation(any(InstanceIdentifier.class));
verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
assertNotNull(optProtocolEntry);
- assertTrue(optProtocolEntry.equals(Optional.absent()));
+ assertTrue(optProtocolEntry.equals(Optional.empty()));
}
}
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.powermock.reflect.Whitebox;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import java.lang.reflect.Field;
import java.util.HashSet;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import org.junit.Ignore;
import org.junit.Test;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionManager;
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.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.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
+
+
@RunWith(MockitoJUnitRunner.class)
public class BridgeConfigReconciliationTaskTest {
private static final String BR_INT = "br-int";
SouthboundProvider.setBridgesReconciliationInclusionList(Arrays.asList(BR_INT));
Node brIntNode = createBridgeNode(NODE_ID + "/bridge/" + BR_INT);
Optional<Node> nodeOptional = Optional.of(brIntNode);
- CheckedFuture<Optional<Node>, ReadFailedException> readNodeFuture =
- Futures.immediateCheckedFuture(nodeOptional);
+ FluentFuture<Optional<Node>> readNodeFuture =
+ FluentFutures.immediateFluentFuture(nodeOptional);
when(reconciliationManager.getDb()).thenReturn(db);
- ReadOnlyTransaction tx = mock(ReadOnlyTransaction.class);
+ ReadTransaction tx = mock(ReadTransaction.class);
Mockito.when(db.newReadOnlyTransaction()).thenReturn(tx);
Mockito.when(tx.read(any(LogicalDatastoreType.class),any(InstanceIdentifier.class)))
.thenReturn(readNodeFuture);
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.notation.UUID;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.schema.openvswitch.AutoAttach;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import com.google.common.collect.Iterators;
import com.google.common.net.InetAddresses;
import java.net.NetworkInterface;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.stubbing.Answer;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.notation.UUID;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.notation.UUID;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.notation.UUID;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
@Test
public void testExecute() throws Exception {
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
- CheckedFuture<Optional<Node>, ReadFailedException> ovsdbNodeFuture = mock(CheckedFuture.class);
+ FluentFuture<Optional<Node>> ovsdbNodeFuture = mock(FluentFuture.class);
OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
when(ovsdbNodeRemoveCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.Version;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.notation.UUID;
import static org.powermock.api.support.membermodification.MemberMatcher.method;
import static org.powermock.api.support.membermodification.MemberModifier.suppress;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import org.junit.Before;
import org.junit.Ignore;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.notation.UUID;
any(Node.class));
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
PowerMockito.mockStatic(SouthboundUtil.class);
- PowerMockito.when(SouthboundUtil.readNode(any(ReadTransaction.class), any(InstanceIdentifier.class)))
+ PowerMockito.when(SouthboundUtil.readNode(any(ReadWriteTransaction.class), any(InstanceIdentifier.class)))
.thenReturn(node);
ovsdbPortUpdateCommand.execute(transaction);
verify(ovsdbConnectionInstance).getInstanceIdentifier();
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
InstanceIdentifier<Node> nodePath = mock(InstanceIdentifier.class);
Optional<Node> node = Optional.of(mock(Node.class));
- CheckedFuture<Optional<Node>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
+ FluentFuture<Optional<Node>> fluentFuture = mock(FluentFuture.class);
when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
- .thenReturn(checkedFuture);
- when(checkedFuture.checkedGet()).thenReturn(node);
+ .thenReturn(fluentFuture);
+ when(fluentFuture.get()).thenReturn(node);
assertEquals(node, Whitebox.invokeMethod(ovsdbPortUpdateCommand, "readNode", transaction, nodePath));
}
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.Transaction;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.TransactionChainListener;
@RunWith(MockitoJUnitRunner.class)
public class TransactionInvokerImplTest {
@Mock
- private BindingTransactionChain chain;
+ private TransactionChain chain;
@Mock
private DataBroker db;
public void testOnTransactionChainFailed() {
final TransactionInvokerImpl invoker = new TransactionInvokerImpl(db, new ArrayList<>());
- final AsyncTransaction<?, ?> transaction = mock(AsyncTransaction.class);
+ final Transaction transaction = mock(Transaction.class);
invoker.onTransactionChainFailed(chain, transaction, new Throwable());
final Queue<?> failedQueue = getInternalState(invoker, "failedTransactionQueue");
<type>pom</type>
<scope>import</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>mdsal-artifacts</artifactId>
- <version>1.11.0</version>
- <type>pom</type>
- <scope>import</scope>
- </dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-common-api</artifactId>
</dependency>
<dependency>
<groupId>${project.groupId}</groupId>
import org.junit.Test;
import org.junit.internal.AssumptionViolatedException;
import org.junit.runner.RunWith;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.mdsal.it.base.AbstractMdsalTestBase;
+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.ovsdb.lib.notation.Version;
import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
}
public void registerDataChangeListener() {
- dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(type,
+ dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(type,
(InstanceIdentifier)iid), this);
}
assertTrue("Did not find " + SouthboundUtils.OVSDB_TOPOLOGY_ID.getValue(), getOvsdbTopology());
final ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portNumber);
final InstanceIdentifier<Node> iid = SouthboundUtils.createInstanceIdentifier(connectionInfo);
- dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
(InstanceIdentifier)iid), CONFIGURATION_LISTENER);
- dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
(InstanceIdentifier)iid), OPERATIONAL_LISTENER);
ovsdbNode = connectOvsdbNode(connectionInfo);
<dependencies>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<!-- testing dependencies -->
<version>${project.version}</version>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
- <type>test-jar</type>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>javax.inject</groupId>
- <artifactId>javax.inject</artifactId>
- <version>1</version>
- <scope>compile</scope>
+ <groupId>javax.inject</groupId>
+ <artifactId>javax.inject</artifactId>
+ <version>1</version>
+ <scope>compile</scope>
</dependency>
</dependencies>
*/
package org.opendaylight.ovsdb.utils.mdsal.utils;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import com.google.common.util.concurrent.FluentFuture;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
/**
* Class constructor setting the data broker.
*
- * @param dataBroker the {@link org.opendaylight.controller.md.sal.binding.api.DataBroker}
+ * @param dataBroker the {@link org.opendaylight.mdsal.binding.api.DataBroker}
*/
public ControllerMdsalUtils(DataBroker dataBroker) {
this.databroker = dataBroker;
boolean result = false;
final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
transaction.delete(store, path);
- CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
+ FluentFuture<? extends @NonNull CommitInfo> future = transaction.commit();
try {
- future.checkedGet();
+ future.get();
result = true;
- } catch (TransactionCommitFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to delete {} ", path, e);
}
return result;
boolean result = false;
final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
transaction.merge(logicalDatastoreType, path, data, true);
- CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
+ FluentFuture<? extends @NonNull CommitInfo> future = transaction.commit();
try {
- future.checkedGet();
+ future.get();
result = true;
- } catch (TransactionCommitFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to merge {} ", path, e);
}
return result;
boolean result = false;
final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
transaction.put(logicalDatastoreType, path, data, true);
- CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
+ FluentFuture<? extends @NonNull CommitInfo> future = transaction.commit();
try {
- future.checkedGet();
+ future.get();
result = true;
- } catch (TransactionCommitFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to put {} ", path, e);
}
return result;
public <D extends DataObject> Optional<D> readOptional(
final LogicalDatastoreType store, final InstanceIdentifier<? extends DataObject> path) {
int trialNo = 0;
- ReadOnlyTransaction transaction = databroker.newReadOnlyTransaction();
+ ReadTransaction transaction = databroker.newReadOnlyTransaction();
do {
try {
- Optional<D> result = transaction.read(store, (InstanceIdentifier<D>)path).checkedGet();
+ Optional<D> result = transaction.read(store, (InstanceIdentifier<D>)path).get();
transaction.close();
return result;
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
if (trialNo == 0) {
logReadFailureError(path, " mdsal Read failed exception retrying the read after sleep");
}
}
} while (trialNo++ < MDSAL_MAX_READ_TRIALS);
logReadFailureError(path, " All read trials exceeded");
- return Optional.absent();
+ return Optional.empty();
}
private <D extends org.opendaylight.yangtools.yang.binding.DataObject> void logReadFailureError(
package org.opendaylight.ovsdb.utils.mdsal.utils;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
/**
* Class constructor setting the data broker.
*
- * @param dataBroker the {@link org.opendaylight.controller.md.sal.binding.api.DataBroker}
+ * @param dataBroker the {@link DataBroker}
*/
public ControllerMdsalUtilsAsync(final DataBroker dataBroker) {
this.databroker = dataBroker;
* @return The {@link CheckedFuture} object to which you can assign a
* callback
*/
- public <D extends DataObject> CheckedFuture<Void, TransactionCommitFailedException> delete(
+ public <D extends DataObject> FluentFuture<? extends @NonNull CommitInfo> delete(
final LogicalDatastoreType store,
final InstanceIdentifier<D> path) {
final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
transaction.delete(store, path);
- return transaction.submit();
+ return transaction.commit();
}
/**
* @return The {@link CheckedFuture} object to which you can assign a
* callback
*/
- public <D extends DataObject> CheckedFuture<Void, TransactionCommitFailedException> put(
+ public <D extends DataObject> FluentFuture<? extends @NonNull CommitInfo> put(
final LogicalDatastoreType logicalDatastoreType,
final InstanceIdentifier<D> path,
final D data) {
final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
transaction.put(logicalDatastoreType, path, data, true);
- return transaction.submit();
+ return transaction.commit();
}
/**
* @return The {@link CheckedFuture} object to which you can assign a
* callback
*/
- public <D extends DataObject> CheckedFuture<Void, TransactionCommitFailedException> merge(
+ public <D extends DataObject> FluentFuture<? extends @NonNull CommitInfo> merge(
final LogicalDatastoreType logicalDatastoreType,
final InstanceIdentifier<D> path,
final D data,
final boolean withParent) {
final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
transaction.merge(logicalDatastoreType, path, data, withParent);
- return transaction.submit();
+ return transaction.commit();
}
/**
* @return The {@link CheckedFuture} object to which you can assign a
* callback
*/
- public <D extends DataObject> CheckedFuture<Optional<D>, ReadFailedException> read(
+ public <D extends DataObject> FluentFuture<Optional<D>> read(
final LogicalDatastoreType store,
final InstanceIdentifier<D> path) {
- final ReadOnlyTransaction transaction = databroker.newReadOnlyTransaction();
- final CheckedFuture<Optional<D>, ReadFailedException> future = transaction.read(store, path);
+ final ReadTransaction transaction = databroker.newReadOnlyTransaction();
+ final FluentFuture<Optional<D>> future = transaction.read(store, path);
final FutureCallback<Optional<D>> closeTransactionCallback = new FutureCallback<Optional<D>>() {
@Override
public void onSuccess(final Optional<D> result) {
transaction.close();
}
};
- Futures.addCallback(future, closeTransactionCallback, MoreExecutors.directExecutor());
+ future.addCallback(closeTransactionCallback, MoreExecutors.directExecutor());
return future;
}
* @param operationDesc
* A description of the transaction to commit.
*/
- void assignDefaultCallback(final CheckedFuture<Void, TransactionCommitFailedException> transactionFuture,
+ void assignDefaultCallback(final FluentFuture<? extends @NonNull CommitInfo> transactionFuture,
final String operationDesc) {
- Futures.addCallback(transactionFuture, new FutureCallback<Void>() {
+ transactionFuture.addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.debug("Transaction({}) SUCCESSFUL", operationDesc);
}
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.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.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private volatile boolean listen;
private volatile int mask;
- public ControllerNotifyingDataChangeListener(LogicalDatastoreType type, int mask, InstanceIdentifier<?> iid,
+ public ControllerNotifyingDataChangeListener(LogicalDatastoreType type, int mask,
+ InstanceIdentifier<?> iid,
List<ControllerNotifyingDataChangeListener> waitList) {
this(type, iid, waitList);
this.mask = mask;
@SuppressWarnings({ "rawtypes", "unchecked" })
public void registerDataChangeListener(DataBroker dataBroker) {
- listenerRegistration = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(type,
- (InstanceIdentifier)iid), this);
+
+ listenerRegistration = dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(type,
+ (InstanceIdentifier)iid), this);
}
public void waitForCreation() throws InterruptedException {
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Optional;
import org.opendaylight.mdsal.binding.api.DataBroker;
transaction.close();
}
};
- Futures.addCallback(future, closeTransactionCallback, MoreExecutors.directExecutor());
+ future.addCallback(closeTransactionCallback, MoreExecutors.directExecutor());
return future;
}
*/
void assignDefaultCallback(final FluentFuture<? extends CommitInfo> transactionFuture,
final String operationDesc) {
- Futures.addCallback(transactionFuture, new FutureCallback<CommitInfo>() {
+ transactionFuture.addCallback(new FutureCallback<CommitInfo>() {
@Override
public void onSuccess(final CommitInfo result) {
LOG.debug("Transaction({}) SUCCESSFUL", operationDesc);
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Collections;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
+import org.eclipse.jdt.annotation.NonNull;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTest;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
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;
@Test
public void testDelete() {
- final CheckedFuture<Void, TransactionCommitFailedException> fut = mdsalUtilsAsync.put(
+ final FluentFuture<? extends @NonNull CommitInfo> fut = mdsalUtilsAsync.put(
LogicalDatastoreType.CONFIGURATION, TEST_IID, DATA);
- Futures.addCallback(fut, new FutureCallback<Void>() {
+ fut.addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
- final CheckedFuture<Void, TransactionCommitFailedException> future =
+ public void onSuccess(final CommitInfo result) {
+ final FluentFuture<? extends @NonNull CommitInfo> future =
mdsalUtilsAsync.delete(LogicalDatastoreType.CONFIGURATION, TEST_IID);
- Futures.addCallback(future, new FutureCallback<Void>() {
+ future.addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
assertNull(readDS());
}
mdsalUtilsAsync.put(LogicalDatastoreType.CONFIGURATION, TEST_IID, data1, operationDesc);
assertEquals(data1, readDS());
- final CheckedFuture<Void, TransactionCommitFailedException> future = mdsalUtilsAsync.put(
+ final FluentFuture<? extends @NonNull CommitInfo> future = mdsalUtilsAsync.put(
LogicalDatastoreType.CONFIGURATION, TEST_IID, data2);
- Futures.addCallback(future, new FutureCallback<Void>() {
+ future.addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
assertEquals(1, readDS().getSupportingNode().size());
}
mdsalUtilsAsync.merge(LogicalDatastoreType.CONFIGURATION, TEST_IID, data1, operationDesc, true);
assertEquals(data1, readDS());
- final CheckedFuture<Void, TransactionCommitFailedException> future =
+ final FluentFuture<? extends @NonNull CommitInfo> future =
mdsalUtilsAsync.merge(LogicalDatastoreType.CONFIGURATION, TEST_IID, data2, true);
- Futures.addCallback(future, new FutureCallback<Void>() {
+ future.addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
assertEquals(2, readDS().getSupportingNode().size());
}
@Test
public void testRead() {
- final CheckedFuture<Void, TransactionCommitFailedException> fut =
+ final FluentFuture<? extends @NonNull CommitInfo> fut =
mdsalUtilsAsync.put(LogicalDatastoreType.CONFIGURATION, TEST_IID, DATA);
- Futures.addCallback(fut, new FutureCallback<Void>() {
+ fut.addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
- final CheckedFuture<Optional<Node>, ReadFailedException> future =
+ public void onSuccess(final CommitInfo result) {
+ final FluentFuture<Optional<Node>> future =
mdsalUtilsAsync.read(LogicalDatastoreType.CONFIGURATION, TEST_IID);
Optional<Node> optNode;
try {
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import org.eclipse.jdt.annotation.NonNull;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
+import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public void testDelete() {
WriteTransaction writeTransaction = mock(WriteTransaction.class);
when(databroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
- CheckedFuture<Void, TransactionCommitFailedException> future = mock(CheckedFuture.class);
- when(writeTransaction.submit()).thenReturn(future);
+ FluentFuture<? extends @NonNull CommitInfo> future = mock(FluentFuture.class);
+ Mockito.when(writeTransaction.commit()).thenReturn(FluentFutures.immediateNullFluentFuture());
boolean result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION, mock(InstanceIdentifier.class));
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(writeTransaction, times(1)).submit();
+ verify(writeTransaction, times(1)).commit();
assertTrue("Error, the delete transaction failed", result);
}
public void testMerge() {
WriteTransaction writeTransaction = mock(WriteTransaction.class);
when(databroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
- CheckedFuture<Void, TransactionCommitFailedException> future = mock(CheckedFuture.class);
- when(writeTransaction.submit()).thenReturn(future);
+ FluentFuture<? extends @NonNull CommitInfo> future = mock(FluentFuture.class);
+ Mockito.when(writeTransaction.commit()).thenReturn(FluentFutures.immediateNullFluentFuture());
boolean result = mdsalUtils.merge(LogicalDatastoreType.CONFIGURATION,
mock(InstanceIdentifier.class), mock(DataObject.class));
verify(writeTransaction, times(1)).merge(any(LogicalDatastoreType.class),
any(InstanceIdentifier.class), any(DataObject.class), anyBoolean());
- verify(writeTransaction, times(1)).submit();
+ verify(writeTransaction, times(1)).commit();
assertTrue("Error, the merge transaction failed", result);
}
public void testPut() {
WriteTransaction writeTransaction = mock(WriteTransaction.class);
when(databroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
- CheckedFuture<Void, TransactionCommitFailedException> future = mock(CheckedFuture.class);
- when(writeTransaction.submit()).thenReturn(future);
+ FluentFuture<? extends @NonNull CommitInfo> future = mock(FluentFuture.class);
+ Mockito.when(writeTransaction.commit()).thenReturn(FluentFutures.immediateNullFluentFuture());
boolean result = mdsalUtils.put(LogicalDatastoreType.CONFIGURATION,
mock(InstanceIdentifier.class), mock(DataObject.class));
verify(writeTransaction, times(1)).put(any(LogicalDatastoreType.class),
any(InstanceIdentifier.class), any(DataObject.class), anyBoolean());
- verify(writeTransaction, times(1)).submit();
+ verify(writeTransaction, times(1)).commit();
assertTrue("Error, the put transaction failed", result);
}
@Test
- public void testRead() throws ReadFailedException {
- ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
+ public void testRead() throws InterruptedException, ExecutionException {
+ ReadTransaction readOnlyTransaction = mock(ReadTransaction.class);
when(databroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
- CheckedFuture<Optional, ReadFailedException> future = mock(CheckedFuture.class);
+ FluentFuture<Optional> future = mock(FluentFuture.class);
DataObject obj = mock(DataObject.class);
Optional opt = Optional.of(obj);
- when(future.checkedGet()).thenReturn(opt);
+ when(future.get()).thenReturn(opt);
when(readOnlyTransaction.read(any(LogicalDatastoreType.class),
any(InstanceIdentifier.class))).thenReturn(future);
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Collections;
import java.util.Optional;
public void testDelete() {
final FluentFuture<? extends CommitInfo> fut = mdsalUtilsAsync.put(
LogicalDatastoreType.CONFIGURATION, TEST_IID, DATA);
- Futures.addCallback(fut, new FutureCallback<CommitInfo>() {
+ fut.addCallback(new FutureCallback<CommitInfo>() {
@Override
public void onSuccess(final CommitInfo result) {
final FluentFuture<? extends CommitInfo> future =
mdsalUtilsAsync.delete(LogicalDatastoreType.CONFIGURATION, TEST_IID);
- Futures.addCallback(future, new FutureCallback<CommitInfo>() {
+ future.addCallback(new FutureCallback<CommitInfo>() {
@Override
public void onSuccess(final CommitInfo result) {
final FluentFuture<? extends CommitInfo> future = mdsalUtilsAsync.put(
LogicalDatastoreType.CONFIGURATION, TEST_IID, data2);
- Futures.addCallback(future, new FutureCallback<CommitInfo>() {
+ future.addCallback(new FutureCallback<CommitInfo>() {
@Override
public void onSuccess(final CommitInfo result) {
final FluentFuture<? extends CommitInfo> future =
mdsalUtilsAsync.merge(LogicalDatastoreType.CONFIGURATION, TEST_IID, data2, true);
- Futures.addCallback(future, new FutureCallback<CommitInfo>() {
+ future.addCallback(new FutureCallback<CommitInfo>() {
@Override
public void onSuccess(final CommitInfo result) {
final FluentFuture<? extends CommitInfo> fut =
mdsalUtilsAsync.put(LogicalDatastoreType.CONFIGURATION, TEST_IID, DATA);
- Futures.addCallback(fut, new FutureCallback<CommitInfo>() {
+ fut.addCallback(new FutureCallback<CommitInfo>() {
@Override
public void onSuccess(final CommitInfo result) {
final FluentFuture<Optional<Node>> future =
build failure. Please do not modify this unless you have a good reason. -->
<name>ODL :: ovsdb :: ${project.artifactId}</name>
- <dependencyManagement>
+ <!--<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<scope>import</scope>
</dependency>
</dependencies>
- </dependencyManagement>
+ </dependencyManagement>-->
<dependencies>
<dependency>
<version>${project.version}</version>
</dependency>
- <dependency>
+ <!--<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>odl-mdsal-broker</artifactId>
<type>xml</type>
<classifier>features</classifier>
- </dependency>
+ </dependency>-->
</dependencies>
</project>
import static org.junit.Assert.assertTrue;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.utils.mdsal.utils.ControllerNotifyingDataChangeListener;
import org.opendaylight.ovsdb.utils.mdsal.utils.NotifyingDataChangeListener;
import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
import static org.junit.Assert.assertNotNull;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.ovsdb.utils.mdsal.utils.ControllerMdsalUtils;
import org.opendaylight.ovsdb.utils.mdsal.utils.ControllerNotifyingDataChangeListener;
import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
@Override
<T extends DataObject> T read(LogicalDatastoreType store, InstanceIdentifier<T> path) {
- return mdsalUtils.read(
- org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.fromMdsal(store), path);
+ return mdsalUtils.read(store, path);
}
@Override
<T extends DataObject> boolean put(LogicalDatastoreType store,
InstanceIdentifier<T> path, T data) {
- return mdsalUtils.put(
- org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.fromMdsal(store), path, data);
+ return mdsalUtils.put(store, path, data);
}
@Override
boolean delete(LogicalDatastoreType store, InstanceIdentifier<?> path) {
- return mdsalUtils.delete(
- org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.fromMdsal(store), path);
+ return mdsalUtils.delete(store, path);
}
@Override
<T extends DataObject> boolean merge(LogicalDatastoreType store, InstanceIdentifier<T> path, T data) {
- return mdsalUtils.merge(
- org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.fromMdsal(store), path, data);
+ return mdsalUtils.merge(store, path, data);
}
}
return controllerEntriesList;
}
- /**
- * Extract the <code>store</code> type data store contents for the particular bridge identified by
- * <code>bridgeName</code>.
- *
- * @param connectionInfo address for the node
- * @param bridgeName name of the bridge
- * @param store defined by the <code>LogicalDatastoreType</code> enumeration
- * @return <code>store</code> type data store contents
- */
- @Deprecated
- public OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName,
- org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType store) {
- return getBridge(connectionInfo, bridgeName, store.toMdsal());
- }
-
/**
* Extract the <code>store</code> type data store contents for the particular bridge identified by
* <code>bridgeName</code>.
return getBridge(connectionInfo, bridgeName, LogicalDatastoreType.OPERATIONAL);
}
- /**
- * Extract the node contents from <code>store</code> type data store for the
- * bridge identified by <code>bridgeName</code>.
- *
- * @param connectionInfo address for the node
- * @param bridgeName name of the bridge
- * @param store defined by the <code>LogicalDatastoreType</code> enumeration
- * @return <code>store</code> type data store contents
- */
- @Deprecated
- public Node getBridgeNode(ConnectionInfo connectionInfo, String bridgeName,
- org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType store) {
- return getBridgeNode(connectionInfo, bridgeName, store.toMdsal());
- }
-
/**
* Extract the node contents from <code>store</code> type data store for the
* bridge identified by <code>bridgeName</code>.