<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>5.0.9</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<dependencyManagement>
<dependencies>
- <!--<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>mdsal-artifacts</artifactId>
- <version>1.11.0</version>
- <type>pom</type>
- <scope>import</scope>
- </dependency>-->
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
<type>pom</type>
<scope>import</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.aaa</groupId>
+ <artifactId>aaa-artifacts</artifactId>
+ <version>0.12.0-SNAPSHOT</version>
+ <type>pom</type>
+ <scope>import</scope>
+ </dependency>
</dependencies>
</dependencyManagement>
<parent>
<groupId>org.opendaylight.controller</groupId>
<artifactId>mdsal-it-parent</artifactId>
- <version>1.11.0</version>
+ <version>2.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>5.0.9</version>
+ <version>6.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>5.0.9</version>
+ <version>6.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<name>ODL :: ovsdb :: ${project.artifactId}</name>
<dependencies>
- <!--<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>odl-mdsal-broker</artifactId>
- <version>1.11.0</version>
+ <dependency>
+ <groupId>org.opendaylight.serviceutils</groupId>
+ <artifactId>odl-serviceutils-tools</artifactId>
+ <version>0.6.0-SNAPSHOT</version>
<type>xml</type>
<classifier>features</classifier>
- </dependency>-->
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>odl-ovsdb-hwvtepsouthbound-api</artifactId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.ovsdb</groupId>
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
<scope>test</scope>
</dependency>
<dependency>
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.hwvtepsouthbound;
import com.google.common.collect.Sets;
-
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
-
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
-
import org.opendaylight.ovsdb.hwvtepsouthbound.transact.DependencyQueue;
import org.opendaylight.ovsdb.hwvtepsouthbound.transact.DependentJob;
import org.opendaylight.ovsdb.hwvtepsouthbound.transact.TransactCommand;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
-
import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
if (!hwvtepTp.get().isPresent()) {
TopologyBuilder tpb = new TopologyBuilder();
tpb.setTopologyId(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID);
- transaction.put(type, path, tpb.build(), true);
+ transaction.mergeParentStructurePut(type, path, tpb.build());
transaction.commit();
} else {
transaction.cancel();
package org.opendaylight.ovsdb.hwvtepsouthbound;
import java.util.Map;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.hwvtepsouthbound;
import 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.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
-
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
return list == null || list.isEmpty();
}
- public static boolean isEmptyMap(Map map) {
+ public static boolean isEmptyMap(Map<?, ?> map) {
return map == null || map.isEmpty();
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.hwvtepsouthbound;
import java.net.URI;
import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
public class InstanceIdentifierCodec extends AbstractModuleStringInstanceIdentifierCodec
- implements SchemaContextListener {
+ implements EffectiveModelContextListener {
private DataSchemaContextTree dataSchemaContextTree;
- private SchemaContext context;
+ private EffectiveModelContext context;
private final BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer;
- public InstanceIdentifierCodec(DOMSchemaService schemaService,
- BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer) {
+ public InstanceIdentifierCodec(final DOMSchemaService schemaService,
+ final BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer) {
schemaService.registerSchemaContextListener(this);
this.bindingNormalizedNodeSerializer = bindingNormalizedNodeSerializer;
}
}
@Override
- public void onGlobalContextUpdated(SchemaContext schemaContext) {
+ public void onModelContextUpdated(final EffectiveModelContext schemaContext) {
this.context = schemaContext;
this.dataSchemaContextTree = DataSchemaContextTree.from(schemaContext);
}
- public String serialize(InstanceIdentifier<?> iid) {
+ public String serialize(final InstanceIdentifier<?> iid) {
YangInstanceIdentifier normalizedIid = bindingNormalizedNodeSerializer.toYangInstanceIdentifier(iid);
return serialize(normalizedIid);
}
- public YangInstanceIdentifier getYangInstanceIdentifier(InstanceIdentifier<?> iid) {
+ public YangInstanceIdentifier getYangInstanceIdentifier(final InstanceIdentifier<?> iid) {
return bindingNormalizedNodeSerializer.toYangInstanceIdentifier(iid);
}
- public InstanceIdentifier<?> bindingDeserializer(String iidString) throws DeserializationException {
+ public InstanceIdentifier<?> bindingDeserializer(final String iidString) throws DeserializationException {
YangInstanceIdentifier normalizedYangIid = deserialize(iidString);
return bindingNormalizedNodeSerializer.fromYangInstanceIdentifier(normalizedYangIid);
}
- public InstanceIdentifier<?> bindingDeserializer(YangInstanceIdentifier yangIID) {
+ public InstanceIdentifier<?> bindingDeserializer(final YangInstanceIdentifier yangIID) {
return bindingNormalizedNodeSerializer.fromYangInstanceIdentifier(yangIID);
}
}
import java.io.PrintStream;
import java.util.Map;
-
import org.apache.karaf.shell.api.action.Action;
import org.apache.karaf.shell.api.action.Argument;
import org.apache.karaf.shell.api.action.Command;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
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;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalMcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitchesKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private GlobalConfigOperationalChangeGetter() {
}
- public static DataTreeModification<Node> getModification(InstanceIdentifier<Node> nodeId, Node configNode,
- Node opNode) {
+ public static DataTreeModification<Node> getModification(final InstanceIdentifier<Node> nodeId,
+ final Node configNode, final Node opNode) {
NodeBuilder newNodeBuilder = getNodeBuilderFromNode(configNode);
NodeBuilder oldNodeBuilder = getNodeBuilderFromNode(opNode);
return new DataTreeModificationImpl<>(nodeId, newNodeBuilder.build(), oldNodeBuilder.build());
}
- static void fillLocalMacsToBeRemoved(HwvtepGlobalAugmentationBuilder oldAugmentation, Node configNode,
- Node opNode) {
+ static void fillLocalMacsToBeRemoved(final HwvtepGlobalAugmentationBuilder oldAugmentation, final Node configNode,
+ final Node opNode) {
Set<String> logicalSwitchNamesToBeRemoved = getLogicalSwitchesToBeRemoved(configNode, opNode);
List<LocalUcastMacs> localUcastMacsToBeRemoved = getLocalUcastMacsToBeRemoved(opNode,
logicalSwitchNamesToBeRemoved);
oldAugmentation.setLocalMcastMacs(localMcastMacsToBeRemoved);
}
- static List<LocalUcastMacs> getLocalUcastMacsToBeRemoved(Node opNode, final Set<String> removedSwitchNames) {
+ static List<LocalUcastMacs> getLocalUcastMacsToBeRemoved(final Node opNode, final Set<String> removedSwitchNames) {
if (opNode == null || opNode.augmentation(HwvtepGlobalAugmentation.class) == null) {
return null;
}
- List<LocalUcastMacs> localUcastMacs = opNode.augmentation(HwvtepGlobalAugmentation.class)
+ Map<LocalUcastMacsKey, LocalUcastMacs> localUcastMacs = opNode.augmentation(HwvtepGlobalAugmentation.class)
.getLocalUcastMacs();
if (localUcastMacs == null) {
return null;
}
- return localUcastMacs.stream()
+ return localUcastMacs.values().stream()
.filter(mac -> removedSwitchNames.contains(
mac.getLogicalSwitchRef().getValue().firstKeyOf(
LogicalSwitches.class).getHwvtepNodeName().getValue()))
.collect(Collectors.toList());
}
- static List<LocalMcastMacs> getLocalMcastMacsToBeRemoved(Node opNode, final Set<String> removedSwitchNames) {
+ static List<LocalMcastMacs> getLocalMcastMacsToBeRemoved(final Node opNode, final Set<String> removedSwitchNames) {
if (opNode == null || opNode.augmentation(HwvtepGlobalAugmentation.class) == null) {
return null;
}
- List<LocalMcastMacs> localMcastMacs = opNode.augmentation(HwvtepGlobalAugmentation.class)
+ Map<LocalMcastMacsKey, LocalMcastMacs> localMcastMacs = opNode.augmentation(HwvtepGlobalAugmentation.class)
.getLocalMcastMacs();
if (localMcastMacs == null) {
return null;
}
- return localMcastMacs.stream()
+ return localMcastMacs.values().stream()
.filter(mac -> removedSwitchNames.contains(
mac.getLogicalSwitchRef().getValue().firstKeyOf(
LogicalSwitches.class).getHwvtepNodeName().getValue()))
.collect(Collectors.toList());
}
- static Set<String> getLogicalSwitchesToBeRemoved(Node configNode, Node opNode) {
+ static Set<String> getLogicalSwitchesToBeRemoved(final Node configNode, final Node opNode) {
Set<String> opSwitchNames = new HashSet<>();
Set<String> cfgSwitchNames = new HashSet<>();
- List<LogicalSwitches> cfgLogicalSwitches = new ArrayList<>();
- List<LogicalSwitches> opLogicalSwitches = new ArrayList<>();
+ Map<LogicalSwitchesKey, LogicalSwitches> cfgLogicalSwitches = null;
+ Map<LogicalSwitchesKey, LogicalSwitches> opLogicalSwitches = null;
if (opNode != null && opNode.augmentation(HwvtepGlobalAugmentation.class) != null) {
opLogicalSwitches = opNode.augmentation(HwvtepGlobalAugmentation.class).getLogicalSwitches();
cfgLogicalSwitches = configNode.augmentation(HwvtepGlobalAugmentation.class).getLogicalSwitches();
}
if (opLogicalSwitches != null) {
- for (LogicalSwitches ls : opLogicalSwitches) {
+ for (LogicalSwitches ls : opLogicalSwitches.values()) {
opSwitchNames.add(ls.getHwvtepNodeName().getValue());
}
}
if (cfgLogicalSwitches != null) {
- for (LogicalSwitches ls : cfgLogicalSwitches) {
+ for (LogicalSwitches ls : cfgLogicalSwitches.values()) {
cfgSwitchNames.add(ls.getHwvtepNodeName().getValue());
}
}
return removedSwitchNames;
}
- static HwvtepGlobalAugmentationBuilder augmentationFromNode(Node node) {
+ static HwvtepGlobalAugmentationBuilder augmentationFromNode(final Node node) {
if (node == null) {
return new HwvtepGlobalAugmentationBuilder();
}
return builder;
}
- static NodeBuilder getNodeBuilderFromNode(Node node) {
+ static NodeBuilder getNodeBuilderFromNode(final Node node) {
NodeBuilder newNodeBuilder;
if (node != null) {
newNodeBuilder = new NodeBuilder(node);
import java.util.ArrayList;
import java.util.Collection;
+import java.util.Map;
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.hwvtepsouthbound.transact.TransactCommandAggregator;
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 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitchesKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
if (globalConfigNode != null) {
HwvtepGlobalAugmentation augmentation = globalConfigNode.augmentation(HwvtepGlobalAugmentation.class);
if (augmentation != null) {
- if (augmentation.getLogicalSwitches() != null) {
- for (LogicalSwitches logicalSwitches : augmentation.getLogicalSwitches()) {
+ Map<LogicalSwitchesKey, LogicalSwitches> switches = augmentation.getLogicalSwitches();
+ if (switches != null) {
+ for (LogicalSwitches logicalSwitches : switches.values()) {
connectionInstance.getDeviceInfo().updateConfigData(LogicalSwitches.class,
nodeId.augmentation(HwvtepGlobalAugmentation.class).child(LogicalSwitches.class,
logicalSwitches.key()), logicalSwitches);
return 0;
}
- private Node readNode(ReadTransaction transaction,
- LogicalDatastoreType logicalDatastoreType, InstanceIdentifier<Node> iid) {
+ private static Node readNode(ReadTransaction transaction,
+ LogicalDatastoreType logicalDatastoreType, InstanceIdentifier<Node> iid) {
Optional<Node> optional = HwvtepSouthboundUtil.readNode(transaction, logicalDatastoreType, iid);
if (optional.isPresent()) {
return optional.get();
*/
package org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation.configuration;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
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.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public final class SwitchConfigOperationalChangeGetter {
private SwitchConfigOperationalChangeGetter() {
}
- public static DataTreeModification<Node> getModification(InstanceIdentifier<Node> psNodeId,
- Node configNode, Node operationalNode) {
+ public static DataTreeModification<Node> getModification(final InstanceIdentifier<Node> psNodeId,
+ final Node configNode, final Node operationalNode) {
NodeBuilder newNodeBuilder = getNodeBuilderFromNode(configNode);
NodeBuilder oldNodeBuilder = getNodeBuilderFromNode(operationalNode);
- List<TerminationPoint> tpList = getPorts(configNode);
+ Map<TerminationPointKey, TerminationPoint> tpList = getPorts(configNode);
if (tpList.size() > 0) {
newNodeBuilder.setTerminationPoint(tpList);
}
}
return new DataTreeModificationImpl<>(psNodeId, newNodeBuilder.build(), oldNodeBuilder.build());
-
}
-
- static NodeBuilder getNodeBuilderFromNode(Node node) {
+ static NodeBuilder getNodeBuilderFromNode(final Node node) {
NodeBuilder newNodeBuilder;
if (node != null) {
newNodeBuilder = new NodeBuilder(node);
} else {
newNodeBuilder = new NodeBuilder();
}
- List<TerminationPoint> emptyList = new ArrayList<>();
- newNodeBuilder.setTerminationPoint(emptyList);
+ newNodeBuilder.setTerminationPoint(Collections.emptyMap());
return newNodeBuilder;
}
-
- static List<TerminationPoint> getPorts(Node node) {
- ArrayList<TerminationPoint> tpList = new ArrayList<>();
- if (node == null || node.getTerminationPoint() == null) {
- return tpList;
+ static Map<TerminationPointKey, TerminationPoint> getPorts(final Node node) {
+ if (node == null) {
+ return Collections.emptyMap();
}
- for (TerminationPoint tp: node.getTerminationPoint()) {
+ final Map<TerminationPointKey, TerminationPoint> tps = node.getTerminationPoint();
+ if (tps == null) {
+ return Collections.emptyMap();
+ }
+
+ final Map<TerminationPointKey, TerminationPoint> result = new HashMap<>();
+ for (TerminationPoint tp : node.getTerminationPoint().values()) {
TerminationPointBuilder terminationPointBuilder = new TerminationPointBuilder(tp);
terminationPointBuilder.removeAugmentation(HwvtepPhysicalPortAugmentation.class);
&& !augmentation.getVlanBindings().isEmpty()) {
builder.setVlanBindings(augmentation.getVlanBindings());
terminationPointBuilder.addAugmentation(HwvtepPhysicalPortAugmentation.class, builder.build());
- tpList.add(terminationPointBuilder.build());
+
+ final TerminationPoint newTp = terminationPointBuilder.build();
+ result.put(newTp.key(), newTp);
}
}
- return tpList;
+ return result;
}
}
* 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 com.google.common.collect.Lists;
-
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
-
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.Identifiable;
+import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public abstract class AbstractTransactCommand<T extends Identifiable, A extends Augmentation<Node>>
- implements TransactCommand<T> {
+public abstract class AbstractTransactCommand<T extends Identifiable<I>, I extends Identifier<T>,
+ A extends Augmentation<Node>> implements TransactCommand<T> {
private static final Logger LOG = LoggerFactory.getLogger(AbstractTransactCommand.class);
protected static final UUID TXUUID = new UUID("TXUUID");
// NO OP
}
- public AbstractTransactCommand(HwvtepOperationalState state, Collection<DataTreeModification<Node>> changes) {
+ public AbstractTransactCommand(final HwvtepOperationalState state,
+ final Collection<DataTreeModification<Node>> changes) {
this.hwvtepOperationalState = state;
this.changes = changes;
}
return changes;
}
- void updateCurrentTxDeleteData(Class<? extends Identifiable> cls, InstanceIdentifier key, T data) {
+ void updateCurrentTxDeleteData(final Class<? extends Identifiable> cls, final InstanceIdentifier key,
+ final T data) {
hwvtepOperationalState.updateCurrentTxDeleteData(cls, key);
markKeyAsInTransit(cls, key);
addToUpdates(key, data);
}
- void updateCurrentTxData(Class<? extends Identifiable> cls, InstanceIdentifier key, UUID uuid, T data) {
+ void updateCurrentTxData(final Class<? extends Identifiable> cls, final InstanceIdentifier key, final UUID uuid,
+ final T data) {
hwvtepOperationalState.updateCurrentTxData(cls, key, uuid);
markKeyAsInTransit(cls, key);
addToUpdates(key, data);
}
- void addToUpdates(InstanceIdentifier key, T data) {
+ void addToUpdates(final InstanceIdentifier key, final T data) {
T oldData = null;
Type type = getClass().getGenericSuperclass();
Type classType = ((ParameterizedType) type).getActualTypeArguments()[0];
if (getConfigData((Class<? extends Identifiable>) classType, key) != null) {
oldData = (T) getConfigData((Class<? extends Identifiable>) classType, key).getData();
}
- updates.add(new MdsalUpdate<T>(key, data, oldData));
+ updates.add(new MdsalUpdate<>(key, data, oldData));
}
void processDependencies(final UnMetDependencyGetter<T> unMetDependencyGetter,
if (isDeleteCmd()) {
if (deviceInfo.isKeyInTransit((Class<? extends Identifiable>) classType, key)) {
inTransitDependencies = new HashMap<>();
- inTransitDependencies.put((Class<? extends Identifiable>) classType, Lists.newArrayList(key));
+ inTransitDependencies.put(classType, Lists.newArrayList(key));
}
} else {
inTransitDependencies = unMetDependencyGetter.getInTransitDependencies(hwvtepOperationalState, data);
//If this key itself is in transit wait for the response of this key itself
if (deviceInfo.isKeyInTransit((Class<? extends Identifiable>) classType, key)
|| deviceInfo.isKeyInDependencyQueue(key)) {
- inTransitDependencies.put((Class<? extends Identifiable>) classType, Lists.newArrayList(key));
+ inTransitDependencies.put(classType, Lists.newArrayList(key));
}
}
LOG.info("Update received for key: {} txId: {}", key, getOperationalState().getTransactionId());
AbstractTransactCommand clone = getClone();
@Override
- public void onDependencyResolved(HwvtepOperationalState operationalState,
- TransactionBuilder transactionBuilder) {
+ public void onDependencyResolved(final HwvtepOperationalState operationalState,
+ final TransactionBuilder transactionBuilder) {
clone.hwvtepOperationalState = operationalState;
HwvtepDeviceInfo.DeviceData deviceData =
getDeviceInfo().getConfigData((Class<? extends Identifiable>)getClassType(), key);
AbstractTransactCommand clone = getClone();
@Override
- public void onDependencyResolved(HwvtepOperationalState operationalState,
- TransactionBuilder transactionBuilder) {
+ public void onDependencyResolved(final HwvtepOperationalState operationalState,
+ final TransactionBuilder transactionBuilder) {
clone.hwvtepOperationalState = operationalState;
HwvtepDeviceInfo.DeviceData deviceData = getDeviceInfo()
.getConfigData((Class<? extends Identifiable>)getClassType(), key);
}
@Override
- public void doDeviceTransaction(TransactionBuilder transaction, InstanceIdentifier<Node> nodeIid, T data,
- InstanceIdentifier key, Object... extraData) {
+ public void doDeviceTransaction(final TransactionBuilder transaction, final InstanceIdentifier<Node> nodeIid,
+ final T data, final InstanceIdentifier key, final Object... extraData) {
//tobe removed as part of refactoring patch
}
@Override
- public void onConfigUpdate(TransactionBuilder transaction, InstanceIdentifier<Node> nodeIid, T data,
- InstanceIdentifier key, Object... extraData) {
+ public void onConfigUpdate(final TransactionBuilder transaction, final InstanceIdentifier<Node> nodeIid,
+ final T data, final InstanceIdentifier key, final Object... extraData) {
//tobe removed as part of refactoring patch
}
- protected A augmentation(Node node) {
+ protected A augmentation(final Node node) {
if (node == null) {
return null;
}
return (A) augmentation;
}
- protected List<T> getData(A augmentation) {
- return Collections.emptyList();
+ protected Map<I, T> getData(final A augmentation) {
+ return Collections.emptyMap();
}
- protected List<T> getData(Node node) {
+ protected List<T> getData(final Node node) {
A augmentation = augmentation(node);
if (augmentation != null) {
- List<T> data = getData(augmentation);
+ Map<I, T> data = getData(augmentation);
if (data != null) {
- return new ArrayList<>(data);
+ // TODO: why are we performing a copy here?
+ return new ArrayList<>(data.values());
}
}
return Collections.emptyList();
@NonNull
protected Map<InstanceIdentifier<Node>, List<T>> extractRemoved(
- Collection<DataTreeModification<Node>> modification, Class<T> class1) {
+ final Collection<DataTreeModification<Node>> modification, final Class<T> class1) {
Map<InstanceIdentifier<Node>, List<T>> result = new HashMap<>();
if (modification != null && !modification.isEmpty()) {
for (DataTreeModification<Node> change : modification) {
@NonNull
protected Map<InstanceIdentifier<Node>, List<T>> extractUpdated(
- Collection<DataTreeModification<Node>> modification, Class<T> class1) {
+ final Collection<DataTreeModification<Node>> modification, final Class<T> class1) {
Map<InstanceIdentifier<Node>, List<T>> result = new HashMap<>();
if (modification != null && !modification.isEmpty()) {
for (DataTreeModification<Node> change : modification) {
return result;
}
- List<T> getCascadeDeleteData(DataTreeModification<Node> change) {
+ List<T> getCascadeDeleteData(final DataTreeModification<Node> change) {
if (!cascadeDelete()) {
return Collections.emptyList();
}
return Collections.emptyList();
}
- List<T> getRemoved(DataTreeModification<Node> change) {
+ List<T> getRemoved(final DataTreeModification<Node> change) {
DataObjectModification<Node> mod = change.getRootNode();
Node removed = TransactUtils.getRemoved(mod);
return diffOf(removed, before, updated, true);
}
- List<T> getUpdated(DataTreeModification<Node> change) {
+ List<T> getUpdated(final DataTreeModification<Node> change) {
DataObjectModification<Node> mod = change.getRootNode();
Node updated = TransactUtils.getUpdated(mod);
Node before = mod.getDataBefore();
return diffOf(updated, before, false);
}
- List<T> diffOf(Node include, Node node1, Node node2, boolean compareKeyOnly) {
+ List<T> diffOf(final Node include, final Node node1, final Node node2, final boolean compareKeyOnly) {
List<T> data1 = getData(include);
List<T> data2 = diffOf(node1, node2, compareKeyOnly);
if (HwvtepSouthboundUtil.isEmpty(data1) && HwvtepSouthboundUtil.isEmpty(data2)) {
return result;
}
- List<T> diffOf(Node node1, Node node2, boolean compareKeyOnly) {
+ List<T> diffOf(final Node node1, final Node node2, final boolean compareKeyOnly) {
List<T> result = new ArrayList<>();
List<T> list1 = getData(node1);
return classType;
}
- protected boolean areEqual(T obj1, T obj2) {
+ protected boolean areEqual(final T obj1, final T obj2) {
return obj1.key().equals(obj2.key());
}
}
@Override
- public void onSuccess(TransactionBuilder deviceTx) {
+ public void onSuccess(final TransactionBuilder deviceTx) {
onCommandSucceeded();
}
@Override
- public void onFailure(TransactionBuilder deviceTx) {
+ public void onFailure(final TransactionBuilder deviceTx) {
onCommandFailed();
}
protected void onCommandFailed() {
}
- void updateControllerTxHistory(TransactionType transactionType, Object element) {
+ void updateControllerTxHistory(final TransactionType transactionType, final Object element) {
getOperationalState().getDeviceInfo().addToControllerTx(transactionType, element);
}
- public <T> HwvtepDeviceInfo.DeviceData fetchDeviceData(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public <T> HwvtepDeviceInfo.DeviceData fetchDeviceData(final Class<? extends Identifiable> cls,
+ final InstanceIdentifier key) {
HwvtepDeviceInfo.DeviceData deviceData = getDeviceOpData(cls, key);
if (deviceData == null) {
LOG.debug("Could not find data for key {}", key);
getTableReader().getHwvtepTableEntryUUID(cls, key, null);
if (optional.isPresent()) {
LOG.debug("Found the data for key from device {} ", key);
- getDeviceInfo().updateDeviceOperData(cls, key, optional.get().getUuid(), (T)optional.get());
+ getDeviceInfo().updateDeviceOperData(cls, key, optional.get().getUuid(), optional.get());
return getDeviceOpData(cls, key);
} else {
LOG.info("Could not Find the data for key from device {} ", key);
return deviceData;
}
- protected String getKeyStr(InstanceIdentifier iid) {
+ protected String getKeyStr(final InstanceIdentifier iid) {
return iid.toString();
}
- public <K extends Identifiable> void addJobToQueue(DependentJob<K> job) {
+ public <K extends Identifiable> void addJobToQueue(final DependentJob<K> job) {
hwvtepOperationalState.getDeviceInfo().putKeyInDependencyQueue(job.getKey());
hwvtepOperationalState.getDeviceInfo().addJobToQueue(job);
}
- public void markKeyAsInTransit(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public void markKeyAsInTransit(final Class<? extends Identifiable> cls, final InstanceIdentifier key) {
hwvtepOperationalState.getDeviceInfo().markKeyAsInTransit(cls, key);
}
- public HwvtepDeviceInfo.DeviceData getDeviceOpData(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public HwvtepDeviceInfo.DeviceData getDeviceOpData(final Class<? extends Identifiable> cls,
+ final InstanceIdentifier key) {
return getOperationalState().getDeviceInfo().getDeviceOperData(cls, key);
}
- public void clearConfigData(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public void clearConfigData(final Class<? extends Identifiable> cls, final InstanceIdentifier key) {
hwvtepOperationalState.getDeviceInfo().clearConfigData(cls, key);
}
- public HwvtepDeviceInfo.DeviceData getConfigData(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public HwvtepDeviceInfo.DeviceData getConfigData(final Class<? extends Identifiable> cls,
+ final InstanceIdentifier key) {
return hwvtepOperationalState.getDeviceInfo().getConfigData(cls, key);
}
- public void updateConfigData(Class<? extends Identifiable> cls, InstanceIdentifier key, Object data) {
+ public void updateConfigData(final Class<? extends Identifiable> cls, final InstanceIdentifier key,
+ final Object data) {
hwvtepOperationalState.getDeviceInfo().updateConfigData(cls, key, data);
}
@SuppressWarnings("checkstyle:IllegalCatch")
public AbstractTransactCommand getClone() {
try {
- return (AbstractTransactCommand) getClass().getConstructor(HwvtepOperationalState.class, Collection.class)
+ return getClass().getConstructor(HwvtepOperationalState.class, Collection.class)
.newInstance(hwvtepOperationalState, changes);
} catch (Throwable e) {
LOG.error("Failed to clone the cmd ", e);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.hwvtepsouthbound.transact;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
-
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
* 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.Collections;
import java.util.List;
-
import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
private final Collection<DataTreeModification<Node>> changes;
long transactionId = 0;
- public HwvtepOperationalState(DataBroker db, HwvtepConnectionInstance connectionInstance,
- Collection<DataTreeModification<Node>> changes) {
+ public HwvtepOperationalState(final DataBroker db, final HwvtepConnectionInstance connectionInstance,
+ final Collection<DataTreeModification<Node>> changes) {
this.connectionInstance = connectionInstance;
this.deviceInfo = connectionInstance.getDeviceInfo();
this.db = db;
this.transaction = db.newReadWriteTransaction();
}
- public HwvtepOperationalState(HwvtepConnectionInstance connectionInstance) {
+ public HwvtepOperationalState(final HwvtepConnectionInstance connectionInstance) {
this.connectionInstance = connectionInstance;
this.deviceInfo = connectionInstance.getDeviceInfo();
this.db = connectionInstance.getDataBroker();
operationalNodes.put(connectionInstance.getInstanceIdentifier(), globalOperNode);
HwvtepGlobalAugmentation globalAugmentation = globalOperNode.augmentation(HwvtepGlobalAugmentation.class);
if (globalAugmentation != null) {
- if (!HwvtepSouthboundUtil.isEmpty(globalAugmentation.getSwitches())) {
+ if (!HwvtepSouthboundUtil.isEmptyMap(globalAugmentation.getSwitches())) {
operationalNodes.put((InstanceIdentifier<Node>)
- globalAugmentation.getSwitches().get(0).getSwitchRef().getValue(), psNode);
+ globalAugmentation.getSwitches().values().iterator().next().getSwitchRef().getValue(), psNode);
}
}
}
PhysicalSwitchAugmentation psAugmentation =
readNode.get().augmentation(PhysicalSwitchAugmentation.class);
if (hgAugmentation != null && hgAugmentation.getSwitches() != null) {
- for (Switches pswitch : hgAugmentation.getSwitches()) {
+ for (Switches pswitch : hgAugmentation.getSwitches().values()) {
@SuppressWarnings("unchecked")
InstanceIdentifier<Node> psNodeIid =
(InstanceIdentifier<Node>) pswitch.getSwitchRef().getValue();
}
}
- public Optional<Node> getGlobalNode(InstanceIdentifier<?> iid) {
+ public Optional<Node> getGlobalNode(final InstanceIdentifier<?> iid) {
InstanceIdentifier<Node> nodeIid = iid.firstIdentifierOf(Node.class);
return Optional.ofNullable(operationalNodes.get(nodeIid));
}
- public Optional<HwvtepGlobalAugmentation> getHwvtepGlobalAugmentation(InstanceIdentifier<?> iid) {
+ public Optional<HwvtepGlobalAugmentation> getHwvtepGlobalAugmentation(final InstanceIdentifier<?> iid) {
Preconditions.checkNotNull(iid);
Optional<Node> nodeOptional = getGlobalNode(iid);
if (nodeOptional.isPresent()) {
return Optional.empty();
}
- public Optional<PhysicalSwitchAugmentation> getPhysicalSwitchAugmentation(InstanceIdentifier<?> iid) {
+ public Optional<PhysicalSwitchAugmentation> getPhysicalSwitchAugmentation(final InstanceIdentifier<?> iid) {
Preconditions.checkNotNull(iid);
Optional<Node> nodeOptional = getGlobalNode(iid);
if (nodeOptional.isPresent()) {
return Optional.empty();
}
- public Optional<List<TerminationPoint>> getTerminationPointList(InstanceIdentifier<?> iid) {
+ public Optional<Map<TerminationPointKey, TerminationPoint>> getTerminationPointList(
+ final InstanceIdentifier<?> iid) {
Preconditions.checkNotNull(iid);
Optional<Node> nodeOptional = getGlobalNode(iid);
if (nodeOptional.isPresent() && nodeOptional.get().getTerminationPoint() != null) {
return Optional.empty();
}
- public Optional<LogicalSwitches> getLogicalSwitches(InstanceIdentifier<?> iid,
- LogicalSwitchesKey logicalSwitchesKey) {
+ public Optional<LogicalSwitches> getLogicalSwitches(final InstanceIdentifier<?> iid,
+ final LogicalSwitchesKey logicalSwitchesKey) {
Preconditions.checkNotNull(iid);
Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
if (nodeOptional.isPresent()) {
- HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
- List<LogicalSwitches> lswitchList = null;
- if (hgAugmentation != null) {
- lswitchList = hgAugmentation.getLogicalSwitches();
- }
- if (lswitchList != null) {
- for (LogicalSwitches lswitch: lswitchList) {
- if (lswitch.key().equals(logicalSwitchesKey)) {
- return Optional.ofNullable(lswitch);
- }
- }
+ LogicalSwitches lswitch = nodeOptional.get().nonnullLogicalSwitches().get(logicalSwitchesKey);
+ if (lswitch != null) {
+ return Optional.of(lswitch);
}
}
return Optional.empty();
}
- public Optional<LogicalSwitches> getLogicalSwitches(InstanceIdentifier<LogicalSwitches> iid) {
+ public Optional<LogicalSwitches> getLogicalSwitches(final InstanceIdentifier<LogicalSwitches> iid) {
return new ControllerMdsalUtils(db).readOptional(LogicalDatastoreType.OPERATIONAL, iid);
}
- public Optional<Tunnels> getTunnels(InstanceIdentifier<?> iid, TunnelsKey tunnelsKey) {
+ public Optional<Tunnels> getTunnels(final InstanceIdentifier<?> iid, final TunnelsKey tunnelsKey) {
Preconditions.checkNotNull(iid);
Optional<PhysicalSwitchAugmentation> psOptional = getPhysicalSwitchAugmentation(iid);
if (psOptional.isPresent()) {
- PhysicalSwitchAugmentation psAugmentation = psOptional.get();
- List<Tunnels> tunnelList = null;
- if (psAugmentation != null) {
- tunnelList = psAugmentation.getTunnels();
- }
- if (tunnelList != null) {
- for (Tunnels tunnel: tunnelList) {
- if (tunnel.key().equals(tunnelsKey)) {
- return Optional.ofNullable(tunnel);
- }
- }
+ Tunnels tunnel = psOptional.get().nonnullTunnels().get(tunnelsKey);
+ if (tunnel != null) {
+ return Optional.of(tunnel);
}
}
return Optional.empty();
}
- public Optional<Tunnels> getTunnels(InstanceIdentifier<Tunnels> iid) {
+ public Optional<Tunnels> getTunnels(final InstanceIdentifier<Tunnels> iid) {
Optional<Tunnels> tunnels = new ControllerMdsalUtils(db).readOptional(LogicalDatastoreType.OPERATIONAL, iid);
return tunnels;
}
- public Optional<HwvtepPhysicalPortAugmentation> getPhysicalPortAugmentation(InstanceIdentifier<?> iid,
- HwvtepNodeName hwvtepNodeName) {
+ public Optional<HwvtepPhysicalPortAugmentation> getPhysicalPortAugmentation(final InstanceIdentifier<?> iid,
+ final HwvtepNodeName hwvtepNodeName) {
Preconditions.checkNotNull(iid);
- Optional<List<TerminationPoint>> nodeOptional = getTerminationPointList(iid);
+ Optional<Map<TerminationPointKey, TerminationPoint>> nodeOptional = getTerminationPointList(iid);
if (nodeOptional.isPresent()) {
- List<TerminationPoint> tpList = nodeOptional.get();
- for (TerminationPoint tp : tpList) {
+ for (TerminationPoint tp : nodeOptional.get().values()) {
HwvtepPhysicalPortAugmentation hppAugmentation =
tp.augmentation(HwvtepPhysicalPortAugmentation.class);
if (hppAugmentation != null && hppAugmentation.getHwvtepNodeName().equals(hwvtepNodeName)) {
return Optional.empty();
}
- public Optional<HwvtepPhysicalLocatorAugmentation> getPhysicalLocatorAugmentation(InstanceIdentifier<?> iid,
- IpAddress dstIp, Class<? extends EncapsulationTypeBase> encapType) {
+ public Optional<HwvtepPhysicalLocatorAugmentation> getPhysicalLocatorAugmentation(final InstanceIdentifier<?> iid,
+ final IpAddress dstIp, final Class<? extends EncapsulationTypeBase> encapType) {
Preconditions.checkNotNull(iid);
- Optional<List<TerminationPoint>> nodeOptional = getTerminationPointList(iid);
+ Optional<Map<TerminationPointKey, TerminationPoint>> nodeOptional = getTerminationPointList(iid);
if (nodeOptional.isPresent()) {
- List<TerminationPoint> tpList = nodeOptional.get();
- for (TerminationPoint tp : tpList) {
+ for (TerminationPoint tp : nodeOptional.get().values()) {
HwvtepPhysicalLocatorAugmentation hppAugmentation =
tp.augmentation(HwvtepPhysicalLocatorAugmentation.class);
if (hppAugmentation != null && hppAugmentation.getDstIp().equals(dstIp)
}
public Optional<HwvtepPhysicalLocatorAugmentation>
- getPhysicalLocatorAugmentation(InstanceIdentifier<TerminationPoint> iid) {
+ getPhysicalLocatorAugmentation(final InstanceIdentifier<TerminationPoint> iid) {
Optional<TerminationPoint> tp =
new ControllerMdsalUtils(db).readOptional(LogicalDatastoreType.OPERATIONAL, iid);
if (tp.isPresent()) {
return Optional.empty();
}
- public Optional<LocalMcastMacs> getLocalMcastMacs(InstanceIdentifier<?> iid, LocalMcastMacsKey key) {
+ public Optional<LocalMcastMacs> getLocalMcastMacs(final InstanceIdentifier<?> iid, final LocalMcastMacsKey key) {
Preconditions.checkNotNull(iid);
Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
if (nodeOptional.isPresent()) {
- HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
- List<LocalMcastMacs> macList = null;
- if (hgAugmentation != null) {
- macList = hgAugmentation.getLocalMcastMacs();
- }
- if (macList != null) {
- for (LocalMcastMacs mac: macList) {
- if (mac.key().equals(key)) {
- return Optional.ofNullable(mac);
- }
- }
+ LocalMcastMacs mac = nodeOptional.get().nonnullLocalMcastMacs().get(key);
+ if (mac != null) {
+ return Optional.of(mac);
}
}
return Optional.empty();
}
- public Optional<RemoteMcastMacs> getRemoteMcastMacs(InstanceIdentifier<?> iid, RemoteMcastMacsKey key) {
+ public Optional<RemoteMcastMacs> getRemoteMcastMacs(final InstanceIdentifier<?> iid, final RemoteMcastMacsKey key) {
Preconditions.checkNotNull(iid);
Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
if (nodeOptional.isPresent()) {
- HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
- List<RemoteMcastMacs> macList = null;
- if (hgAugmentation != null) {
- macList = hgAugmentation.getRemoteMcastMacs();
- }
- if (macList != null) {
- for (RemoteMcastMacs mac: macList) {
- if (mac.key().equals(key)) {
- return Optional.ofNullable(mac);
- }
- }
+ RemoteMcastMacs mac = nodeOptional.get().nonnullRemoteMcastMacs().get(key);
+ if (mac != null) {
+ return Optional.of(mac);
}
}
return Optional.empty();
}
- public Optional<LocalUcastMacs> getLocalUcastMacs(InstanceIdentifier<?> iid, LocalUcastMacsKey key) {
+ public Optional<LocalUcastMacs> getLocalUcastMacs(final InstanceIdentifier<?> iid, final LocalUcastMacsKey key) {
Preconditions.checkNotNull(iid);
Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
if (nodeOptional.isPresent()) {
- HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
- List<LocalUcastMacs> macList = null;
- if (hgAugmentation != null) {
- macList = hgAugmentation.getLocalUcastMacs();
- }
- if (macList != null) {
- for (LocalUcastMacs mac: macList) {
- if (mac.key().equals(key)) {
- return Optional.ofNullable(mac);
- }
- }
+ LocalUcastMacs mac = nodeOptional.get().nonnullLocalUcastMacs().get(key);
+ if (mac != null) {
+ return Optional.of(mac);
}
}
return Optional.empty();
}
- public Optional<RemoteUcastMacs> getRemoteUcastMacs(InstanceIdentifier<?> iid, RemoteUcastMacsKey key) {
+ public Optional<RemoteUcastMacs> getRemoteUcastMacs(final InstanceIdentifier<?> iid, final RemoteUcastMacsKey key) {
Preconditions.checkNotNull(iid);
Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
if (nodeOptional.isPresent()) {
- HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
- List<RemoteUcastMacs> macList = null;
- if (hgAugmentation != null) {
- macList = hgAugmentation.getRemoteUcastMacs();
- }
- if (macList != null) {
- for (RemoteUcastMacs mac: macList) {
- if (mac.key().equals(key)) {
- return Optional.ofNullable(mac);
- }
- }
+ RemoteUcastMacs mac = nodeOptional.get().nonnullRemoteUcastMacs().get(key);
+ if (mac != null) {
+ return Optional.of(mac);
}
}
return Optional.empty();
Preconditions.checkNotNull(iid);
Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
if (nodeOptional.isPresent()) {
- HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
- if (hgAugmentation != null && hgAugmentation.getLogicalRouters() != null) {
- for (LogicalRouters lrouter: hgAugmentation.getLogicalRouters()) {
- if (lrouter.key().equals(logicalRoutersKey)) {
- return Optional.ofNullable(lrouter);
- }
- }
+ LogicalRouters lrouter = nodeOptional.get().nonnullLogicalRouters().get(logicalRoutersKey);
+ if (lrouter != null) {
+ return Optional.of(lrouter);
}
}
return Optional.empty();
}
- public Optional<Acls> getAcls(InstanceIdentifier<Acls> iid) {
+ public Optional<Acls> getAcls(
final InstanceIdentifier<Acls> iid) {
Optional<Acls> acl = new ControllerMdsalUtils(db).readOptional(LogicalDatastoreType.OPERATIONAL, iid);
return acl;
}
return transaction;
}
- public void setPhysicalLocatorInFlight(InstanceIdentifier<TerminationPoint> iid,
- UUID uuid) {
+ public void setPhysicalLocatorInFlight(final InstanceIdentifier<TerminationPoint> iid,
+ final UUID uuid) {
inflightLocators.put(iid, uuid);
}
- public UUID getPhysicalLocatorInFlight(InstanceIdentifier<TerminationPoint> iid) {
+ public UUID getPhysicalLocatorInFlight(final InstanceIdentifier<TerminationPoint> iid) {
return inflightLocators.get(iid);
}
return deviceInfo;
}
- public void updateCurrentTxData(Class<? extends Identifiable> cls, InstanceIdentifier key, UUID uuid) {
+ public void updateCurrentTxData(final Class<? extends Identifiable> cls, final InstanceIdentifier key,
+ final UUID uuid) {
HwvtepSouthboundUtil.updateData(currentTxUUIDs, cls, key, uuid);
}
- public void updateCurrentTxDeleteData(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public void updateCurrentTxDeleteData(final Class<? extends Identifiable> cls, final InstanceIdentifier key) {
HwvtepSouthboundUtil.updateData(currentTxDeletedKeys, cls, key, Boolean.TRUE);
}
- public UUID getUUIDFromCurrentTx(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public UUID getUUIDFromCurrentTx(final Class<? extends Identifiable> cls, final InstanceIdentifier key) {
return HwvtepSouthboundUtil.getData(currentTxUUIDs, cls, key);
}
- public boolean isKeyPartOfCurrentTx(Class<? extends Identifiable> cls, InstanceIdentifier key) {
+ public boolean isKeyPartOfCurrentTx(final Class<? extends Identifiable> cls, final InstanceIdentifier key) {
return HwvtepSouthboundUtil.containsKey(currentTxUUIDs, cls, key);
}
- public Set<InstanceIdentifier> getDeletedKeysInCurrentTx(Class<? extends Identifiable> cls) {
+ public Set<InstanceIdentifier> getDeletedKeysInCurrentTx(final Class<? extends Identifiable> cls) {
if (currentTxDeletedKeys.containsKey(cls)) {
return currentTxDeletedKeys.get(cls).keySet();
}
return inReconciliation;
}
- public void setInReconciliation(boolean inReconciliation) {
+ public void setInReconciliation(final boolean inReconciliation) {
this.inReconciliation = inReconciliation;
}
import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionType;
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.LogicalRouters;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalRoutersKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class LogicalRouterRemoveCommand extends AbstractTransactCommand<LogicalRouters, HwvtepGlobalAugmentation> {
+public class LogicalRouterRemoveCommand
+ extends AbstractTransactCommand<LogicalRouters, LogicalRoutersKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(LogicalRouterRemoveCommand.class);
public LogicalRouterRemoveCommand(final HwvtepOperationalState state,
}
@Override
- protected List<LogicalRouters> getData(final HwvtepGlobalAugmentation augmentation) {
+ protected Map<LogicalRoutersKey, LogicalRouters> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getLogicalRouters();
}
* 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 static org.opendaylight.ovsdb.lib.operations.Operations.op;
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.Acls;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalRouters;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalRoutersKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.logical.router.attributes.AclBindings;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.logical.router.attributes.AclBindingsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.logical.router.attributes.StaticRoutes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.logical.router.attributes.SwitchBindings;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
-public class LogicalRouterUpdateCommand extends AbstractTransactCommand<LogicalRouters, HwvtepGlobalAugmentation> {
+public class LogicalRouterUpdateCommand
+ extends AbstractTransactCommand<LogicalRouters, LogicalRoutersKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(LogicalRouterUpdateCommand.class);
public LogicalRouterUpdateCommand(final HwvtepOperationalState state,
}
}
- private void setAclBindings(final LogicalRouter logicalRouter, final List<AclBindings> aclBindings) {
+ private void setAclBindings(final LogicalRouter logicalRouter, final Map<AclBindingsKey, AclBindings> aclBindings) {
if (aclBindings != null) {
Map<String, UUID> bindingMap = new HashMap<>();
- for (AclBindings aclBinding : aclBindings) {
+ for (AclBindings aclBinding : aclBindings.values()) {
@SuppressWarnings("unchecked")
InstanceIdentifier<Acls> aclIid =
(InstanceIdentifier<Acls>)aclBinding.getAclRef().getValue();
}
- private void setStaticRoutes(final LogicalRouter logicalRouter, final List<StaticRoutes> staticRoutes) {
+ private static void setStaticRoutes(final LogicalRouter logicalRouter, final List<StaticRoutes> staticRoutes) {
if (staticRoutes != null) {
Map<String, String> staticRoutesMap = new HashMap<>();
for (StaticRoutes staticRoute : staticRoutes) {
}
@Override
- protected List<LogicalRouters> getData(final HwvtepGlobalAugmentation augmentation) {
+ protected Map<LogicalRoutersKey, LogicalRouters> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getLogicalRouters();
}
}
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 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitchesKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class LogicalSwitchRemoveCommand extends AbstractTransactCommand<LogicalSwitches, HwvtepGlobalAugmentation> {
+public class LogicalSwitchRemoveCommand
+ extends AbstractTransactCommand<LogicalSwitches, LogicalSwitchesKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(LogicalSwitchRemoveCommand.class);
List<LogicalSwitches> deletedLs;
}
@Override
- public void onConfigUpdate(TransactionBuilder transaction, InstanceIdentifier<Node> nodeIid,
- LogicalSwitches logicalSwitches, InstanceIdentifier lsKey, Object... extraData) {
+ public void onConfigUpdate(final TransactionBuilder transaction, final InstanceIdentifier<Node> nodeIid,
+ final LogicalSwitches logicalSwitches, final InstanceIdentifier lsKey,
+ final Object... extraData) {
processDependencies(EmptyDependencyGetter.INSTANCE, transaction, nodeIid, lsKey, logicalSwitches);
}
}
@Override
- protected List<LogicalSwitches> getData(final HwvtepGlobalAugmentation augmentation) {
+ protected Map<LogicalSwitchesKey, LogicalSwitches> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getLogicalSwitches();
}
* 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 static org.opendaylight.ovsdb.lib.operations.Operations.op;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
-
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionType;
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 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitchesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindings;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.LoggerFactory;
public class LogicalSwitchUcastsRemoveCommand
- extends AbstractTransactCommand<LogicalSwitches, HwvtepGlobalAugmentation> {
+ extends AbstractTransactCommand<LogicalSwitches, LogicalSwitchesKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(LogicalSwitchUcastsRemoveCommand.class);
+ private final AtomicInteger retryCount = new AtomicInteger(5);
+ private final LogicalSwitches logicalSwitches;
+ private final InstanceIdentifier<Node> nodeIid;
+ private final List<LogicalSwitches> deletedLs;
+
volatile Map<String, Map<Long, UUID>> updatedPortBindings = new HashMap<>();
- private AtomicInteger retryCount = new AtomicInteger(5);
- private LogicalSwitches logicalSwitches;
- private InstanceIdentifier<Node> nodeIid;
- private List<LogicalSwitches> deletedLs;
private boolean firstAttempt = true;
- public LogicalSwitchUcastsRemoveCommand(HwvtepOperationalState state,
- Collection<DataTreeModification<Node>> changes,
- List<LogicalSwitches> deletedLs,
- LogicalSwitches logicalSwitches) {
+ public LogicalSwitchUcastsRemoveCommand(final HwvtepOperationalState state,
+ final Collection<DataTreeModification<Node>> changes,
+ final List<LogicalSwitches> deletedLs,
+ final LogicalSwitches logicalSwitches) {
super(state, changes);
this.deletedLs = deletedLs;
this.logicalSwitches = logicalSwitches;
}
@Override
- public void execute(TransactionBuilder transaction) {
+ public void execute(final TransactionBuilder transaction) {
InstanceIdentifier<LogicalSwitches> lsKey = nodeIid.augmentation(HwvtepGlobalAugmentation.class)
.child(LogicalSwitches.class, logicalSwitches.key());
HwvtepDeviceInfo.DeviceData deviceData = super.<LogicalSwitch>fetchDeviceData(LogicalSwitches.class, lsKey);
}
@Override
- protected List<LogicalSwitches> getData(HwvtepGlobalAugmentation augmentation) {
+ protected Map<LogicalSwitchesKey, LogicalSwitches> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getLogicalSwitches();
}
@Override
- protected boolean areEqual(LogicalSwitches logicalSwitches1 , LogicalSwitches logicalSwitches2) {
+ protected boolean areEqual(final LogicalSwitches logicalSwitches1 , final LogicalSwitches logicalSwitches2) {
return logicalSwitches1.key().equals(logicalSwitches2.key())
&& Objects.equals(logicalSwitches1.getTunnelKey(), logicalSwitches2.getTunnelKey());
}
@Override
- public void onSuccess(TransactionBuilder tx) {
+ public void onSuccess(final TransactionBuilder tx) {
if (firstAttempt) {
//LOG.error("check succeeded in deletion of logical swtich at first attempt ");
//succeed in removing the logical switch upon first attempt
}
@Override
- public void onFailure(TransactionBuilder tx) {
+ public void onFailure(final TransactionBuilder tx) {
//Failed to remove logical swith upon first attempt,
//will attempt to remove the local ucasts and vlan bindings alone in the next attemtps
firstAttempt = false;
});
}
- private Map<Long, UUID> excludeVlanBindings(Set<UUID> deletedLsUuids, PhysicalPort port) {
+ private Map<Long, UUID> excludeVlanBindings(final Set<UUID> deletedLsUuids, final PhysicalPort port) {
return port.getVlanBindingsColumn().getData()
.entrySet().stream()
.peek(entry -> {
.collect(Collectors.toMap(entry -> entry.getKey(), entry -> entry.getValue()));
}
+ @Override
public boolean retry() {
boolean ret = retryCount.decrementAndGet() > 0;
return ret;
}
+ @Override
protected boolean isDeleteCmd() {
return true;
}
import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionType;
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 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitchesKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class LogicalSwitchUpdateCommand extends AbstractTransactCommand<LogicalSwitches, HwvtepGlobalAugmentation> {
+public class LogicalSwitchUpdateCommand
+ extends AbstractTransactCommand<LogicalSwitches, LogicalSwitchesKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(LogicalSwitchUpdateCommand.class);
public LogicalSwitchUpdateCommand(final HwvtepOperationalState state,
}
@Override
- protected List<LogicalSwitches> getData(final HwvtepGlobalAugmentation augmentation) {
+ protected Map<LogicalSwitchesKey, LogicalSwitches> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getLogicalSwitches();
}
* 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 static org.opendaylight.ovsdb.lib.operations.Operations.op;
import org.opendaylight.ovsdb.schema.hardwarevtep.McastMacsLocal;
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.LocalMcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalMcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class McastMacsLocalRemoveCommand extends AbstractTransactCommand<LocalMcastMacs, HwvtepGlobalAugmentation> {
+public class McastMacsLocalRemoveCommand
+ extends AbstractTransactCommand<LocalMcastMacs, LocalMcastMacsKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(McastMacsLocalRemoveCommand.class);
public McastMacsLocalRemoveCommand(final HwvtepOperationalState state,
}
@Override
- protected List<LocalMcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
+ protected Map<LocalMcastMacsKey, LocalMcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getLocalMcastMacs();
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.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.LocalMcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalMcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class McastMacsLocalUpdateCommand extends AbstractTransactCommand<LocalMcastMacs, HwvtepGlobalAugmentation> {
+public class McastMacsLocalUpdateCommand
+ extends AbstractTransactCommand<LocalMcastMacs, LocalMcastMacsKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(McastMacsLocalUpdateCommand.class);
public McastMacsLocalUpdateCommand(final HwvtepOperationalState state,
}
@Override
- protected List<LocalMcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
+ protected Map<LocalMcastMacsKey, LocalMcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getLocalMcastMacs();
}
}
import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionType;
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.RemoteMcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class McastMacsRemoteRemoveCommand extends AbstractTransactCommand<RemoteMcastMacs, HwvtepGlobalAugmentation> {
+public class McastMacsRemoteRemoveCommand
+ extends AbstractTransactCommand<RemoteMcastMacs, RemoteMcastMacsKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(McastMacsRemoteRemoveCommand.class);
public McastMacsRemoteRemoveCommand(final HwvtepOperationalState state,
}
@Override
- protected List<RemoteMcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
+ protected Map<RemoteMcastMacsKey, RemoteMcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getRemoteMcastMacs();
}
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;
-
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
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 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.locator.set.attributes.LocatorSet;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class McastMacsRemoteUpdateCommand extends AbstractTransactCommand<RemoteMcastMacs, HwvtepGlobalAugmentation> {
+public class McastMacsRemoteUpdateCommand
+ extends AbstractTransactCommand<RemoteMcastMacs, RemoteMcastMacsKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(McastMacsRemoteUpdateCommand.class);
private static final McastMacUnMetDependencyGetter MCAST_MAC_DATA_VALIDATOR = new McastMacUnMetDependencyGetter();
}
@Override
- protected List<RemoteMcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
+ protected Map<RemoteMcastMacsKey, RemoteMcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getRemoteMcastMacs();
}
}
@Override
- public void onSuccess(TransactionBuilder tx) {
+ public void onSuccess(final TransactionBuilder tx) {
for (MdsalUpdate mdsalUpdate : updates) {
updateLocatorRefCounts(mdsalUpdate);
RemoteMcastMacs mac = (RemoteMcastMacs) mdsalUpdate.getNewData();
Node removed = TransactUtils.getRemoved(mod);
if (removed != null) {
List<HwvtepPhysicalPortAugmentation> lswitchListRemoved = new ArrayList<>();
- if (removed.getTerminationPoint() != null) {
- for (TerminationPoint tp : removed.getTerminationPoint()) {
- HwvtepPhysicalPortAugmentation hppAugmentation =
- tp.augmentation(HwvtepPhysicalPortAugmentation.class);
- if (hppAugmentation != null) {
- lswitchListRemoved.add(hppAugmentation);
- }
+ for (TerminationPoint tp : removed.nonnullTerminationPoint().values()) {
+ HwvtepPhysicalPortAugmentation hppAugmentation =
+ tp.augmentation(HwvtepPhysicalPortAugmentation.class);
+ if (hppAugmentation != null) {
+ lswitchListRemoved.add(hppAugmentation);
}
}
if (!lswitchListRemoved.isEmpty()) {
List<HwvtepPhysicalPortAugmentation> portListUpdated = new ArrayList<>();
List<HwvtepPhysicalPortAugmentation> portListBefore = new ArrayList<>();
List<HwvtepPhysicalPortAugmentation> portListRemoved = new ArrayList<>();
- if (updated.getTerminationPoint() != null) {
- for (TerminationPoint tp : updated.getTerminationPoint()) {
- HwvtepPhysicalPortAugmentation hppAugmentation =
- tp.augmentation(HwvtepPhysicalPortAugmentation.class);
- if (hppAugmentation != null) {
- portListUpdated.add(hppAugmentation);
- }
+ for (TerminationPoint tp : updated.nonnullTerminationPoint().values()) {
+ HwvtepPhysicalPortAugmentation hppAugmentation =
+ tp.augmentation(HwvtepPhysicalPortAugmentation.class);
+ if (hppAugmentation != null) {
+ portListUpdated.add(hppAugmentation);
}
}
- if (before.getTerminationPoint() != null) {
- for (TerminationPoint tp : before.getTerminationPoint()) {
- HwvtepPhysicalPortAugmentation hppAugmentation =
- tp.augmentation(HwvtepPhysicalPortAugmentation.class);
- if (hppAugmentation != null) {
- portListBefore.add(hppAugmentation);
- }
+ for (TerminationPoint tp : before.nonnullTerminationPoint().values()) {
+ HwvtepPhysicalPortAugmentation hppAugmentation =
+ tp.augmentation(HwvtepPhysicalPortAugmentation.class);
+ if (hppAugmentation != null) {
+ portListBefore.add(hppAugmentation);
}
}
portListBefore.removeAll(portListUpdated);
* 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 static org.opendaylight.ovsdb.lib.operations.Operations.op;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
-
import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindings;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class PhysicalPortUpdateCommand extends AbstractTransactCommand<TerminationPoint, PhysicalSwitchAugmentation> {
+public class PhysicalPortUpdateCommand
+ extends AbstractTransactCommand<TerminationPoint, TerminationPointKey, PhysicalSwitchAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(PhysicalPortUpdateCommand.class);
private static final VlanBindingsUnMetDependencyGetter DEPENDENCY_GETTER = new VlanBindingsUnMetDependencyGetter();
}
@Override
- public void onConfigUpdate(TransactionBuilder transaction, InstanceIdentifier psNodeiid,
- TerminationPoint port, InstanceIdentifier tpIId, Object... extraData) {
+ public void onConfigUpdate(final TransactionBuilder transaction, final InstanceIdentifier psNodeiid,
+ final TerminationPoint port, final InstanceIdentifier tpIId, final Object... extraData) {
doDeviceTransaction(transaction, psNodeiid, port, tpIId);
}
@Override
- public void doDeviceTransaction(TransactionBuilder transaction, InstanceIdentifier nodeIid,
- TerminationPoint data, InstanceIdentifier key, Object... extraData) {
+ public void doDeviceTransaction(final TransactionBuilder transaction, final InstanceIdentifier nodeIid,
+ final TerminationPoint data, final InstanceIdentifier key,
+ final Object... extraData) {
LOG.debug("Processing port doDeviceTransaction {}", data);
InstanceIdentifier<Node> psNodeiid = nodeIid;
- HwvtepPhysicalPortAugmentation port = ((TerminationPoint)data).augmentation(
+ HwvtepPhysicalPortAugmentation port = data.augmentation(
HwvtepPhysicalPortAugmentation.class);
if (port == null) {
LOG.info("No port augmentation found for port {}", data);
return;
}
- private void setName(PhysicalPort physicalPort, HwvtepPhysicalPortAugmentation inputPhysicalPort) {
+ private void setName(final PhysicalPort physicalPort, final HwvtepPhysicalPortAugmentation inputPhysicalPort) {
if (inputPhysicalPort.getHwvtepNodeName() != null) {
physicalPort.setName(inputPhysicalPort.getHwvtepNodeName().getValue());
}
HwvtepPhysicalPortAugmentation portAugmentation = inputPhysicalPort.augmentation(
HwvtepPhysicalPortAugmentation.class);
Map<Long, UUID> bindingMap = new HashMap<>();
- if (portAugmentation.getVlanBindings() != null) {
- //get UUID by LogicalSwitchRef
- for (VlanBindings vlanBinding : portAugmentation.getVlanBindings()) {
- @SuppressWarnings("unchecked")
- InstanceIdentifier<LogicalSwitches> lswitchIid =
- (InstanceIdentifier<LogicalSwitches>) vlanBinding.getLogicalSwitchRef().getValue();
+ //get UUID by LogicalSwitchRef
+ for (VlanBindings vlanBinding : portAugmentation.nonnullVlanBindings().values()) {
+ @SuppressWarnings("unchecked")
+ InstanceIdentifier<LogicalSwitches> lswitchIid =
+ (InstanceIdentifier<LogicalSwitches>) vlanBinding.getLogicalSwitchRef().getValue();
- Map inTransitDependencies = DEPENDENCY_GETTER.getInTransitDependencies(
- getOperationalState(), vlanBinding);
- Map configDependencies = DEPENDENCY_GETTER.getUnMetConfigDependencies(
- getOperationalState(), vlanBinding);
+ Map inTransitDependencies = DEPENDENCY_GETTER.getInTransitDependencies(
+ getOperationalState(), vlanBinding);
+ Map configDependencies = DEPENDENCY_GETTER.getUnMetConfigDependencies(
+ getOperationalState(), vlanBinding);
- if (!HwvtepSouthboundUtil.isEmptyMap(configDependencies)) {
- createConfigWaitJob(psNodeiid, inputPhysicalPort, key, configDependencies);
- continue;
- }
- if (!HwvtepSouthboundUtil.isEmptyMap(inTransitDependencies)) {
- createOperWaitingJob(psNodeiid, inputPhysicalPort, key, inTransitDependencies);
- continue;
- }
+ if (!HwvtepSouthboundUtil.isEmptyMap(configDependencies)) {
+ createConfigWaitJob(psNodeiid, inputPhysicalPort, key, configDependencies);
+ continue;
+ }
+ if (!HwvtepSouthboundUtil.isEmptyMap(inTransitDependencies)) {
+ createOperWaitingJob(psNodeiid, inputPhysicalPort, key, inTransitDependencies);
+ continue;
+ }
- UUID lsUUid = TransactUtils.getLogicalSwitchUUID(transaction, getOperationalState(), lswitchIid);
- if (lsUUid == null) {
- LOG.error("Could not get the logical switch uuid for {}", vlanBinding);
- continue;
- }
- bindingMap.put(vlanBinding.getVlanIdKey().getValue().longValue(), lsUUid);
+ UUID lsUUid = TransactUtils.getLogicalSwitchUUID(transaction, getOperationalState(), lswitchIid);
+ if (lsUUid == null) {
+ LOG.error("Could not get the logical switch uuid for {}", vlanBinding);
+ continue;
}
+ bindingMap.put(vlanBinding.getVlanIdKey().getValue().longValue(), lsUUid);
}
physicalPort.setVlanBindings(bindingMap);
return bindingMap;
Node created = TransactUtils.getCreated(mod);
if (created != null) {
List<TerminationPoint> portListUpdated = new ArrayList<>();
- if (created.getTerminationPoint() != null) {
- for (TerminationPoint tp : created.getTerminationPoint()) {
- HwvtepPhysicalPortAugmentation hppAugmentation =
- tp.augmentation(HwvtepPhysicalPortAugmentation.class);
- if (hppAugmentation != null) {
- portListUpdated.add(tp);
- }
+ for (TerminationPoint tp : created.nonnullTerminationPoint().values()) {
+ HwvtepPhysicalPortAugmentation hppAugmentation =
+ tp.augmentation(HwvtepPhysicalPortAugmentation.class);
+ if (hppAugmentation != null) {
+ portListUpdated.add(tp);
}
}
result.put(key, portListUpdated);
if (updated != null && before != null) {
List<TerminationPoint> portListUpdated = new ArrayList<>();
List<TerminationPoint> portListBefore = new ArrayList<>();
- if (updated.getTerminationPoint() != null) {
- for (TerminationPoint tp : updated.getTerminationPoint()) {
- HwvtepPhysicalPortAugmentation hppAugmentation =
- tp.augmentation(HwvtepPhysicalPortAugmentation.class);
- if (hppAugmentation != null) {
- portListUpdated.add(tp);
- }
+ for (TerminationPoint tp : updated.nonnullTerminationPoint().values()) {
+ HwvtepPhysicalPortAugmentation hppAugmentation =
+ tp.augmentation(HwvtepPhysicalPortAugmentation.class);
+ if (hppAugmentation != null) {
+ portListUpdated.add(tp);
}
}
- if (before.getTerminationPoint() != null) {
- for (TerminationPoint tp : before.getTerminationPoint()) {
- HwvtepPhysicalPortAugmentation hppAugmentation =
- tp.augmentation(HwvtepPhysicalPortAugmentation.class);
- if (hppAugmentation != null) {
- portListBefore.add(tp);
- }
+ for (TerminationPoint tp : before.nonnullTerminationPoint().values()) {
+ HwvtepPhysicalPortAugmentation hppAugmentation =
+ tp.augmentation(HwvtepPhysicalPortAugmentation.class);
+ if (hppAugmentation != null) {
+ portListBefore.add(tp);
}
}
portListUpdated.removeAll(portListBefore);
return result;
}
- protected String getKeyStr(InstanceIdentifier iid) {
+ @Override
+ protected String getKeyStr(final InstanceIdentifier iid) {
try {
return ((TerminationPoint)iid.firstKeyOf(TerminationPoint.class)).getTpId().getValue();
} catch (ClassCastException exp) {
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.ManagementIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.ManagementIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.Tunnels;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdLocalConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdLocalConfigsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdParams;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdParamsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdRemoteConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdRemoteConfigsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private static void setManagementIps(final PhysicalSwitch physicalSwitch,
final PhysicalSwitchAugmentation physicalSwitchAugmentation) {
- Set<String> ipSet = new HashSet<>();
- if (physicalSwitchAugmentation.getManagementIps() != null) {
- for (ManagementIps ip: physicalSwitchAugmentation.getManagementIps()) {
+ Map<ManagementIpsKey, ManagementIps> managementIps = physicalSwitchAugmentation.getManagementIps();
+ if (managementIps != null) {
+ Set<String> ipSet = new HashSet<>();
+ for (ManagementIps ip: managementIps.values()) {
ipSet.add(ip.getManagementIpsKey().getIpv4Address().getValue());
}
physicalSwitch.setManagementIps(ipSet);
private static void setTunnuleIps(final PhysicalSwitch physicalSwitch,
final PhysicalSwitchAugmentation physicalSwitchAugmentation) {
- Set<String> ipSet = new HashSet<>();
- if (physicalSwitchAugmentation.getTunnelIps() != null) {
- for (TunnelIps ip: physicalSwitchAugmentation.getTunnelIps()) {
+ final Map<TunnelIpsKey, TunnelIps> tunnelIps = physicalSwitchAugmentation.getTunnelIps();
+ if (tunnelIps != null) {
+ Set<String> ipSet = new HashSet<>();
+ for (TunnelIps ip: tunnelIps.values()) {
ipSet.add(ip.getTunnelIpsKey().getIpv4Address().getValue());
}
physicalSwitch.setTunnelIps(ipSet);
final boolean switchExists) {
//TODO: revisit this code for optimizations
//TODO: needs more testing
- if (physicalSwitchAugmentation.getTunnels() != null) {
- for (Tunnels tunnel : physicalSwitchAugmentation.getTunnels()) {
- Optional<Tunnels> opTunnelOpt = getOperationalState().getTunnels(iid, tunnel.key());
- Tunnel newTunnel = transaction.getTypedRowWrapper(Tunnel.class);
+ for (Tunnels tunnel : physicalSwitchAugmentation.nonnullTunnels().values()) {
+ Optional<Tunnels> opTunnelOpt = getOperationalState().getTunnels(iid, tunnel.key());
+ Tunnel newTunnel = transaction.getTypedRowWrapper(Tunnel.class);
- UUID localUUID = getLocatorUUID(transaction,
- (InstanceIdentifier<TerminationPoint>) tunnel.getLocalLocatorRef().getValue());
- UUID remoteUUID = getLocatorUUID(transaction,
- (InstanceIdentifier<TerminationPoint>) tunnel.getRemoteLocatorRef().getValue());
- if (localUUID != null && remoteUUID != null) {
- // local and remote must exist
- newTunnel.setLocal(localUUID);
- newTunnel.setRemote(remoteUUID);
- setBfdParams(newTunnel, tunnel);
- setBfdLocalConfigs(newTunnel, tunnel);
- setBfdRemoteConfigs(newTunnel, tunnel);
- if (!opTunnelOpt.isPresent()) {
- String tunnelUuid = "Tunnel_" + HwvtepSouthboundMapper.getRandomUUID();
- transaction.add(op.insert(newTunnel).withId(tunnelUuid));
- transaction.add(op.comment("Tunnel: Creating " + tunnelUuid));
- if (!switchExists) {
- //TODO: Figure out a way to handle this
- LOG.warn("Tunnel configuration requires pre-existing physicalSwitch");
- } else {
- // TODO: Can we reuse physicalSwitch instead?
- PhysicalSwitch phySwitch = transaction.getTypedRowWrapper(PhysicalSwitch.class);
- phySwitch.setTunnels(Collections.singleton(new UUID(tunnelUuid)));
- phySwitch.setName(physicalSwitchAugmentation.getHwvtepNodeName().getValue());
- transaction.add(op.mutate(phySwitch)
- .addMutation(phySwitch.getTunnels().getSchema(), Mutator.INSERT,
- phySwitch.getTunnels().getData())
- .where(phySwitch.getNameColumn().getSchema()
- .opEqual(phySwitch.getNameColumn().getData()))
- .build());
- transaction.add(op.comment("PhysicalSwitch: Mutating " + tunnelUuid));
- }
+ UUID localUUID = getLocatorUUID(transaction,
+ (InstanceIdentifier<TerminationPoint>) tunnel.getLocalLocatorRef().getValue());
+ UUID remoteUUID = getLocatorUUID(transaction,
+ (InstanceIdentifier<TerminationPoint>) tunnel.getRemoteLocatorRef().getValue());
+ if (localUUID != null && remoteUUID != null) {
+ // local and remote must exist
+ newTunnel.setLocal(localUUID);
+ newTunnel.setRemote(remoteUUID);
+ setBfdParams(newTunnel, tunnel);
+ setBfdLocalConfigs(newTunnel, tunnel);
+ setBfdRemoteConfigs(newTunnel, tunnel);
+ if (!opTunnelOpt.isPresent()) {
+ String tunnelUuid = "Tunnel_" + HwvtepSouthboundMapper.getRandomUUID();
+ transaction.add(op.insert(newTunnel).withId(tunnelUuid));
+ transaction.add(op.comment("Tunnel: Creating " + tunnelUuid));
+ if (!switchExists) {
+ //TODO: Figure out a way to handle this
+ LOG.warn("Tunnel configuration requires pre-existing physicalSwitch");
} else {
- UUID uuid = new UUID(opTunnelOpt.get().getTunnelUuid().getValue());
- Tunnel extraTunnel = transaction.getTypedRowSchema(Tunnel.class);
- extraTunnel.getUuidColumn().setData(uuid);
- transaction.add(op.update(newTunnel)
- .where(extraTunnel.getUuidColumn().getSchema().opEqual(uuid))
- .build());
- transaction.add(op.comment("Tunnel: Updating " + uuid));
+ // TODO: Can we reuse physicalSwitch instead?
+ PhysicalSwitch phySwitch = transaction.getTypedRowWrapper(PhysicalSwitch.class);
+ phySwitch.setTunnels(Collections.singleton(new UUID(tunnelUuid)));
+ phySwitch.setName(physicalSwitchAugmentation.getHwvtepNodeName().getValue());
+ transaction.add(op.mutate(phySwitch)
+ .addMutation(phySwitch.getTunnels().getSchema(), Mutator.INSERT,
+ phySwitch.getTunnels().getData())
+ .where(phySwitch.getNameColumn().getSchema()
+ .opEqual(phySwitch.getNameColumn().getData()))
+ .build());
+ transaction.add(op.comment("PhysicalSwitch: Mutating " + tunnelUuid));
}
+ } else {
+ UUID uuid = new UUID(opTunnelOpt.get().getTunnelUuid().getValue());
+ Tunnel extraTunnel = transaction.getTypedRowSchema(Tunnel.class);
+ extraTunnel.getUuidColumn().setData(uuid);
+ transaction.add(op.update(newTunnel)
+ .where(extraTunnel.getUuidColumn().getSchema().opEqual(uuid))
+ .build());
+ transaction.add(op.comment("Tunnel: Updating " + uuid));
}
}
}
}
private static void setBfdParams(final Tunnel tunnel, final Tunnels psAugTunnel) {
- List<BfdParams> bfdParams = psAugTunnel.getBfdParams();
+ Map<BfdParamsKey, BfdParams> bfdParams = psAugTunnel.getBfdParams();
if (bfdParams != null) {
Map<String, String> bfdParamMap = new HashMap<>();
- for (BfdParams bfdParam : bfdParams) {
+ for (BfdParams bfdParam : bfdParams.values()) {
bfdParamMap.put(bfdParam.getBfdParamKey(), bfdParam.getBfdParamValue());
}
try {
}
private static void setBfdLocalConfigs(final Tunnel tunnel, final Tunnels psAugTunnel) {
- List<BfdLocalConfigs> bfdLocalConfigs = psAugTunnel.getBfdLocalConfigs();
+ Map<BfdLocalConfigsKey, BfdLocalConfigs> bfdLocalConfigs = psAugTunnel.getBfdLocalConfigs();
if (bfdLocalConfigs != null) {
Map<String, String> configLocalMap = new HashMap<>();
- for (BfdLocalConfigs localConfig : bfdLocalConfigs) {
+ for (BfdLocalConfigs localConfig : bfdLocalConfigs.values()) {
configLocalMap.put(localConfig.getBfdLocalConfigKey(), localConfig.getBfdLocalConfigValue());
}
try {
}
private static void setBfdRemoteConfigs(final Tunnel tunnel, final Tunnels psAugTunnel) {
- List<BfdRemoteConfigs> bfdRemoteConfigs = psAugTunnel.getBfdRemoteConfigs();
+ Map<BfdRemoteConfigsKey, BfdRemoteConfigs> bfdRemoteConfigs = psAugTunnel.getBfdRemoteConfigs();
if (bfdRemoteConfigs != null) {
Map<String, String> configRemoteMap = new HashMap<>();
- for (BfdRemoteConfigs remoteConfig : bfdRemoteConfigs) {
+ for (BfdRemoteConfigs remoteConfig : bfdRemoteConfigs.values()) {
configRemoteMap.put(remoteConfig.getBfdRemoteConfigKey(), remoteConfig.getBfdRemoteConfigValue());
}
try {
* 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 static org.opendaylight.ovsdb.lib.operations.Operations.op;
import java.util.Collection;
-import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
-
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
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.LogicalSwitches;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitchesKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class PlainLogicalSwitchRemoveCmd extends AbstractTransactCommand<LogicalSwitches, HwvtepGlobalAugmentation> {
+public class PlainLogicalSwitchRemoveCmd
+ extends AbstractTransactCommand<LogicalSwitches, LogicalSwitchesKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(PlainLogicalSwitchRemoveCmd.class);
+
private AtomicInteger retryCount = new AtomicInteger(5);
- private LogicalSwitches logicalSwitches;
- private InstanceIdentifier<Node> nodeIid;
+ private final LogicalSwitches logicalSwitches;
+ private final InstanceIdentifier<Node> nodeIid;
- public PlainLogicalSwitchRemoveCmd(HwvtepOperationalState state,
- Collection<DataTreeModification<Node>> changes,
- LogicalSwitches logicalSwitches,
- int retryCount) {
+ public PlainLogicalSwitchRemoveCmd(final HwvtepOperationalState state,
+ final Collection<DataTreeModification<Node>> changes,
+ final LogicalSwitches logicalSwitches,
+ final int retryCount) {
super(state, changes);
this.logicalSwitches = logicalSwitches;
this.retryCount = new AtomicInteger(retryCount);
}
@Override
- public void execute(TransactionBuilder transaction) {
+ public void execute(final TransactionBuilder transaction) {
LogicalSwitch logicalSwitch = TyperUtils.getTypedRowWrapper(
transaction.getDatabaseSchema(), LogicalSwitch.class, null);
transaction.add(op.delete(logicalSwitch.getSchema())
}
@Override
- protected List<LogicalSwitches> getData(HwvtepGlobalAugmentation augmentation) {
+ protected Map<LogicalSwitchesKey, LogicalSwitches> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getLogicalSwitches();
}
@Override
- protected boolean areEqual(LogicalSwitches logicalSwitches1 , LogicalSwitches logicalSwitches2) {
+ protected boolean areEqual(final LogicalSwitches logicalSwitches1 , final LogicalSwitches logicalSwitches2) {
return logicalSwitches1.key().equals(logicalSwitches2.key())
&& Objects.equals(logicalSwitches1.getTunnelKey(), logicalSwitches2.getTunnelKey());
}
+ @Override
public boolean retry() {
boolean ret = retryCount.decrementAndGet() > 0;
if (ret) {
return ret;
}
+ @Override
protected boolean isDeleteCmd() {
return true;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.hwvtepsouthbound.transact;
import java.util.Collection;
-
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;
* 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.Collection;
-
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.opendaylight.ovsdb.schema.hardwarevtep.UcastMacsLocal;
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.LocalUcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class UcastMacsLocalRemoveCommand extends AbstractTransactCommand<LocalUcastMacs, HwvtepGlobalAugmentation> {
+public class UcastMacsLocalRemoveCommand
+ extends AbstractTransactCommand<LocalUcastMacs, LocalUcastMacsKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(UcastMacsLocalRemoveCommand.class);
public UcastMacsLocalRemoveCommand(final HwvtepOperationalState state,
}
@Override
- protected List<LocalUcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
+ protected Map<LocalUcastMacsKey, LocalUcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getLocalUcastMacs();
}
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.HwvtepPhysicalLocatorAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class UcastMacsLocalUpdateCommand extends AbstractTransactCommand<LocalUcastMacs, HwvtepGlobalAugmentation> {
+public class UcastMacsLocalUpdateCommand
+ extends AbstractTransactCommand<LocalUcastMacs, LocalUcastMacsKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(UcastMacsLocalUpdateCommand.class);
public UcastMacsLocalUpdateCommand(final HwvtepOperationalState state,
}
@Override
- protected List<LocalUcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
+ protected Map<LocalUcastMacsKey, LocalUcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getLocalUcastMacs();
}
}
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
-
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
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;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class UcastMacsRemoteRemoveCommand extends AbstractTransactCommand<RemoteUcastMacs, HwvtepGlobalAugmentation> {
+public class UcastMacsRemoteRemoveCommand
+ extends AbstractTransactCommand<RemoteUcastMacs, RemoteUcastMacsKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(UcastMacsRemoteRemoveCommand.class);
public UcastMacsRemoteRemoveCommand(final HwvtepOperationalState state,
}
}
- public void onConfigUpdate(TransactionBuilder transaction,
- InstanceIdentifier<Node> nodeIid,
- List<RemoteUcastMacs> macs) {
+ public void onConfigUpdate(final TransactionBuilder transaction,
+ final InstanceIdentifier<Node> nodeIid,
+ final List<RemoteUcastMacs> macs) {
for (RemoteUcastMacs mac : macs) {
InstanceIdentifier<RemoteUcastMacs> macKey = nodeIid.augmentation(HwvtepGlobalAugmentation.class)
.child(RemoteUcastMacs.class, mac.key());
}
@Override
- public void onConfigUpdate(TransactionBuilder transaction,
- InstanceIdentifier<Node> nodeIid,
- RemoteUcastMacs remoteMcastMac,
- InstanceIdentifier macKey,
- Object... extraData) {
+ public void onConfigUpdate(final TransactionBuilder transaction,
+ final InstanceIdentifier<Node> nodeIid,
+ final RemoteUcastMacs remoteMcastMac,
+ final InstanceIdentifier macKey,
+ final Object... extraData) {
processDependencies(EmptyDependencyGetter.INSTANCE, transaction, nodeIid, macKey, remoteMcastMac);
}
@Override
- public void doDeviceTransaction(TransactionBuilder transaction,
- InstanceIdentifier<Node> instanceIdentifier,
- RemoteUcastMacs mac,
- InstanceIdentifier macKey,
- Object... extraData) {
+ public void doDeviceTransaction(final TransactionBuilder transaction,
+ final InstanceIdentifier<Node> instanceIdentifier,
+ final RemoteUcastMacs mac,
+ final InstanceIdentifier macKey,
+ final Object... extraData) {
removeUcastMacRemote(transaction, instanceIdentifier, Lists.newArrayList(mac));
}
}
@Override
- protected List<RemoteUcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
+ protected Map<RemoteUcastMacsKey, RemoteUcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getRemoteUcastMacs();
}
@Override
- protected boolean areEqual(RemoteUcastMacs remoteUcastMacs1, RemoteUcastMacs remoteUcastMacs2) {
+ protected boolean areEqual(final RemoteUcastMacs remoteUcastMacs1, final RemoteUcastMacs remoteUcastMacs2) {
return Objects.equals(remoteUcastMacs1.key(), remoteUcastMacs2.key());
}
@Override
- public void onSuccess(TransactionBuilder tx) {
+ public void onSuccess(final TransactionBuilder tx) {
for (MdsalUpdate mdsalUpdate : updates) {
RemoteUcastMacs mac = (RemoteUcastMacs) mdsalUpdate.getNewData();
InstanceIdentifier<RemoteUcastMacs> macIid = mdsalUpdate.getKey();
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
-
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
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;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class UcastMacsRemoteUpdateCommand extends AbstractTransactCommand<RemoteUcastMacs, HwvtepGlobalAugmentation> {
+public class UcastMacsRemoteUpdateCommand
+ extends AbstractTransactCommand<RemoteUcastMacs, RemoteUcastMacsKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(UcastMacsRemoteUpdateCommand.class);
private static final UcastMacUnMetDependencyGetter UCAST_MAC_DATA_VALIDATOR = new UcastMacUnMetDependencyGetter();
}
}
- private UUID setLocator(TransactionBuilder transaction, UcastMacsRemote ucastMacsRemote, RemoteUcastMacs inputMac) {
+ private UUID setLocator(final TransactionBuilder transaction, final UcastMacsRemote ucastMacsRemote,
+ final RemoteUcastMacs inputMac) {
//get UUID by locatorRef
if (inputMac.getLocatorRef() != null) {
@SuppressWarnings("unchecked")
}
@Override
- protected List<RemoteUcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
+ protected Map<RemoteUcastMacsKey, RemoteUcastMacs> getData(final HwvtepGlobalAugmentation augmentation) {
return augmentation.getRemoteUcastMacs();
}
}
@Override
- protected boolean areEqual(RemoteUcastMacs remoteUcastMacs1, RemoteUcastMacs remoteUcastMacs2) {
+ protected boolean areEqual(final RemoteUcastMacs remoteUcastMacs1, final RemoteUcastMacs remoteUcastMacs2) {
return Objects.equals(remoteUcastMacs1.key(), remoteUcastMacs2.key())
&& Objects.equals(remoteUcastMacs1.getLocatorRef(), remoteUcastMacs2.getLocatorRef());
}
@Override
- public void onSuccess(TransactionBuilder tx) {
+ public void onSuccess(final TransactionBuilder tx) {
for (MdsalUpdate mdsalUpdate : updates) {
RemoteUcastMacs mac = (RemoteUcastMacs) mdsalUpdate.getNewData();
InstanceIdentifier<RemoteUcastMacs> macIid = mdsalUpdate.getKey();
* 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.Map.Entry;
import java.util.Optional;
-
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
package org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md;
import com.google.common.util.concurrent.FluentFuture;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
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.Managers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.ManagersKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Switches;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.SwitchesKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
HwvtepGlobalAugmentation hgAugmentation = hwvtepNode.augmentation(HwvtepGlobalAugmentation.class);
if (checkIfOnlyConnectedManager(hgAugmentation)) {
if (hgAugmentation != null) {
- if (hgAugmentation.getSwitches() != null) {
- for (Switches hwSwitch : hgAugmentation.getSwitches()) {
+ Map<SwitchesKey, Switches> switches = hgAugmentation.getSwitches();
+ if (switches != null) {
+ for (Switches hwSwitch : switches.values()) {
LOG.debug("Deleting hwvtep switch {}", hwSwitch);
transaction.delete(
LogicalDatastoreType.OPERATIONAL, hwSwitch.getSwitchRef().getValue());
}
}
- private boolean checkIfOnlyConnectedManager(HwvtepGlobalAugmentation hgAugmentation) {
+ private static boolean checkIfOnlyConnectedManager(HwvtepGlobalAugmentation hgAugmentation) {
if (hgAugmentation != null) {
int connectedManager = 0;
- if (hgAugmentation.getManagers() != null) {
- for (Managers manager : hgAugmentation.getManagers()) {
+ Map<ManagersKey, Managers> managers = hgAugmentation.getManagers();
+ if (managers != null) {
+ for (Managers manager : managers.values()) {
if (manager.isIsConnected()) {
connectedManager++;
if (connectedManager > ONE_CONNECTED_MANAGER) {
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.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.HwvtepGlobalAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepLogicalSwitchRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalMcastMacs;
private void updateData(ReadWriteTransaction transaction, McastMacsLocal macLocal) {
final InstanceIdentifier<Node> connectionIId = getOvsdbConnectionInstance().getInstanceIdentifier();
- Node connectionNode = buildConnectionNode(macLocal);
- transaction.merge(LogicalDatastoreType.OPERATIONAL, connectionIId, connectionNode);
+
+ // Ensure the node exists
+ transaction.merge(LogicalDatastoreType.OPERATIONAL, connectionIId,
+ new NodeBuilder().setNodeId(getOvsdbConnectionInstance().getNodeId()).build());
+
+ final LocalMcastMacs mac = buildLocalMcastMacs(macLocal);
+ final InstanceIdentifier<LocalMcastMacs> macIid = connectionIId.augmentation(HwvtepGlobalAugmentation.class)
+ .child(LocalMcastMacs.class, mac.key());
+
+ // Merge update, relying on automatic lifecycle...
+ transaction.merge(LogicalDatastoreType.OPERATIONAL, macIid, mac);
+ if (mac.getLocatorSet() == null) {
+ // ... but delete locator set if it is empty
+ // FIXME: can we use .put() of instead of merge/delete?
+ transaction.delete(LogicalDatastoreType.OPERATIONAL, macIid.child(LocatorSet.class));
+ }
}
- private Node buildConnectionNode(McastMacsLocal macLocal) {
- NodeBuilder connectionNode = new NodeBuilder();
- connectionNode.setNodeId(getOvsdbConnectionInstance().getNodeId());
+ private LocalMcastMacs buildLocalMcastMacs(McastMacsLocal macLocal) {
LocalMcastMacsBuilder macLocalBuilder = new LocalMcastMacsBuilder();
if (macLocal.getMac().equals(HwvtepSouthboundConstants.UNKNOWN_DST_STRING)) {
macLocalBuilder.setMacEntryKey(HwvtepSouthboundConstants.UNKNOWN_DST_MAC);
setLocatorSet(macLocalBuilder, macLocal);
setLogicalSwitch(macLocalBuilder, macLocal);
- List<LocalMcastMacs> macLocalList = new ArrayList<>();
- macLocalList.add(macLocalBuilder.build());
-
- HwvtepGlobalAugmentationBuilder hgAugmentationBuilder = new HwvtepGlobalAugmentationBuilder();
- hgAugmentationBuilder.setLocalMcastMacs(macLocalList);
- connectionNode.addAugmentation(HwvtepGlobalAugmentation.class, hgAugmentationBuilder.build());
- return connectionNode.build();
+ return macLocalBuilder.build();
}
private void setLogicalSwitch(LocalMcastMacsBuilder macLocalBuilder, McastMacsLocal macLocal) {
}
}
- private void setIpAddress(LocalMcastMacsBuilder macLocalBuilder, McastMacsLocal macLocal) {
+ private static void setIpAddress(LocalMcastMacsBuilder macLocalBuilder, McastMacsLocal macLocal) {
if (macLocal.getIpAddr() != null && !macLocal.getIpAddr().isEmpty()) {
macLocalBuilder.setIpaddr(IpAddressBuilder.getDefaultInstance(macLocal.getIpAddr()));
}
for (UUID locUUID : plSet.getLocatorsColumn().getData()) {
PhysicalLocator locator = updatedPLocRows.get(locUUID);
if (locator == null) {
- locator = (PhysicalLocator) getOvsdbConnectionInstance()
- .getDeviceInfo().getPhysicalLocator(locUUID);
+ locator = getOvsdbConnectionInstance().getDeviceInfo().getPhysicalLocator(locUUID);
}
InstanceIdentifier<TerminationPoint> tpIid = HwvtepSouthboundMapper.createInstanceIdentifier(
getOvsdbConnectionInstance().getInstanceIdentifier(), locator);
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.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.HwvtepGlobalAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepLogicalSwitchRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.locator.set.attributes.LocatorSet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.locator.set.attributes.LocatorSetBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
private void updateData(ReadWriteTransaction transaction, McastMacsRemote macRemote) {
final InstanceIdentifier<Node> connectionIId = getOvsdbConnectionInstance().getInstanceIdentifier();
- Node connectionNode = buildConnectionNode(macRemote);
- transaction.merge(LogicalDatastoreType.OPERATIONAL, connectionIId, connectionNode);
- }
- InstanceIdentifier<RemoteMcastMacs> getMacIid(InstanceIdentifier<Node> connectionIId, Node connectionNode) {
- RemoteMcastMacsKey macsKey =
- connectionNode.augmentation(HwvtepGlobalAugmentation.class).getRemoteMcastMacs().get(0).key();
- InstanceIdentifier<RemoteMcastMacs> key = connectionIId.augmentation(HwvtepGlobalAugmentation.class)
- .child(RemoteMcastMacs.class, macsKey);
- return key;
+ // Ensure the node exists
+ transaction.merge(LogicalDatastoreType.OPERATIONAL, connectionIId,
+ new NodeBuilder().setNodeId(getOvsdbConnectionInstance().getNodeId()).build());
+
+ // Prepare the update in internal structures
+ final RemoteMcastMacs mac = buildRemoteMcastMacs(macRemote);
+ final InstanceIdentifier<RemoteMcastMacs> macIid = connectionIId.augmentation(HwvtepGlobalAugmentation.class)
+ .child(RemoteMcastMacs.class, mac.key());
+ addToUpdateTx(RemoteMcastMacs.class, macIid, macRemote.getUuid(), macRemote);
+
+ // Merge update, relying on automatic lifecycle...
+ transaction.merge(LogicalDatastoreType.OPERATIONAL, macIid, mac);
+ if (mac.getLocatorSet() == null) {
+ // ... but delete locator set if it is empty
+ // FIXME: can we use .put() of instead of merge/delete?
+ transaction.delete(LogicalDatastoreType.OPERATIONAL, macIid.child(LocatorSet.class));
+ }
}
- private Node buildConnectionNode(McastMacsRemote macRemote) {
- NodeBuilder connectionNode = new NodeBuilder();
- connectionNode.setNodeId(getOvsdbConnectionInstance().getNodeId());
+ private RemoteMcastMacs buildRemoteMcastMacs(McastMacsRemote macRemote) {
RemoteMcastMacsBuilder macRemoteBuilder = new RemoteMcastMacsBuilder();
if (macRemote.getMac().equals(HwvtepSouthboundConstants.UNKNOWN_DST_STRING)) {
macRemoteBuilder.setMacEntryKey(HwvtepSouthboundConstants.UNKNOWN_DST_MAC);
setLocatorSet(macRemoteBuilder, macRemote);
setLogicalSwitch(macRemoteBuilder, macRemote);
- List<RemoteMcastMacs> macRemoteList = new ArrayList<>();
- RemoteMcastMacs mac = macRemoteBuilder.build();
- macRemoteList.add(mac);
-
- HwvtepGlobalAugmentationBuilder hgAugmentationBuilder = new HwvtepGlobalAugmentationBuilder();
- hgAugmentationBuilder.setRemoteMcastMacs(macRemoteList);
- connectionNode.addAugmentation(HwvtepGlobalAugmentation.class, hgAugmentationBuilder.build());
- InstanceIdentifier<RemoteMcastMacs> macIid = getOvsdbConnectionInstance().getInstanceIdentifier()
- .augmentation(HwvtepGlobalAugmentation.class).child(RemoteMcastMacs.class, mac.key());
- addToUpdateTx(RemoteMcastMacs.class, macIid, macRemote.getUuid(), macRemote);
- return connectionNode.build();
+ return macRemoteBuilder.build();
}
private void setLogicalSwitch(RemoteMcastMacsBuilder macRemoteBuilder, McastMacsRemote macRemote) {
}
}
- private void setIpAddress(RemoteMcastMacsBuilder macRemoteBuilder, McastMacsRemote macRemote) {
+ private static void setIpAddress(RemoteMcastMacsBuilder macRemoteBuilder, McastMacsRemote macRemote) {
if (macRemote.getIpAddr() != null && !macRemote.getIpAddr().isEmpty()) {
macRemoteBuilder.setIpaddr(IpAddressBuilder.getDefaultInstance(macRemote.getIpAddr()));
}
for (UUID locUUID : plSet.getLocatorsColumn().getData()) {
PhysicalLocator locator = updatedPLocRows.get(locUUID);
if (locator == null) {
- locator = (PhysicalLocator) getOvsdbConnectionInstance()
- .getDeviceInfo().getPhysicalLocator(locUUID);
+ locator = getOvsdbConnectionInstance().getDeviceInfo().getPhysicalLocator(locUUID);
}
InstanceIdentifier<TerminationPoint> tpIid = HwvtepSouthboundMapper.createInstanceIdentifier(
getOvsdbConnectionInstance().getInstanceIdentifier(), locator);
}
}
}
-
}
* 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.transactions.md;
import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;
-
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
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.hwvtep.global.attributes.LogicalSwitches;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Switches;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.SwitchesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.PortFaultStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.PortFaultStatusBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.PortFaultStatusKey;
private static Optional<InstanceIdentifier<Node>> getTerminationPointSwitch(final ReadWriteTransaction transaction,
final Node node, final String tpName) {
HwvtepGlobalAugmentation hwvtepNode = node.augmentation(HwvtepGlobalAugmentation.class);
- List<Switches> switchNodes = hwvtepNode.getSwitches();
+ Map<SwitchesKey, Switches> switchNodes = hwvtepNode.getSwitches();
if (switchNodes != null && !switchNodes.isEmpty()) {
- for (Switches managedNodeEntry : switchNodes) {
+ for (Switches managedNodeEntry : switchNodes.values()) {
@SuppressWarnings("unchecked")
- Node switchNode = HwvtepSouthboundUtil
- .readNode(transaction,
+ Node switchNode = HwvtepSouthboundUtil.readNode(transaction,
(InstanceIdentifier<Node>) managedNodeEntry.getSwitchRef().getValue()).get();
TerminationPointKey tpKey = new TerminationPointKey(new TpId(tpName));
- if (switchNode.getTerminationPoint() != null) {
- for (TerminationPoint terminationPoint : switchNode.getTerminationPoint()) {
- if (terminationPoint.key().equals(tpKey)) {
- return Optional.of((InstanceIdentifier<Node>) managedNodeEntry.getSwitchRef().getValue());
- }
- }
+ TerminationPoint terminationPoint = switchNode.nonnullTerminationPoint().get(tpKey);
+ if (terminationPoint != null) {
+ return Optional.of((InstanceIdentifier<Node>) managedNodeEntry.getSwitchRef().getValue());
}
}
} else {
* 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.transactions.md;
import com.google.common.base.Preconditions;
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.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.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.HwvtepGlobalAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepNodeName;
}
}
- private InstanceIdentifier<TunnelIps> getTunnelIpIid(final String tunnelIp,
+ private static InstanceIdentifier<TunnelIps> getTunnelIpIid(final String tunnelIp,
final InstanceIdentifier<Node> psIid) {
IpAddress ip = IpAddressBuilder.getDefaultInstance(tunnelIp);
TunnelIps tunnelIps = new TunnelIpsBuilder().withKey(new TunnelIpsKey(ip)).setTunnelIpsKey(ip).build();
IpAddress ip = IpAddressBuilder.getDefaultInstance(tunnelIp);
InstanceIdentifier<TunnelIps> tunnelIpsInstanceIdentifier = getTunnelIpIid(tunnelIp, psIid);
TunnelIps tunnelIps = new TunnelIpsBuilder().withKey(new TunnelIpsKey(ip)).setTunnelIpsKey(ip).build();
- transaction.put(LogicalDatastoreType.OPERATIONAL, tunnelIpsInstanceIdentifier, tunnelIps, true);
+ transaction.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, tunnelIpsInstanceIdentifier,
+ tunnelIps);
}
}
NodeBuilder connectionNode = new NodeBuilder();
connectionNode.setNodeId(getOvsdbConnectionInstance().getNodeId());
- HwvtepGlobalAugmentationBuilder hgAugmentationBuilder = new HwvtepGlobalAugmentationBuilder();
- List<Switches> switches = new ArrayList<>();
InstanceIdentifier<Node> switchIid =
HwvtepSouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance(), phySwitch);
- hgAugmentationBuilder.setSwitches(switches);
Switches physicalSwitch = new SwitchesBuilder().setSwitchRef(new HwvtepPhysicalSwitchRef(switchIid)).build();
- switches.add(physicalSwitch);
- connectionNode.addAugmentation(HwvtepGlobalAugmentation.class, hgAugmentationBuilder.build());
+ connectionNode.addAugmentation(new HwvtepGlobalAugmentationBuilder()
+ .setSwitches(Map.of(physicalSwitch.key(), physicalSwitch))
+ .build());
- LOG.debug("Update node with physicalswitch ref {}", hgAugmentationBuilder.getSwitches().iterator().next());
+ LOG.debug("Update node with physicalswitch ref {}", physicalSwitch);
return connectionNode.build();
}
HwvtepGlobalAugmentationBuilder builder = new HwvtepGlobalAugmentationBuilder();
nodeBuilder.addAugmentation(HwvtepGlobalAugmentation.class, builder.build());
WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
- transaction.put(logicalDatastoreType, nodeIid, nodeBuilder.build(), WriteTransaction.CREATE_MISSING_PARENTS);
+ transaction.mergeParentStructurePut(logicalDatastoreType, nodeIid, nodeBuilder.build());
transaction.commit();
}
return mergeNode(logicalDatastoreType, nodeIid, nodeBuilder);
}
+ void deleteData(final LogicalDatastoreType datastoreType, InstanceIdentifier<?>... iids) {
+ WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
+ for (InstanceIdentifier<?> id : iids) {
+ transaction.delete(datastoreType, id);
+ }
+ transaction.commit();
+ }
+
void deleteData(final LogicalDatastoreType logicalDatastoreType, final Class<? extends DataObject> dataObject,
final String[]... data) {
NodeBuilder nodeBuilder = prepareNode(nodeIid);
final NodeBuilder nodeBuilder) {
Node node = nodeBuilder.build();
WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
- transaction.merge(datastoreType, id, node, WriteTransaction.CREATE_MISSING_PARENTS);
+ transaction.mergeParentStructureMerge(datastoreType, id, node);
transaction.commit();
return node;
}
import org.opendaylight.ovsdb.schema.hardwarevtep.LogicalSwitch;
import org.opendaylight.ovsdb.schema.hardwarevtep.McastMacsRemote;
import org.opendaylight.ovsdb.schema.hardwarevtep.UcastMacsRemote;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.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 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.locator.set.attributes.LocatorSet;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
addData(LogicalDatastoreType.OPERATIONAL, RemoteMcastMacs.class, mcastMacs);
resetOperations();
- addData(LogicalDatastoreType.CONFIGURATION, RemoteMcastMacs.class, mcastMac3WithZeroLocators);
+ final MacAddress macAddr = new MacAddress("FF:FF:FF:FF:FF:FF");
+ final InstanceIdentifier<HwvtepGlobalAugmentation> augIid =
+ nodeIid.augmentation(HwvtepGlobalAugmentation.class);
+ deleteData(LogicalDatastoreType.CONFIGURATION,
+ augIid.child(RemoteMcastMacs.class,
+ new RemoteMcastMacsKey(TestBuilders.buildLogicalSwitchesRef(nodeIid, "ls0"), macAddr))
+ .child(LocatorSet.class),
+ augIid.child(RemoteMcastMacs.class,
+ new RemoteMcastMacsKey(TestBuilders.buildLogicalSwitchesRef(nodeIid, "ls1"), macAddr))
+ .child(LocatorSet.class));
verify(Operations.op, times(2)).delete(ArgumentMatchers.any());
}
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
-import org.opendaylight.mdsal.binding.api.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;
deleteNode(nodeIid3);
}
- private void deleteNode(InstanceIdentifier<Node> iid) {
+ private void deleteNode(final InstanceIdentifier<Node> iid) {
ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
tx.delete(LogicalDatastoreType.CONFIGURATION, iid);
tx.commit();
}
- private InstanceIdentifier<Node> createInstanceIdentifier(String nodeIdString) {
+ private InstanceIdentifier<Node> createInstanceIdentifier(final String nodeIdString) {
NodeId nodeId = new NodeId(new Uri(nodeIdString));
NodeKey nodeKey = new NodeKey(nodeId);
TopologyKey topoKey = new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID);
private static class AddNodeCmd extends DefaultTransactionComamndImpl {
InstanceIdentifier<Node> iid;
- AddNodeCmd(InstanceIdentifier<Node> iid, SettableFuture ft) {
+ AddNodeCmd(final InstanceIdentifier<Node> iid, final SettableFuture ft) {
super(ft);
this.iid = iid;
}
@Override
- public void execute(ReadWriteTransaction transaction) {
+ public void execute(final ReadWriteTransaction transaction) {
NodeBuilder nodeBuilder = new NodeBuilder();
nodeBuilder.setNodeId(iid.firstKeyOf(Node.class).getNodeId());
HwvtepGlobalAugmentationBuilder builder = new HwvtepGlobalAugmentationBuilder();
nodeBuilder.addAugmentation(HwvtepGlobalAugmentation.class, builder.build());
- transaction.put(LogicalDatastoreType.CONFIGURATION, iid, nodeBuilder.build(),
- WriteTransaction.CREATE_MISSING_PARENTS);
+ transaction.mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, iid, nodeBuilder.build());
}
}
private static class DeleteNodeCmd extends DefaultTransactionComamndImpl {
InstanceIdentifier<Node> iid;
- DeleteNodeCmd(InstanceIdentifier<Node> iid, SettableFuture ft) {
+ DeleteNodeCmd(final InstanceIdentifier<Node> iid, final SettableFuture ft) {
super(ft);
this.iid = iid;
}
@Override
- public void execute(ReadWriteTransaction transaction) {
+ public void execute(final ReadWriteTransaction transaction) {
transaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
}
}
private static class DefaultTransactionComamndImpl implements TransactionCommand {
SettableFuture ft;
- DefaultTransactionComamndImpl(SettableFuture ft) {
+ DefaultTransactionComamndImpl(final SettableFuture ft) {
this.ft = ft;
}
@Override
- public void execute(ReadWriteTransaction transaction) {
+ public void execute(final ReadWriteTransaction transaction) {
}
@Override
- public void setTransactionResultFuture(FluentFuture future) {
- future.addCallback(new FutureCallback<Object>() {
+ public void setTransactionResultFuture(final FluentFuture future) {
+ future.addCallback(new FutureCallback<>() {
@Override
- public void onSuccess(Object notUsed) {
+ public void onSuccess(final Object notUsed) {
ft.set(null);
}
@Override
- public void onFailure(Throwable throwable) {
+ public void onFailure(final Throwable throwable) {
ft.setException(throwable);
}
}, MoreExecutors.directExecutor());
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<dependencies>
<dependency>
<groupId>org.opendaylight.odlparent</groupId>
- <artifactId>odl-jackson-2.9</artifactId>
- <version>6.0.4</version>
+ <artifactId>odl-jackson-2.10</artifactId>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.odlparent</groupId>
+ <artifactId>odl-netty-4</artifactId>
<type>xml</type>
<classifier>features</classifier>
</dependency>
-->
<features name="odl-ovsdb-library-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-library" version="${project.version}">
- <feature version="[6,7)">odl-jackson-2.9</feature>
+ <feature version="[7,8)">odl-jackson-2.10</feature>
+ <feature version="[7,8)">odl-netty-4</feature>
<configfile finalname="etc/org.opendaylight.ovsdb.library.cfg">
mvn:org.opendaylight.ovsdb/library/${project.version}/cfg/config
</configfile>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.ovsdb</groupId>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>aaa-cert</artifactId>
- <version>0.12.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
+ <optional>true</optional>
</dependency>
<dependency>
<groupId>javax.annotation</groupId>
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
-
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
-
import org.opendaylight.ovsdb.lib.OvsdbClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public void close() {
}
-}
\ No newline at end of file
+}
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.SettableFuture;
-
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.junit.MockitoJUnitRunner;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
* 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.schema.hardwarevtep;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
import org.opendaylight.ovsdb.lib.schema.typed.MethodType;
* 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.schema.hardwarevtep;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
* 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.schema.openvswitch;
import java.util.Map;
-
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
import org.opendaylight.ovsdb.lib.schema.typed.MethodType;
* 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.schema.openvswitch;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
* 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.schema.openvswitch;
import java.util.Map;
-
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
import org.opendaylight.ovsdb.lib.schema.typed.MethodType;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>5.0.9</version>
+ <version>6.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<type>xml</type>
<classifier>features</classifier>
</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>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>odl-infrautils-diagstatus</artifactId>
<type>xml</type>
<classifier>features</classifier>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.serviceutils</groupId>
+ <artifactId>odl-serviceutils-tools</artifactId>
+ <version>0.6.0-SNAPSHOT</version>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.ovsdb</groupId>
+ <artifactId>odl-ovsdb-utils</artifactId>
+ <version>${project.version}</version>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>odl-ovsdb-southbound-api</artifactId>
<type>cfg</type>
<classifier>config</classifier>
</dependency>
-
- <dependency>
- <groupId>javax.inject</groupId>
- <artifactId>javax.inject</artifactId>
- </dependency>
</dependencies>
-
- <!--
- <feature name='odl-ovsdb-southbound-impl' version='${project.version}' description=' '>
- <bundle>mvn:org.opendaylight.ovsdb/southbound-impl/{{VERSION}}</bundle>
- <bundle>mvn:org.opendaylight.ovsdb/library/{{VERSION}}</bundle>
- <bundle>mvn:org.opendaylight.ovsdb/utils.yang-utils/{{VERSION}}</bundle>
- <bundle>mvn:com.fasterxml.jackson.core/jackson-annotations/{{VERSION}}</bundle>
- <bundle>mvn:com.fasterxml.jackson.core/jackson-core/{{VERSION}}</bundle>
- <bundle>mvn:com.fasterxml.jackson.core/jackson-databind/{{VERSION}}</bundle>
- <bundle>mvn:com.google.code.gson/gson/{{VERSION}}</bundle>
- <bundle>mvn:io.netty/netty-buffer/{{VERSION}}</bundle>
- <bundle>mvn:io.netty/netty-codec/{{VERSION}}</bundle>
- <bundle>mvn:io.netty/netty-codec-http/{{VERSION}}</bundle>
- <bundle>mvn:io.netty/netty-common/{{VERSION}}</bundle>
- <bundle>mvn:io.netty/netty-handler/{{VERSION}}</bundle>
- <bundle>mvn:io.netty/netty-transport/{{VERSION}}</bundle>
- <feature version="${project.version}">odl-ovsdb-library</feature>
- </feature>
- -->
-
</project>
-->
<features name="odl-ovsdb-southbound-impl-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-southbound-impl" version="${project.version}">
- <feature version="[6,7)">odl-jackson-2.9</feature>
+ <feature version="[7,8)">odl-jackson-2.10</feature>
<configfile finalname="etc/org.opendaylight.ovsdb.southbound.cfg">
mvn:org.opendaylight.ovsdb/southbound-impl/${project.version}/cfg/config
</configfile>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
<scope>test</scope>
</dependency>
<dependency>
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.southbound;
import java.net.URI;
import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class InstanceIdentifierCodec extends AbstractModuleStringInstanceIdentifierCodec
- implements SchemaContextListener {
+ implements EffectiveModelContextListener {
private static final Logger LOG = LoggerFactory.getLogger(InstanceIdentifierCodec.class);
+ private final BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer;
+
private DataSchemaContextTree dataSchemaContextTree;
private SchemaContext context;
- private final BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer;
public InstanceIdentifierCodec(DOMSchemaService schemaService,
BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer) {
}
@Override
- public void onGlobalContextUpdated(SchemaContext schemaContext) {
+ public void onModelContextUpdated(EffectiveModelContext schemaContext) {
this.context = schemaContext;
this.dataSchemaContextTree = DataSchemaContextTree.from(schemaContext);
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIds;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
private Entity connectedEntity;
private EntityOwnershipCandidateRegistration deviceOwnershipCandidateRegistration;
private OvsdbNodeAugmentation initialCreateData = null;
- private Map<UUID, InstanceIdentifier<Node>> ports = new ConcurrentHashMap<>();
- private Map<String, InstanceIdentifier<Node>> portInterfaces = new ConcurrentHashMap<>();
+ private final Map<UUID, InstanceIdentifier<Node>> ports = new ConcurrentHashMap<>();
+ private final Map<String, InstanceIdentifier<Node>> portInterfaces = new ConcurrentHashMap<>();
OvsdbConnectionInstance(final ConnectionInfo key, final OvsdbClient client, final TransactionInvoker txInvoker,
final InstanceIdentifier<Node> iid) {
// OpenVSwitchPart
OpenVSwitch ovs = transaction.getTypedRowWrapper(OpenVSwitch.class);
- List<OpenvswitchExternalIds> externalIds = this.initialCreateData.getOpenvswitchExternalIds();
+ Map<OpenvswitchExternalIdsKey, OpenvswitchExternalIds> externalIds =
+ this.initialCreateData.getOpenvswitchExternalIds();
stampInstanceIdentifier(transaction, this.instanceIdentifier.firstIdentifierOf(Node.class),
instanceIdentifierCodec);
- List<OpenvswitchOtherConfigs> otherConfigs = this.initialCreateData.getOpenvswitchOtherConfigs();
+ Map<OpenvswitchOtherConfigsKey, OpenvswitchOtherConfigs> otherConfigs =
+ this.initialCreateData.getOpenvswitchOtherConfigs();
if (otherConfigs != null) {
try {
ovs.setOtherConfig(YangUtils.convertYangKeyValueListToMap(otherConfigs,
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
Node ovsdbNode = ovsdbNodeOpt.get();
OvsdbNodeAugmentation nodeAugmentation = ovsdbNode.augmentation(OvsdbNodeAugmentation.class);
if (nodeAugmentation != null) {
- if (nodeAugmentation.getManagedNodeEntry() != null) {
- for (ManagedNodeEntry managedNode : nodeAugmentation.getManagedNodeEntry()) {
+ Map<ManagedNodeEntryKey, ManagedNodeEntry> entries = nodeAugmentation.getManagedNodeEntry();
+ if (entries != null) {
+ for (ManagedNodeEntry managedNode : entries.values()) {
transaction.delete(
LogicalDatastoreType.OPERATIONAL, managedNode.getBridgeRef().getValue());
}
package org.opendaylight.ovsdb.southbound;
import java.util.concurrent.atomic.AtomicBoolean;
-
import org.opendaylight.ovsdb.lib.MonitorCallBack;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.slf4j.LoggerFactory;
public class OvsdbMonitorCallback implements MonitorCallBack {
-
private static final Logger LOG = LoggerFactory.getLogger(OvsdbMonitorCallback.class);
+
private final InstanceIdentifierCodec instanceIdentifierCodec;
private TransactionInvoker txInvoker;
private OvsdbConnectionInstance key;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.southbound;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.slf4j.LoggerFactory;
public class OvsdbOperGlobalListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
+ public static final ConcurrentMap<InstanceIdentifier<Node>, Node> OPER_NODE_CACHE = new ConcurrentHashMap<>();
private static final Logger LOG = LoggerFactory.getLogger(OvsdbOperGlobalListener.class);
+
private ListenerRegistration<OvsdbOperGlobalListener> registration;
private DataBroker db;
- public static final ConcurrentMap<InstanceIdentifier<Node>, Node> OPER_NODE_CACHE = new ConcurrentHashMap<>();
private final OvsdbConnectionManager ovsdbConnectionManager;
private final TransactionInvoker txInvoker;
-
OvsdbOperGlobalListener(DataBroker db, OvsdbConnectionManager ovsdbConnectionManager,
TransactionInvoker txInvoker) {
LOG.info("Registering OvsdbOperGlobalListener");
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
-
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeNetdev;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.QosTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
return datapathtype;
}
- public static Class<? extends DatapathTypeBase> createDatapathType(final String type) {
- Preconditions.checkNotNull(type);
+ public static Class<? extends DatapathTypeBase> createDatapathType(final String type) {
if (type.isEmpty()) {
return DatapathTypeSystem.class;
- } else {
- ImmutableBiMap<String, Class<? extends DatapathTypeBase>> mapper =
- SouthboundConstants.DATAPATH_TYPE_MAP.inverse();
- return mapper.get(type);
}
+ return SouthboundConstants.DATAPATH_TYPE_MAP.inverse().get(type);
}
public static Set<String> createOvsdbBridgeProtocols(final OvsdbBridgeAugmentation ovsdbBridgeNode) {
Set<String> protocols = new HashSet<>();
- if (ovsdbBridgeNode.getProtocolEntry() != null && ovsdbBridgeNode.getProtocolEntry().size() > 0) {
- for (ProtocolEntry protocol : ovsdbBridgeNode.getProtocolEntry()) {
- if (SouthboundConstants.OVSDB_PROTOCOL_MAP.get(protocol.getProtocol()) != null) {
- protocols.add(SouthboundConstants.OVSDB_PROTOCOL_MAP.get(protocol.getProtocol()));
- } else {
- throw new IllegalArgumentException("Unknown protocol " + protocol.getProtocol());
- }
+ Map<ProtocolEntryKey, ProtocolEntry> entries = ovsdbBridgeNode.getProtocolEntry();
+ if (entries != null) {
+ for (ProtocolEntry protocol : entries.values()) {
+ Class<? extends OvsdbBridgeProtocolBase> lookup = protocol.getProtocol();
+ final String toAdd = SouthboundConstants.OVSDB_PROTOCOL_MAP.get(protocol.getProtocol());
+ Preconditions.checkArgument(toAdd != null, "Unknown protocol %s", lookup);
+ protocols.add(toAdd);
}
}
return protocols;
schemaMismatchLog("protocols", "Bridge", e);
}
List<ProtocolEntry> protocolList = new ArrayList<>();
- if (protocols != null && protocols.size() > 0) {
+ if (protocols != null && !protocols.isEmpty()) {
ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
for (String protocol : protocols) {
- if (protocol != null && mapper.get(protocol) != null) {
- protocolList.add(new ProtocolEntryBuilder().setProtocol(mapper.get(protocol)).build());
+ if (protocol != null) {
+ final Class<? extends OvsdbBridgeProtocolBase> mapped = mapper.get(protocol);
+ if (mapped != null) {
+ protocolList.add(new ProtocolEntryBuilder().setProtocol(mapped).build());
+ }
}
}
}
return controllerEntriesCreated;
}
- final List<ControllerEntry> controllerEntries = ovsdbBridgeAugmentation.getControllerEntry();
+ final Map<ControllerEntryKey, ControllerEntry> controllerEntries = ovsdbBridgeAugmentation.getControllerEntry();
if (controllerEntries != null) {
- for (ControllerEntry controllerEntry : controllerEntries) {
+ for (ControllerEntry controllerEntry : controllerEntries.values()) {
final Controller controller = updatedControllerRows.get(
new UUID(controllerEntry.getControllerUuid().getValue()));
addControllerEntries(controllerEntriesCreated, controller);
// This is not called from anywhere but test. Do we need this?
public static Map<UUID, Controller> createOvsdbController(final OvsdbBridgeAugmentation omn,
final DatabaseSchema dbSchema) {
- List<ControllerEntry> controllerEntries = omn.getControllerEntry();
+ Map<ControllerEntryKey, ControllerEntry> controllerEntries = omn.getControllerEntry();
Map<UUID,Controller> controllerMap = new HashMap<>();
if (controllerEntries != null && !controllerEntries.isEmpty()) {
- for (ControllerEntry controllerEntry : controllerEntries) {
+ for (ControllerEntry controllerEntry : controllerEntries.values()) {
String controllerNamedUuid = "Controller_" + getRandomUuid();
Controller controller = TypedDatabaseSchema.of(dbSchema).getTypedRowWrapper(Controller.class);
controller.setTarget(controllerEntry.getTarget().getValue());
return managerEntriesCreated;
}
- final List<ManagerEntry> managerEntries = ovsdbNodeAugmentation.getManagerEntry();
+ final Map<ManagerEntryKey, ManagerEntry> managerEntries = ovsdbNodeAugmentation.getManagerEntry();
if (managerEntries != null) {
- for (ManagerEntry managerEntry : managerEntries) {
+ for (ManagerEntry managerEntry : managerEntries.values()) {
final Manager manager = updatedManagerRows.get(managerEntry.getTarget());
addManagerEntries(managerEntriesCreated, manager);
}
SouthboundMapper.createInstanceIdentifier(bridgeNode.getNodeId());
changes.put(bridgeNodeIid, bridgeNode);
- List<TerminationPoint> terminationPoints = bridgeNode.getTerminationPoint();
- if (terminationPoints != null && !terminationPoints.isEmpty()) {
- for (TerminationPoint tp : terminationPoints) {
+ Map<TerminationPointKey, TerminationPoint> terminationPoints = bridgeNode.getTerminationPoint();
+ if (terminationPoints != null) {
+ for (TerminationPoint tp : terminationPoints.values()) {
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
tp.augmentation(OvsdbTerminationPointAugmentation.class);
if (ovsdbTerminationPointAugmentation != null) {
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-
import org.opendaylight.infrautils.diagstatus.DiagStatusService;
import org.opendaylight.infrautils.diagstatus.ServiceState;
import org.opendaylight.infrautils.ready.SystemReadyMonitor;
@Singleton
public class SouthboundProvider implements ClusteredDataTreeChangeListener<Topology>, AutoCloseable {
-
private static final Logger LOG = LoggerFactory.getLogger(SouthboundProvider.class);
-
private static final String ENTITY_TYPE = "ovsdb-southbound-provider";
+ // FIXME: get rid of this static
+ @SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
+ private static DataBroker db;
+
public static DataBroker getDb() {
return db;
}
- // FIXME: get rid of this static
- @SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
- private static DataBroker db;
private OvsdbConnectionManager cm;
private TransactionInvoker txInvoker;
private OvsdbDataTreeChangeListener ovsdbDataTreeChangeListener;
if (!ovsdbTp.get().isPresent()) {
TopologyBuilder tpb = new TopologyBuilder();
tpb.setTopologyId(SouthboundConstants.OVSDB_TOPOLOGY_ID);
- transaction.put(type, path, tpb.build(), true);
+ transaction.mergeParentStructurePut(type, path, tpb.build());
transaction.commit();
} else {
transaction.cancel();
import java.util.Enumeration;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
-
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.slf4j.LoggerFactory;
public final class SouthboundUtil {
-
private static final Logger LOG = LoggerFactory.getLogger(SouthboundUtil.class);
private static final String SCHEMA_VERSION_MISMATCH =
"{} column for {} table is not supported by this version of the {} schema: {}";
+ private static final InterfaceExternalIds INTERACE_CREATED_BY_OPENDAYLIGHT = createExternalIdsForInterface(
+ SouthboundConstants.CREATED_BY, SouthboundConstants.ODL);
+ private static final PortExternalIds PORT_CREATED_BY_OPENDAYLIGHT = createExternalIdsForPort(
+ SouthboundConstants.CREATED_BY, SouthboundConstants.ODL);
private SouthboundUtil() {
// Prevent instantiating a utility class
.setExternalIdValue(value).build();
}
+ public static InterfaceExternalIds interfaceCreatedByOpenDaylight() {
+ return INTERACE_CREATED_BY_OPENDAYLIGHT;
+ }
+
+ public static PortExternalIds portCreatedByOpenDaylight() {
+ return PORT_CREATED_BY_OPENDAYLIGHT;
+ }
+
@SuppressWarnings("checkstyle:IllegalCatch")
public static String getOvsdbNodeId(InstanceIdentifier<Node> nodeIid) {
String nodeId = "";
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
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.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.ovsdb.southbound.SouthboundProvider;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.Autoattach;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.AutoattachKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
final OvsdbNodeAugmentation deletedOvsdbNodeAugmentation = updated.get(ovsdbNodeIid);
if (ovsdbNodeAugmentation != null && deletedOvsdbNodeAugmentation != null) {
- final List<Autoattach> origAutoattachList = ovsdbNodeAugmentation.getAutoattach();
- final List<Autoattach> deletedAutoattachList = deletedOvsdbNodeAugmentation.getAutoattach();
+ final Map<AutoattachKey, Autoattach> origAutoattachList = ovsdbNodeAugmentation.getAutoattach();
+ final Map<AutoattachKey, Autoattach> deletedAutoattachList =
+ deletedOvsdbNodeAugmentation.getAutoattach();
if (origAutoattachList != null && !origAutoattachList.isEmpty()
&& (deletedAutoattachList == null || deletedAutoattachList.isEmpty())) {
}
final OvsdbNodeAugmentation currentOvsdbNode =
state.getBridgeNode(ovsdbNodeIid).get().augmentation(OvsdbNodeAugmentation.class);
- final List<Autoattach> currentAutoAttach = currentOvsdbNode.getAutoattach();
- for (final Autoattach origAutoattach : origAutoattachList) {
- final Uri autoAttachId = origAutoattach.getAutoattachId();
- deleteAutoAttach(transaction, ovsdbNodeIid, getAutoAttachUuid(currentAutoAttach, autoAttachId));
+ final Map<AutoattachKey, Autoattach> currentAutoAttach = currentOvsdbNode.getAutoattach();
+ for (final Autoattach origAutoattach : origAutoattachList.values()) {
+ deleteAutoAttach(transaction, ovsdbNodeIid, getAutoAttachUuid(currentAutoAttach,
+ origAutoattach.key()));
}
}
}
}
}
- private Uuid getAutoAttachUuid(final List<Autoattach> currentAutoAttach, final Uri autoAttachId) {
- if (currentAutoAttach != null && !currentAutoAttach.isEmpty()) {
- for (final Autoattach autoAttach : currentAutoAttach) {
- if (autoAttach.getAutoattachId().equals(autoAttachId)) {
- return autoAttach.getAutoattachUuid();
- }
+ private static Uuid getAutoAttachUuid(final Map<AutoattachKey, Autoattach> currentAutoAttach,
+ final AutoattachKey autoAttachId) {
+ if (currentAutoAttach != null) {
+ final Autoattach autoAttach = currentAutoAttach.get(autoAttachId);
+ if (autoAttach != null) {
+ return autoAttach.getAutoattachUuid();
}
}
return null;
}
- private OvsdbBridgeAugmentation getBridge(final InstanceIdentifier<OvsdbNodeAugmentation> key, final Uuid aaUuid) {
+ private static OvsdbBridgeAugmentation getBridge(final InstanceIdentifier<OvsdbNodeAugmentation> key,
+ final Uuid aaUuid) {
if (aaUuid == null) {
return null;
}
try (ReadTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction()) {
final Optional<Node> nodeOptional = SouthboundUtil.readNode(transaction, nodeIid);
if (nodeOptional.isPresent()) {
- final List<ManagedNodeEntry> managedNodes =
+ final Map<ManagedNodeEntryKey, ManagedNodeEntry> managedNodes =
nodeOptional.get().augmentation(OvsdbNodeAugmentation.class).getManagedNodeEntry();
- for (final ManagedNodeEntry managedNode : managedNodes) {
+ for (final ManagedNodeEntry managedNode : managedNodes.values()) {
final OvsdbBridgeRef ovsdbBridgeRef = managedNode.getBridgeRef();
final InstanceIdentifier<OvsdbBridgeAugmentation> brIid = ovsdbBridgeRef.getValue()
.firstIdentifierOf(Node.class).augmentation(OvsdbBridgeAugmentation.class);
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
-import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
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 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.Autoattach;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.AutoattachKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.AutoattachExternalIds;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.AutoattachExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.Mappings;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.MappingsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
if (!state.getBridgeNode(iid).isPresent()) {
return;
}
- final List<Autoattach> autoAttachList = ovsdbNode.getAutoattach();
+ final Map<AutoattachKey, Autoattach> autoAttachList = ovsdbNode.getAutoattach();
if (autoAttachList != null) {
if (true) {
// FIXME: Remove if loop after ovs community supports external_ids column in AutoAttach Table
final OvsdbNodeAugmentation currentOvsdbNode =
state.getBridgeNode(iid).get().augmentation(OvsdbNodeAugmentation.class);
- final List<Autoattach> currentAutoAttach = currentOvsdbNode.getAutoattach();
- for (final Autoattach autoAttach : autoAttachList) {
+ final Map<AutoattachKey, Autoattach> currentAutoAttach = currentOvsdbNode.getAutoattach();
+ for (final Autoattach autoAttach : autoAttachList.values()) {
final AutoAttach autoAttachWrapper = transaction.getTypedRowWrapper(AutoAttach.class);
if (autoAttach.getSystemName() != null) {
autoAttachWrapper.setSystemName(autoAttach.getSystemName());
autoAttachWrapper.setSystemDescription(autoAttach.getSystemDescription());
}
- final List<Mappings> mappingsList = autoAttach.getMappings();
+ final Map<MappingsKey, Mappings> mappingsList = autoAttach.getMappings();
if (mappingsList != null && !mappingsList.isEmpty()) {
final Map<Long, Long> newMappings = new HashMap<>();
- for (final Mappings mappings : mappingsList) {
- final Long mappingsValue = new Long(mappings.getMappingsValue().toString());
- newMappings.put(mappings.getMappingsKey().toJava(), mappingsValue);
+ for (final Mappings mappings : mappingsList.values()) {
+ newMappings.put(mappings.getMappingsKey().toJava(), mappings.getMappingsValue().longValue());
}
autoAttachWrapper.setMappings(newMappings);
}
- final List<AutoattachExternalIds> externalIds = autoAttach.getAutoattachExternalIds();
+ final Map<AutoattachExternalIdsKey, AutoattachExternalIds> externalIds =
+ autoAttach.getAutoattachExternalIds();
final Map<String, String> externalIdsMap = new HashMap<>();
if (externalIds != null) {
- for (final AutoattachExternalIds externalId : externalIds) {
+ for (final AutoattachExternalIds externalId : externalIds.values()) {
externalIdsMap.put(externalId.getAutoattachExternalIdKey(),
externalId.getAutoattachExternalIdValue());
}
// LOG.warn("Incomplete AutoAttach external IDs");
// }
- final Uuid aaUuid = getAutoAttachUuid(currentAutoAttach, autoAttach.getAutoattachId());
+ final Uuid aaUuid = getAutoAttachUuid(currentAutoAttach, autoAttach.key());
if (aaUuid != null) {
final UUID uuid = new UUID(aaUuid.getValue());
final AutoAttach newAutoAttach = transaction.getTypedRowSchema(AutoAttach.class);
}
}
- private OvsdbBridgeAugmentation getBridge(final InstanceIdentifier<OvsdbNodeAugmentation> key,
+ private static OvsdbBridgeAugmentation getBridge(final InstanceIdentifier<OvsdbNodeAugmentation> key,
final Uri bridgeUri) {
final InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid = InstanceIdentifier
.create(NetworkTopology.class)
return bridge;
}
- private Uuid getAutoAttachUuid(final List<Autoattach> currentAutoAttach, final Uri autoattachId) {
- if (currentAutoAttach != null && !currentAutoAttach.isEmpty()) {
- for (final Autoattach autoAttach : currentAutoAttach) {
- if (autoAttach.getAutoattachId().equals(autoattachId)) {
- return autoAttach.getAutoattachUuid();
- }
+ private static Uuid getAutoAttachUuid(final Map<AutoattachKey, Autoattach> currentAutoAttach,
+ final AutoattachKey autoattachId) {
+ if (currentAutoAttach != null) {
+ final Autoattach found = currentAutoAttach.get(autoattachId);
+ if (found != null) {
+ return found.getAutoattachUuid();
}
}
return null;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
import java.util.Collection;
+import java.util.Map;
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;
public class BridgeOperationalState {
private static final Logger LOG = LoggerFactory.getLogger(BridgeOperationalState.class);
- private DataBroker db;
+ private final DataBroker db;
public BridgeOperationalState(DataBroker db, DataChangeEvent changes) {
this.db = db;
if (nodeOptional.isPresent() && nodeOptional.get().getTerminationPoint() != null) {
TerminationPointKey key = iid.firstKeyOf(TerminationPoint.class);
if (key != null) {
- for (TerminationPoint tp:nodeOptional.get().getTerminationPoint()) {
- if (tp.key().equals(key)) {
- return Optional.of(tp);
- }
+ final TerminationPoint tp = nodeOptional.get().nonnullTerminationPoint().get(key);
+ if (tp != null) {
+ return Optional.of(tp);
}
}
} else {
public Optional<ControllerEntry> getControllerEntry(InstanceIdentifier<?> iid) {
if (iid != null) {
Optional<OvsdbBridgeAugmentation> ovsdbBridgeOptional = getOvsdbBridgeAugmentation(iid);
- if (ovsdbBridgeOptional.isPresent() && ovsdbBridgeOptional.get().getControllerEntry() != null) {
- ControllerEntryKey key = iid.firstKeyOf(ControllerEntry.class);
- if (key != null) {
- for (ControllerEntry entry: ovsdbBridgeOptional.get().getControllerEntry()) {
- if (entry.key().equals(key)) {
+ if (ovsdbBridgeOptional.isPresent()) {
+ Map<ControllerEntryKey, ControllerEntry> entries = ovsdbBridgeOptional.get().getControllerEntry();
+ if (entries != null) {
+ ControllerEntryKey key = iid.firstKeyOf(ControllerEntry.class);
+ if (key != null) {
+ ControllerEntry entry = entries.get(key);
+ if (entry != null) {
return Optional.of(entry);
}
}
public Optional<ProtocolEntry> getProtocolEntry(InstanceIdentifier<ProtocolEntry> iid) {
if (iid != null) {
Optional<OvsdbBridgeAugmentation> ovsdbBridgeOptional = getOvsdbBridgeAugmentation(iid);
- if (ovsdbBridgeOptional.isPresent() && ovsdbBridgeOptional.get().getProtocolEntry() != null) {
- ProtocolEntryKey key = iid.firstKeyOf(ProtocolEntry.class);
- if (key != null) {
- for (ProtocolEntry entry: ovsdbBridgeOptional.get().getProtocolEntry()) {
- if (entry.key().equals(key)) {
+ if (ovsdbBridgeOptional.isPresent()) {
+ Map<ProtocolEntryKey, ProtocolEntry> entries = ovsdbBridgeOptional.get().getProtocolEntry();
+ if (entries != null) {
+ ProtocolEntryKey key = iid.firstKeyOf(ProtocolEntry.class);
+ if (key != null) {
+ ProtocolEntry entry = entries.get(key);
+ if (entry != null) {
return Optional.of(entry);
}
}
}
return Optional.empty();
}
-
}
import java.util.Collection;
import java.util.Collections;
-import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
- List<OpenvswitchOtherConfigs> otherConfigs = ovsdbNode.getOpenvswitchOtherConfigs();
+ Map<OpenvswitchOtherConfigsKey, OpenvswitchOtherConfigs> otherConfigs =
+ ovsdbNode.getOpenvswitchOtherConfigs();
if (otherConfigs != null) {
try {
ovs.setOtherConfig(YangUtils.convertYangKeyValueListToMap(otherConfigs,
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import java.util.Collection;
-import java.util.List;
import java.util.Map;
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 org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntries;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
OvsdbNodeAugmentation update = updated.get(ovsdbNodeIid);
if (original != null && update != null) {
- List<QosEntries> origQosEntries = original.getQosEntries();
- List<QosEntries> updatedQosEntries = update.getQosEntries();
+ Map<QosEntriesKey, QosEntries> origQosEntries = original.getQosEntries();
+ Map<QosEntriesKey, QosEntries> updatedQosEntries = update.getQosEntries();
if (origQosEntries != null && !origQosEntries.isEmpty()) {
- for (QosEntries origQosEntry : origQosEntries) {
+ for (QosEntries origQosEntry : origQosEntries.values()) {
OvsdbNodeAugmentation operNode =
state.getBridgeNode(ovsdbNodeIid).get().augmentation(OvsdbNodeAugmentation.class);
- List<QosEntries> operQosEntries = operNode.getQosEntries();
-
- boolean found = false;
- if (updatedQosEntries != null && !updatedQosEntries.isEmpty()) {
- for (QosEntries updatedQosEntry : updatedQosEntries) {
- if (origQosEntry.getQosId().equals(updatedQosEntry.getQosId())) {
- found = true;
- break;
- }
- }
- }
- if (!found) {
+ if (updatedQosEntries == null || !updatedQosEntries.containsKey(origQosEntry.key())) {
LOG.debug("Received request to delete QoS entry {}", origQosEntry.getQosId());
- Uuid qosUuid = getQosEntryUuid(operQosEntries, origQosEntry.getQosId());
+ Uuid qosUuid = getQosEntryUuid(operNode.getQosEntries(), origQosEntry.key());
if (qosUuid != null) {
Qos qos = transaction.getTypedRowSchema(Qos.class);
transaction.add(op.delete(qos.getSchema())
}
}
- private static Uuid getQosEntryUuid(final List<QosEntries> operQosEntries, final Uri qosId) {
+ private static Uuid getQosEntryUuid(final Map<QosEntriesKey, QosEntries> operQosEntries,
+ final QosEntriesKey qosId) {
if (operQosEntries != null && !operQosEntries.isEmpty()) {
- for (QosEntries qosEntry : operQosEntries) {
- if (qosEntry.getQosId().equals(qosId)) {
- return qosEntry.getQosUuid();
- }
+ QosEntries qosEntry = operQosEntries.get(qosId);
+ if (qosEntry != null) {
+ return qosEntry.getQosUuid();
}
}
return null;
import java.util.Collection;
import java.util.HashMap;
-import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.ovsdb.utils.yang.YangUtils;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbQueueRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosOtherConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QueueList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QueueListKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
qos.setType(SouthboundMapper.createQosType(qosEntry.getQosType()));
}
- List<QueueList> queueList = qosEntry.getQueueList();
+ Map<QueueListKey, QueueList> queueList = qosEntry.getQueueList();
Map<Long, UUID> newQueueList = new HashMap<>();
if (queueList != null && !queueList.isEmpty()) {
- for (QueueList queue : queueList) {
+ for (QueueList queue : queueList.values()) {
if (queue.getQueueRef() != null) {
newQueueList.put(queue.getQueueNumber().toJava(),
new UUID(getQueueUuid(queue.getQueueRef(), operNode)));
LOG.warn("Incomplete Qos other_config", e);
}
- Uuid operQosUuid = getQosEntryUuid(operNode.getQosEntries(), qosEntry.getQosId());
+ Uuid operQosUuid = getQosEntryUuid(operNode.getQosEntries(), qosEntry.key());
if (operQosUuid == null) {
UUID namedUuid = new UUID(SouthboundConstants.QOS_NAMED_UUID_PREFIX
+ TransactUtils.bytesToHexString(qosEntry.getQosId().getValue().getBytes(UTF_8)));
}
}
- private String getQueueUuid(final OvsdbQueueRef queueRef, final OvsdbNodeAugmentation operNode) {
+ private static String getQueueUuid(final OvsdbQueueRef queueRef, final OvsdbNodeAugmentation operNode) {
QueuesKey queueKey = queueRef.getValue().firstKeyOf(Queues.class);
- if (operNode.getQueues() != null && !operNode.getQueues().isEmpty()) {
- for (Queues queue : operNode.getQueues()) {
- if (queue.getQueueId().equals(queueKey.getQueueId())) {
- return queue.getQueueUuid().getValue();
- }
+ Map<QueuesKey, Queues> queues = operNode.getQueues();
+ if (queues != null) {
+ Queues queue = queues.get(queueKey);
+ if (queue != null) {
+ return queue.getQueueUuid().getValue();
}
}
return SouthboundConstants.QUEUE_NAMED_UUID_PREFIX
+ TransactUtils.bytesToHexString(queueKey.getQueueId().getValue().getBytes(UTF_8));
}
- private Uuid getQosEntryUuid(final List<QosEntries> operQosEntries, final Uri qosId) {
- if (operQosEntries != null && !operQosEntries.isEmpty()) {
- for (QosEntries qosEntry : operQosEntries) {
- if (qosEntry.getQosId().equals(qosId)) {
- return qosEntry.getQosUuid();
- }
+ private static Uuid getQosEntryUuid(final Map<QosEntriesKey, QosEntries> operQosEntries,
+ final QosEntriesKey qosId) {
+ if (operQosEntries != null) {
+ QosEntries qosEntry = operQosEntries.get(qosId);
+ if (qosEntry != null) {
+ return qosEntry.getQosUuid();
}
}
return null;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import java.util.Collection;
-import java.util.List;
import java.util.Map;
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 org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.Queues;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QueuesKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
TransactUtils.extractUpdated(modifications, OvsdbNodeAugmentation.class));
}
- private void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
- final Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> originals,
- final Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> updated) {
+ private static void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+ final Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> originals,
+ final Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> updated) {
for (Map.Entry<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> originalEntry : originals
.entrySet()) {
InstanceIdentifier<OvsdbNodeAugmentation> ovsdbNodeIid = originalEntry.getKey();
OvsdbNodeAugmentation update = updated.get(ovsdbNodeIid);
if (original != null && update != null) {
- List<Queues> origQueues = original.getQueues();
- List<Queues> updatedQueues = update.getQueues();
+ Map<QueuesKey, Queues> origQueues = original.getQueues();
+ Map<QueuesKey, Queues> updatedQueues = update.getQueues();
if (origQueues != null && !origQueues.isEmpty()) {
- for (Queues origQueue : origQueues) {
+ for (Queues origQueue : origQueues.values()) {
OvsdbNodeAugmentation operNode =
state.getBridgeNode(ovsdbNodeIid).get().augmentation(
OvsdbNodeAugmentation.class);
- List<Queues> operQueues = operNode.getQueues();
-
- boolean found = false;
- if (updatedQueues != null && !updatedQueues.isEmpty()) {
- for (Queues updatedQueue : updatedQueues) {
- if (origQueue.getQueueId().equals(updatedQueue.getQueueId())) {
- found = true;
- break;
- }
- }
- }
- if (!found) {
+ if (updatedQueues == null || !updatedQueues.containsKey(origQueue.key())) {
LOG.debug("Received request to delete Queue entry {}", origQueue.getQueueId());
- Uuid queueUuid = getQueueUuid(operQueues, origQueue.getQueueId());
+ Uuid queueUuid = getQueueUuid(operNode.getQueues(), origQueue.key());
if (queueUuid != null) {
Queue queue = transaction.getTypedRowSchema(Queue.class);
transaction.add(op.delete(queue.getSchema())
}
}
- private Uuid getQueueUuid(final List<Queues> operQueues, final Uri queueId) {
- if (operQueues != null && !operQueues.isEmpty()) {
- for (Queues queueEntry : operQueues) {
- if (queueEntry.getQueueId().equals(queueId)) {
- return queueEntry.getQueueUuid();
- }
+ private static Uuid getQueueUuid(final Map<QueuesKey, Queues> operQueues, final QueuesKey queueId) {
+ if (operQueues != null) {
+ Queues queueEntry = operQueues.get(queueId);
+ if (queueEntry != null) {
+ return queueEntry.getQueueUuid();
}
}
return null;
}
-
}
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.ovsdb.utils.yang.YangUtils;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.Queues;
OvsdbNodeAugmentation operNode =
state.getBridgeNode(iid).get().augmentation(OvsdbNodeAugmentation.class);
- Uuid operQueueUuid = getQueueEntryUuid(operNode.getQueues(), queueEntry.getQueueId());
+ Uuid operQueueUuid = getQueueEntryUuid(operNode.getQueues(), queueEntry.key());
if (operQueueUuid == null) {
UUID namedUuid = new UUID(SouthboundConstants.QUEUE_NAMED_UUID_PREFIX
+ TransactUtils.bytesToHexString(queueEntry.getQueueId().getValue().getBytes(UTF_8)));
}
}
- private static Uuid getQueueEntryUuid(final List<Queues> operQueues, final Uri queueId) {
- if (operQueues != null && !operQueues.isEmpty()) {
- for (Queues queueEntry : operQueues) {
- if (queueEntry.getQueueId().equals(queueId)) {
- return queueEntry.getQueueUuid();
- }
+ private static Uuid getQueueEntryUuid(final Map<QueuesKey, Queues> operQueues, final QueuesKey queueId) {
+ if (operQueues != null) {
+ Queues queueEntry = operQueues.get(queueId);
+ if (queueEntry != null) {
+ return queueEntry.getQueueUuid();
}
}
return null;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
-import java.util.ArrayList;
-import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
- List<InterfaceExternalIds> interfaceExternalIds =
+ Map<InterfaceExternalIdsKey, InterfaceExternalIds> interfaceExternalIds =
terminationPoint.getInterfaceExternalIds();
+ final InterfaceExternalIds odl = SouthboundUtil.interfaceCreatedByOpenDaylight();
+
if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
- interfaceExternalIds.add(SouthboundUtil.createExternalIdsForInterface(
- SouthboundConstants.CREATED_BY, SouthboundConstants.ODL));
+ interfaceExternalIds.put(odl.key(), odl);
} else {
- interfaceExternalIds = Arrays.asList(SouthboundUtil.createExternalIdsForInterface(
- SouthboundConstants.CREATED_BY, SouthboundConstants.ODL));
+ interfaceExternalIds = Map.of(odl.key(), odl);
}
try {
ovsInterface.setExternalIds(YangUtils.convertYangKeyValueListToMap(interfaceExternalIds,
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
- List<InterfaceOtherConfigs> interfaceOtherConfigs =
+ Map<InterfaceOtherConfigsKey, InterfaceOtherConfigs> interfaceOtherConfigs =
terminationPoint.getInterfaceOtherConfigs();
if (interfaceOtherConfigs != null && !interfaceOtherConfigs.isEmpty()) {
Map<String, String> otherConfigsMap = new HashMap<>();
- for (InterfaceOtherConfigs interfaceOtherConfig : interfaceOtherConfigs) {
+ for (InterfaceOtherConfigs interfaceOtherConfig : interfaceOtherConfigs.values()) {
otherConfigsMap.put(interfaceOtherConfig.getOtherConfigKey(),
interfaceOtherConfig.getOtherConfigValue());
}
final Interface ovsInterface) {
try {
- List<InterfaceLldp> interfaceLldpList =
+ Map<InterfaceLldpKey, InterfaceLldp> interfaceLldpList =
terminationPoint.getInterfaceLldp();
if (interfaceLldpList != null && !interfaceLldpList.isEmpty()) {
try {
final Interface ovsInterface) {
try {
- List<InterfaceBfd> interfaceBfdList = terminationPoint.getInterfaceBfd();
+ Map<InterfaceBfdKey, InterfaceBfd> interfaceBfdList = terminationPoint.getInterfaceBfd();
if (interfaceBfdList != null && !interfaceBfdList.isEmpty()) {
try {
ovsInterface.setBfd(YangUtils.convertYangKeyValueListToMap(interfaceBfdList,
final Port port, final String opendaylightIid) {
// Set the iid external_id
- List<PortExternalIds> portExternalIds = terminationPoint.getPortExternalIds();
+ Map<PortExternalIdsKey, PortExternalIds> portExternalIds = terminationPoint.getPortExternalIds();
+ PortExternalIds odl = SouthboundUtil.portCreatedByOpenDaylight();
+ PortExternalIds iid = SouthboundUtil.createExternalIdsForPort(
+ SouthboundConstants.IID_EXTERNAL_ID_KEY, opendaylightIid);
+
if (portExternalIds != null && !portExternalIds.isEmpty()) {
- portExternalIds.add(SouthboundUtil.createExternalIdsForPort(
- SouthboundConstants.CREATED_BY, SouthboundConstants.ODL));
- portExternalIds.add(SouthboundUtil.createExternalIdsForPort(
- SouthboundConstants.IID_EXTERNAL_ID_KEY, opendaylightIid));
+ portExternalIds.put(odl.key(), odl);
+ portExternalIds.put(iid.key(), iid);
} else {
- portExternalIds = new ArrayList<>();
- portExternalIds.add(SouthboundUtil.createExternalIdsForPort(
- SouthboundConstants.CREATED_BY, SouthboundConstants.ODL));
- portExternalIds.add(SouthboundUtil.createExternalIdsForPort(
- SouthboundConstants.IID_EXTERNAL_ID_KEY, opendaylightIid));
+ portExternalIds = Map.of(odl.key(), odl, iid.key(), iid);
}
try {
port.setExternalIds(YangUtils.convertYangKeyValueListToMap(portExternalIds,
private void createPortOtherConfig(
final OvsdbTerminationPointAugmentation terminationPoint,
final Port ovsPort) {
- List<PortOtherConfigs> portOtherConfigs =
+ Map<PortOtherConfigsKey, PortOtherConfigs> portOtherConfigs =
terminationPoint.getPortOtherConfigs();
if (portOtherConfigs != null && !portOtherConfigs.isEmpty()) {
try {
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
-import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbQosRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntries;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
// First check if QosEntry is present and use that
if (terminationPoint.getQosEntry() != null && !terminationPoint.getQosEntry().isEmpty()) {
- OvsdbQosRef qosRef = terminationPoint.getQosEntry().iterator().next().getQosRef();
+ OvsdbQosRef qosRef = terminationPoint.getQosEntry().values().iterator().next().getQosRef();
Uri qosId = qosRef.getValue().firstKeyOf(QosEntries.class).getQosId();
OvsdbNodeAugmentation operNode = getOperNode(operBridge);
- if (operNode != null && operNode.getQosEntries() != null
- && !operNode.getQosEntries().isEmpty()) {
- for (QosEntries qosEntry : operNode.getQosEntries()) {
- if (qosEntry.getQosId().equals(qosId)) {
+ if (operNode != null) {
+ Map<QosEntriesKey, QosEntries> entries = operNode.getQosEntries();
+ if (entries != null) {
+ QosEntries qosEntry = entries.get(new QosEntriesKey(qosId));
+ if (qosEntry != null) {
uuidSet.add(new UUID(qosEntry.getQosUuid().getValue()));
}
}
private static void updateInterfaceExternalIds(final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
- List<InterfaceExternalIds> interfaceExternalIds =
+ Map<InterfaceExternalIdsKey, InterfaceExternalIds> interfaceExternalIds =
terminationPoint.getInterfaceExternalIds();
+ final InterfaceExternalIds odl = SouthboundUtil.interfaceCreatedByOpenDaylight();
+
if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
- interfaceExternalIds.add(SouthboundUtil.createExternalIdsForInterface(
- SouthboundConstants.CREATED_BY, SouthboundConstants.ODL));
+ interfaceExternalIds.put(odl.key(), odl);
} else {
- interfaceExternalIds = Arrays.asList(SouthboundUtil.createExternalIdsForInterface(
- SouthboundConstants.CREATED_BY, SouthboundConstants.ODL));
+ interfaceExternalIds = Map.of(odl.key(), odl);
}
try {
ovsInterface.setExternalIds(YangUtils.convertYangKeyValueListToMap(interfaceExternalIds,
private static void updateInterfaceLldp(final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
try {
- List<InterfaceLldp> interfaceLldpList =
+ Map<InterfaceLldpKey, InterfaceLldp> interfaceLldpList =
terminationPoint.getInterfaceLldp();
if (interfaceLldpList != null && !interfaceLldpList.isEmpty()) {
try {
private static void updateInterfaceOtherConfig(final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
- List<InterfaceOtherConfigs> interfaceOtherConfigs =
+ Map<InterfaceOtherConfigsKey, InterfaceOtherConfigs> interfaceOtherConfigs =
terminationPoint.getInterfaceOtherConfigs();
if (interfaceOtherConfigs != null && !interfaceOtherConfigs.isEmpty()) {
Map<String, String> otherConfigsMap = new HashMap<>();
- for (InterfaceOtherConfigs interfaceOtherConfig : interfaceOtherConfigs) {
+ for (InterfaceOtherConfigs interfaceOtherConfig : interfaceOtherConfigs.values()) {
otherConfigsMap.put(interfaceOtherConfig.getOtherConfigKey(),
interfaceOtherConfig.getOtherConfigValue());
}
final Interface ovsInterface) {
try {
- List<InterfaceBfd> interfaceBfdList =
- terminationPoint.getInterfaceBfd();
+ Map<InterfaceBfdKey, InterfaceBfd> interfaceBfdList = terminationPoint.getInterfaceBfd();
if (interfaceBfdList != null && !interfaceBfdList.isEmpty()) {
try {
ovsInterface.setBfd(YangUtils.convertYangKeyValueListToMap(interfaceBfdList,
private static void updatePortOtherConfig(final OvsdbTerminationPointAugmentation terminationPoint,
final Port ovsPort) {
- List<PortOtherConfigs> portOtherConfigs =
+ Map<PortOtherConfigsKey, PortOtherConfigs> portOtherConfigs =
terminationPoint.getPortOtherConfigs();
if (portOtherConfigs != null && !portOtherConfigs.isEmpty()) {
try {
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
@Override
public void onSuccess(@Nullable final Optional<Topology> optionalTopology) {
if (optionalTopology != null && optionalTopology.isPresent()) {
- Topology topology = optionalTopology.get();
- if (topology.getNode() != null) {
- for (Node node : topology.getNode()) {
+ Map<NodeKey, Node> nodes = optionalTopology.get().getNode();
+ if (nodes != null) {
+ for (Node node : nodes.values()) {
String bridgeNodeIid = node.getNodeId().getValue();
LOG.trace("bridgeNodeIid : {}", bridgeNodeIid);
if (bridgeReconcileExcludeList.contains(bridgeNodeIid)) {
changes.put(bridgeNodeIid, bridgeNode);
changes.put(ovsdbBridgeIid, ovsdbBridge);
- if (ovsdbBridge.getProtocolEntry() != null) {
- for (ProtocolEntry protocol : ovsdbBridge.getProtocolEntry()) {
+ final Map<ProtocolEntryKey, ProtocolEntry> protocols = ovsdbBridge.getProtocolEntry();
+ if (protocols != null) {
+ for (ProtocolEntry protocol : protocols.values()) {
if (SouthboundConstants.OVSDB_PROTOCOL_MAP.get(protocol.getProtocol()) != null) {
KeyedInstanceIdentifier<ProtocolEntry, ProtocolEntryKey> protocolIid =
ovsdbBridgeIid.child(ProtocolEntry.class, protocol.key());
}
}
- if (ovsdbBridge.getControllerEntry() != null) {
- for (ControllerEntry controller : ovsdbBridge.getControllerEntry()) {
+ final Map<ControllerEntryKey, ControllerEntry> controllers = ovsdbBridge.getControllerEntry();
+ if (controllers != null) {
+ for (ControllerEntry controller : controllers.values()) {
KeyedInstanceIdentifier<ControllerEntry, ControllerEntryKey> controllerIid =
ovsdbBridgeIid.child(ControllerEntry.class, controller.key());
changes.put(controllerIid, controller);
import java.util.List;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionManager;
import org.opendaylight.ovsdb.southbound.reconciliation.ReconciliationTask;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
* termination point reconciliation is triggered for that bridge.
*/
public class TerminationPointConfigReconciliationTask extends ReconciliationTask {
-
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointConfigReconciliationTask.class);
+ private static final PortExternalIdsKey CREATED_BY_KEY = new PortExternalIdsKey(SouthboundConstants.CREATED_BY);
+
private final OvsdbConnectionInstance connectionInstance;
private final InstanceIdentifierCodec instanceIdentifierCodec;
private final Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation>
@Override
public boolean reconcileConfiguration(final OvsdbConnectionManager connectionManager) {
final Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
- final Node configNodeData = ((Node) configData);
+ final Node configNodeData = (Node) configData;
LOG.debug("Reconcile Termination Point Configuration for node {}", configNodeData.getNodeId());
changes.putAll(SouthboundMapper.extractTerminationPointConfigurationChanges(configNodeData));
DataChangeEvent changeEvents = new DataChangeEvent() {
List<String> configTerminationPoints = new ArrayList<>();
if (configNodeData.getTerminationPoint() != null) {
- configNodeData.getTerminationPoint().forEach(entry -> {
+ configNodeData.getTerminationPoint().values().forEach(entry -> {
configTerminationPoints.add(entry.getTpId().getValue());
});
}
LOG.trace("Termination Point {} from Oper Topology NOT present in config topology During Reconcile,"
+ "checking if this created by ODL and perform delete reconciliation",
terminationPoint.getName());
- List<PortExternalIds> externalIds = terminationPoint.getPortExternalIds();
+ Map<PortExternalIdsKey, PortExternalIds> externalIds = terminationPoint.getPortExternalIds();
if (externalIds != null) {
- for (PortExternalIds portExternalIds : externalIds) {
- if (portExternalIds.getExternalIdKey().equals(SouthboundConstants.CREATED_BY)
- && portExternalIds.getExternalIdValue().equals(SouthboundConstants.ODL)) {
- LOG.trace("Termination Point {} created by ODL. Marking for deletion during reconcile",
- entry.getKey());
- removeTerminationPoints.add(entry.getKey());
- original.put(entry.getKey(), entry.getValue());
- break;
- }
+ final PortExternalIds portExternalIds = externalIds.get(CREATED_BY_KEY);
+ if (portExternalIds != null
+ && SouthboundConstants.ODL.equals(portExternalIds.getExternalIdValue())) {
+ LOG.trace("Termination Point {} created by ODL. Marking for deletion during reconcile",
+ entry.getKey());
+ removeTerminationPoints.add(entry.getKey());
+ original.put(entry.getKey(), entry.getValue());
+ break;
}
}
}
package org.opendaylight.ovsdb.southbound.transactions.md;
-import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
public class OvsdbAutoAttachRemovedCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbAutoAttachRemovedCommand.class);
- private Map<UUID, AutoAttach> removedAutoAttachRows;
+ private final Map<UUID, AutoAttach> removedAutoAttachRows;
public OvsdbAutoAttachRemovedCommand(OvsdbConnectionInstance key,
TableUpdates updates, DatabaseSchema dbSchema) {
}
private AutoattachKey getAutoAttachKeyToRemove(Node node, UUID autoAttachUuid) {
- final List<Autoattach> autoAttachList = node.augmentation(OvsdbNodeAugmentation.class).getAutoattach();
+ final Map<AutoattachKey, Autoattach> autoAttachList =
+ node.augmentation(OvsdbNodeAugmentation.class).getAutoattach();
if (autoAttachList == null || autoAttachList.isEmpty()) {
return null;
}
- for (final Autoattach autoAttach : autoAttachList) {
- if (autoAttach.getAutoattachUuid()
- .equals(new Uuid(autoAttachUuid.toString()))) {
+ for (final Autoattach autoAttach : autoAttachList.values()) {
+ if (autoAttach.getAutoattachUuid().equals(new Uuid(autoAttachUuid.toString()))) {
return autoAttach.key();
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.southbound.transactions.md;
import java.util.ArrayList;
import java.util.Map.Entry;
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;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.southbound.transactions.md;
import java.util.Collection;
-
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
connectionNode.addAugmentation(OvsdbNodeAugmentation.class, ovsdbConnectionAugmentationBuilder.build());
LOG.debug("Update node with bridge node ref {}",
- ovsdbConnectionAugmentationBuilder.getManagedNodeEntry().iterator().next());
+ ovsdbConnectionAugmentationBuilder.getManagedNodeEntry().values().iterator().next());
return connectionNode.build();
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
if (ovsdbNode.isPresent()) {
OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode.get().augmentation(OvsdbNodeAugmentation.class);
if (ovsdbNodeAugmentation != null) {
- final List<ManagedNodeEntry> managedNodeEntries = ovsdbNodeAugmentation.getManagedNodeEntry();
- for (ManagedNodeEntry managedNodeEntry : managedNodeEntries) {
+ final Map<ManagedNodeEntryKey, ManagedNodeEntry> managedNodeEntries
+ = ovsdbNodeAugmentation.getManagedNodeEntry();
+ for (ManagedNodeEntry managedNodeEntry : managedNodeEntries.values()) {
final InstanceIdentifier<Node> bridgeIid =
(InstanceIdentifier<Node>) managedNodeEntry.getBridgeRef().getValue();
final Optional<Node> bridgeNode = SouthboundUtil.readNode(transaction, bridgeIid);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.southbound.transactions.md;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
public class OvsdbInitialPortUpdateCommand extends OvsdbPortUpdateCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbInitialPortUpdateCommand.class);
private final Map<NodeId, Node> updatedBridgeNodes;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.FluentFuture;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode.augmentation(OvsdbNodeAugmentation.class);
if (checkIfOnlyConnectedManager(ovsdbNodeAugmentation)) {
if (ovsdbNodeAugmentation != null) {
- if (ovsdbNodeAugmentation.getManagedNodeEntry() != null) {
- for (ManagedNodeEntry managedNode : ovsdbNodeAugmentation.getManagedNodeEntry()) {
+ Map<ManagedNodeEntryKey, ManagedNodeEntry> entries =
+ ovsdbNodeAugmentation.getManagedNodeEntry();
+ if (entries != null) {
+ for (ManagedNodeEntry managedNode : entries.values()) {
transaction.delete(
LogicalDatastoreType.OPERATIONAL, managedNode.getBridgeRef().getValue());
}
ManagerEntry onlyConnectedManager = null;
if (ovsdbNodeAugmentation != null) {
int connectedManager = 0;
- if (ovsdbNodeAugmentation.getManagerEntry() != null) {
- for (ManagerEntry manager : ovsdbNodeAugmentation.getManagerEntry()) {
+ final Map<ManagerEntryKey, ManagerEntry> entries = ovsdbNodeAugmentation.getManagerEntry();
+ if (entries != null) {
+ for (ManagerEntry manager : entries.values()) {
if (manager.isConnected()) {
connectedManager++;
if (connectedManager > ONE_CONNECTED_MANAGER) {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.southbound.transactions.md;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
import com.google.common.annotations.VisibleForTesting;
-
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
-
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.error.ColumnSchemaNotFoundException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
}
@SuppressWarnings("unchecked")
+ // FIXME: non-static for implementation internals mocking
private Optional<InstanceIdentifier<Node>> getTerminationPointBridge(
final ReadWriteTransaction transaction, Node node, String tpName) {
OvsdbNodeAugmentation ovsdbNode = node.augmentation(OvsdbNodeAugmentation.class);
- List<ManagedNodeEntry> managedNodes = ovsdbNode.getManagedNodeEntry();
+ Map<ManagedNodeEntryKey, ManagedNodeEntry> managedNodes = ovsdbNode.nonnullManagedNodeEntry();
TpId tpId = new TpId(tpName);
- for (ManagedNodeEntry managedNodeEntry : managedNodes) {
+ for (ManagedNodeEntry managedNodeEntry : managedNodes.values()) {
Optional<Node> optManagedNode = SouthboundUtil.readNode(transaction,
(InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue());
if (optManagedNode.isPresent()) {
Node managedNode = optManagedNode.get();
- List<TerminationPoint> tpEntrys = managedNode.getTerminationPoint();
+ Map<TerminationPointKey, TerminationPoint> tpEntrys = managedNode.getTerminationPoint();
if (tpEntrys != null) {
- for (TerminationPoint tpEntry : tpEntrys) {
- if (tpId.equals(tpEntry.getTpId())) {
- return Optional.of((InstanceIdentifier<Node>) managedNodeEntry.getBridgeRef().getValue());
- }
+ TerminationPoint tpEntry = tpEntrys.get(new TerminationPointKey(tpId));
+ if (tpEntry != null) {
+ return Optional.of((InstanceIdentifier<Node>) managedNodeEntry.getBridgeRef().getValue());
}
}
}
@SuppressWarnings("unchecked")
private InstanceIdentifier<QosEntries> getQosIid(NodeId nodeId, OvsdbNodeAugmentation ovsdbNode, UUID qosUuid) {
// Search for the QoS entry first in the operational datastore
- for (QosEntries qosEntry : ovsdbNode.getQosEntries()) {
- if (qosEntry.getQosUuid().equals(new Uuid(qosUuid.toString()))) {
+ final Uuid uuid = new Uuid(qosUuid.toString());
+ for (QosEntries qosEntry : ovsdbNode.nonnullQosEntries().values()) {
+ if (uuid.equals(qosEntry.getQosUuid())) {
return SouthboundMapper.createInstanceIdentifier(nodeId)
.augmentation(OvsdbNodeAugmentation.class)
- .child(QosEntries.class, new QosEntriesKey(qosEntry.getQosId()));
+ .child(QosEntries.class, qosEntry.key());
}
}
package org.opendaylight.ovsdb.southbound.transactions.md;
import java.util.ArrayList;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
public class OvsdbQosRemovedCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbQosRemovedCommand.class);
- private Map<UUID, Qos> removedQosRows;
+ private final Map<UUID, Qos> removedQosRows;
public OvsdbQosRemovedCommand(OvsdbConnectionInstance key,
TableUpdates updates, DatabaseSchema dbSchema) {
}
}
- private QosEntriesKey getQosEntriesKey(Node node, UUID qosUuid) {
- List<QosEntries> qosList = node.augmentation(OvsdbNodeAugmentation.class).getQosEntries();
+ private static QosEntriesKey getQosEntriesKey(Node node, UUID qosUuid) {
+ Map<QosEntriesKey, QosEntries> qosList = node.augmentation(OvsdbNodeAugmentation.class).getQosEntries();
if (qosList == null || qosList.isEmpty()) {
LOG.debug("Deleting Qos {}, Ovsdb Node {} does not have a Qos list.", qosUuid, node);
return null;
}
- Iterator<QosEntries> itr = qosList.iterator();
Uuid quUuid = new Uuid(qosUuid.toString());
- while (itr.hasNext()) {
- QosEntries qos = itr.next();
+ for (QosEntries qos : qosList.values()) {
if (qos.getQosUuid().equals(quUuid)) {
return qos.key();
}
return null;
}
- private void deleteQos(ReadWriteTransaction transaction,
+ private static void deleteQos(ReadWriteTransaction transaction,
List<InstanceIdentifier<QosEntries>> qosEntryIids) {
for (InstanceIdentifier<QosEntries> qosEntryIid: qosEntryIids) {
transaction.delete(LogicalDatastoreType.OPERATIONAL, qosEntryIid);
queue.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY));
} else {
OvsdbNodeAugmentation node = ovsdbNode.augmentation(OvsdbNodeAugmentation.class);
- if (node.getQueues() != null && !node.getQueues().isEmpty()) {
- for (Queues q : node.getQueues()) {
- if (q.getQueueUuid().equals(new Uuid(queueUuid.toString()))) {
+ Map<QueuesKey, Queues> queues = node.getQueues();
+ if (queues != null) {
+ final Uuid uuid = new Uuid(queueUuid.toString());
+ for (Queues q : queues.values()) {
+ if (uuid.equals(q.getQueueUuid())) {
return SouthboundMapper.createInstanceIdentifier(ovsdbNode.getNodeId())
.augmentation(OvsdbNodeAugmentation.class)
- .child(Queues.class, new QueuesKey(q.getQueueId()));
+ .child(Queues.class, q.key());
}
}
}
package org.opendaylight.ovsdb.southbound.transactions.md;
import java.util.ArrayList;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
public class OvsdbQueueRemovedCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbQueueRemovedCommand.class);
- private Map<UUID, Queue> removedQueueRows;
+ private final Map<UUID, Queue> removedQueueRows;
public OvsdbQueueRemovedCommand(OvsdbConnectionInstance key,
TableUpdates updates, DatabaseSchema dbSchema) {
}
}
- private QueuesKey getQueueKey(Node node, UUID queueUuid) {
- List<Queues> queueList = node.augmentation(OvsdbNodeAugmentation.class).getQueues();
+ private static QueuesKey getQueueKey(Node node, UUID queueUuid) {
+ Map<QueuesKey, Queues> queueList = node.augmentation(OvsdbNodeAugmentation.class).getQueues();
if (queueList == null || queueList.isEmpty()) {
LOG.debug("Deleting Queue {}, Ovsdb Node {} does not have a Queue list.", queueUuid, node);
return null;
}
- Iterator<Queues> itr = queueList.iterator();
Uuid quUuid = new Uuid(queueUuid.toString());
- while (itr.hasNext()) {
- Queues queue = itr.next();
+ for (Queues queue : queueList.values()) {
if (queue.getQueueUuid().equals(quUuid)) {
return queue.key();
}
return null;
}
- private void deleteQueue(ReadWriteTransaction transaction,
+ private static void deleteQueue(ReadWriteTransaction transaction,
List<InstanceIdentifier<Queues>> queueIids) {
for (InstanceIdentifier<Queues> queueIid: queueIids) {
transaction.delete(LogicalDatastoreType.OPERATIONAL, queueIid);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.southbound;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@Test
public void testModuleForPrefix() {
Module module = mock(Module.class);
- when(context.findModules("")).thenReturn(ImmutableSet.of(module));
+ doReturn(ImmutableSet.of(module)).when(context).findModules("");
assertEquals("Found Module", module, instanceIdCodec.moduleForPrefix(""));
-
- when(context.findModules("foo")).thenReturn(ImmutableSet.of(module, mock(Module.class)));
+ doReturn(ImmutableSet.of(module, mock(Module.class))).when(context).findModules("foo");
assertEquals("Found Module", module, instanceIdCodec.moduleForPrefix("foo"));
when(context.findModules("bar")).thenReturn(Collections.emptySet());
when(context.findModules(namespace)).thenReturn(Collections.emptySet());
assertNull(instanceIdCodec.prefixForNamespace(namespace));
- when(context.findModules(namespace)).thenReturn(ImmutableSet.of(module));
+ doReturn(ImmutableSet.of(module)).when(context).findModules(namespace);
assertEquals("Found prefix", prefix, instanceIdCodec.prefixForNamespace(namespace));
-
- when(context.findModules(namespace)).thenReturn(ImmutableSet.of(module, mock(Module.class)));
+ doReturn(ImmutableSet.of(module, mock(Module.class))).when(context).findModules(namespace);
assertEquals("Found prefix", prefix, instanceIdCodec.prefixForNamespace(namespace));
}
.build();
final InstanceIdentifier<Node> iid = SouthboundUtils.createInstanceIdentifier(connectionInfo);
WriteTransaction transaction = dataBroker.newReadWriteTransaction();
- transaction.put(LogicalDatastoreType.CONFIGURATION, iid, SouthboundUtils.createNode(connectionInfo),
- WriteTransaction.CREATE_MISSING_PARENTS);
+ transaction.mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, iid,
+ SouthboundUtils.createNode(connectionInfo));
transaction.commit().get();
// Then the listener tries to open a connection
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlan;
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.OvsdbBridgeAugmentationBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolOpenflow10;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryBuilder;
public void testCreateOvsdbBridgeProtocols() {
OvsdbBridgeAugmentation ovsdbBridgeNode = mock(OvsdbBridgeAugmentation.class);
List<ProtocolEntry> protocolList = new ArrayList<>();
- ProtocolEntry protocolEntry = mock(ProtocolEntry.class);
- protocolList.add(protocolEntry);
- when(ovsdbBridgeNode.getProtocolEntry()).thenReturn(protocolList);
- when(protocolEntry.getProtocol()).thenAnswer(
- (Answer<Class<? extends OvsdbBridgeProtocolBase>>) invocation -> OvsdbBridgeProtocolOpenflow10.class);
+ ProtocolEntry protocolEntry = new ProtocolEntryBuilder()
+ .setProtocol(OvsdbBridgeProtocolOpenflow10.class)
+ .build();
+
+ when(ovsdbBridgeNode.getProtocolEntry()).thenReturn(Map.of(protocolEntry.key(), protocolEntry));
Set<String> protocols = new HashSet<>();
protocols.add("OpenFlow10");
assertEquals(protocols, SouthboundMapper.createOvsdbBridgeProtocols(ovsdbBridgeNode));
OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
when(ovsdbNode.augmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNodeAugmentation);
- List<ManagerEntry> managerEntries = new ArrayList<>();
- ManagerEntry managerEntry = mock(ManagerEntry.class);
- managerEntries.add(managerEntry);
- when(ovsdbNodeAugmentation.getManagerEntry()).thenReturn(managerEntries);
- when(managerEntry.getTarget()).thenReturn(uri);
+ ManagerEntry managerEntry = new ManagerEntryBuilder().setTarget(uri).build();
+ when(ovsdbNodeAugmentation.getManagerEntry()).thenReturn(Map.of(managerEntry.key(), managerEntry));
//Test addManagerEntries(managerEntriesCreated, manager)
Column<GenericTableSchema, String> value = mock(Column.class);
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.when;
import static org.powermock.reflect.Whitebox.getField;
-import java.util.ArrayList;
-import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.junit.Before;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@RunWith(MockitoJUnitRunner.class)
assertNotNull(optTerm);
assertTrue(optTerm.equals(Optional.empty()));
- TerminationPoint termPnt = mock(TerminationPoint.class);
- List<TerminationPoint> termPntList = new ArrayList<>();
- termPntList.add(termPnt);
+ TerminationPoint termPnt = new TerminationPointBuilder().setTpId(new TpId("mockTp")).build();
Node node = mock(Node.class);
Optional<Node> optNode = Optional.of(node);
doReturn(optNode).when(briOperationState).getBridgeNode(any(InstanceIdentifier.class));
- when(node.getTerminationPoint()).thenReturn(termPntList);
- TerminationPointKey termPntKey = mock(TerminationPointKey.class);
- when(termPnt.key()).thenReturn(termPntKey);
+ when(node.nonnullTerminationPoint()).thenCallRealMethod();
+ when(node.getTerminationPoint()).thenReturn(Map.of(termPnt.key(), termPnt));
Optional<TerminationPoint> optTermPnt = briOperationState.getBridgeTerminationPoint(
- iidNode.child(TerminationPoint.class, termPntKey));
+ iidNode.child(TerminationPoint.class, termPnt.key()));
assertTrue(optTermPnt.isPresent());
}
import com.google.common.collect.ImmutableMap;
import java.lang.reflect.Field;
-import java.util.ArrayList;
import java.util.HashMap;
-import java.util.List;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIds;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIdsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.api.support.membermodification.MemberMatcher;
TransactionBuilder transaction = mock(TransactionBuilder.class);
when(transaction.getTypedRowWrapper(eq(OpenVSwitch.class))).thenReturn(ovs);
- List<OpenvswitchExternalIds> externalIds = new ArrayList<>();
- OpenvswitchExternalIds externalId = mock(OpenvswitchExternalIds.class);
- externalIds.add(externalId);
- when(externalId.getExternalIdKey()).thenReturn(EXTERNAL_ID_KEY);
- when(externalId.getExternalIdValue()).thenReturn(EXTERNAL_ID_VALUE);
- when(ovsdbNode.getOpenvswitchExternalIds()).thenReturn(externalIds);
+
+ OpenvswitchExternalIds externalId = new OpenvswitchExternalIdsBuilder()
+ .setExternalIdKey(EXTERNAL_ID_KEY)
+ .setExternalIdValue(EXTERNAL_ID_VALUE)
+ .build();
+ when(ovsdbNode.getOpenvswitchExternalIds()).thenReturn(Map.of(externalId.key(), externalId));
PowerMockito.suppress(MemberMatcher.method(OvsdbNodeUpdateCommand.class, "stampInstanceIdentifier",
TransactionBuilder.class, InstanceIdentifier.class, InstanceIdentifierCodec.class));
PowerMockito.suppress(MemberMatcher.methodsDeclaredIn(InstanceIdentifier.class));
when(op.mutate(any(OpenVSwitch.class))).thenReturn(mutate);
when(transaction.add(any(Operation.class))).thenReturn(transaction);
- List<OpenvswitchOtherConfigs> otherConfigs = new ArrayList<>();
- OpenvswitchOtherConfigs otherConfig = mock(OpenvswitchOtherConfigs.class);
- otherConfigs.add(otherConfig);
- when(ovsdbNode.getOpenvswitchOtherConfigs()).thenReturn(otherConfigs);
- when(otherConfig.getOtherConfigKey()).thenReturn(OTHER_CONFIG_KEY);
- when(otherConfig.getOtherConfigValue()).thenReturn(OTHER_CONFIG_VALUE);
+ OpenvswitchOtherConfigs otherConfig = new OpenvswitchOtherConfigsBuilder()
+ .setOtherConfigKey(OTHER_CONFIG_KEY)
+ .setOtherConfigValue(OTHER_CONFIG_VALUE)
+ .build();
+
+ when(ovsdbNode.getOpenvswitchOtherConfigs()).thenReturn(Map.of(otherConfig.key(), otherConfig));
doNothing().when(ovs).setOtherConfig(any(ImmutableMap.class));
when(ovs.getOtherConfigColumn()).thenReturn(column);
ovsdbNodeUpdateCommand.execute(transaction, mock(BridgeOperationalState.class), changes,
mock(InstanceIdentifierCodec.class));
- verify(externalId).getExternalIdKey();
- verify(otherConfig).getOtherConfigKey();
verify(ovs, times(2)).getExternalIdsColumn();
verify(transaction, times(2)).add(eq(null));
}
import static org.mockito.Mockito.when;
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.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
-import org.mockito.stubbing.Answer;
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.reconciliation.ReconciliationManager;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolOpenflow10;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.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";
@Before
public void setUp() throws Exception {
NodeKey nodeKey = new NodeKey(new NodeId(new Uri(NODE_ID)));
- List<Node> bridgeNodes = new ArrayList<>();
iid = SouthboundMapper.createInstanceIdentifier(nodeKey.getNodeId());
- when(topology.getNode()).thenReturn(bridgeNodes);
SouthboundProvider.setBridgesReconciliationInclusionList(Arrays.asList(BR_INT));
Node brIntNode = createBridgeNode(NODE_ID + "/bridge/" + BR_INT);
Optional<Node> nodeOptional = Optional.of(brIntNode);
Mockito.when(db.newReadOnlyTransaction()).thenReturn(tx);
Mockito.when(tx.read(any(LogicalDatastoreType.class),any(InstanceIdentifier.class)))
.thenReturn(readNodeFuture);
- bridgeNodes.add(brIntNode);
+
+ when(topology.getNode()).thenReturn(Map.of(brIntNode.key(), brIntNode));
configurationReconciliationTask =
new BridgeConfigReconciliationTask(reconciliationManager, ovsdbConnectionManager, iid,
doNothing().when(underTest).reconcileBridgeConfigurations(any(Map.class));
assertTrue(underTest.reconcileConfiguration(ovsdbConnectionManager));
Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
- for (Node bridgeNode : topology.getNode()) {
+ for (Node bridgeNode : topology.getNode().values()) {
changes.putAll(createExpectedConfigurationChanges(bridgeNode));
}
verify(underTest).reconcileBridgeConfigurations(changes);
}
private Node createBridgeNode(final String bridgeName) {
- Node bridgeNode = mock(Node.class);
- String nodeString = bridgeName;
- when(bridgeNode.getNodeId()).thenReturn(new NodeId(new Uri(nodeString)));
- OvsdbBridgeAugmentation ovsdbBridgeAugmentation = mock(OvsdbBridgeAugmentation.class);
- OvsdbNodeRef ovsdbNodeRef = mock(OvsdbNodeRef.class);
-
- when((InstanceIdentifier<Node>)ovsdbNodeRef.getValue()).thenReturn(iid);
- OvsdbBridgeName ovsdbBridgeName = new OvsdbBridgeName(bridgeName);
- when(bridgeNode.augmentation(OvsdbBridgeAugmentation.class)).thenReturn(ovsdbBridgeAugmentation);
- ProtocolEntry protocolEntry = mock(ProtocolEntry.class);
- ProtocolEntryKey protocolEntryKey = mock(ProtocolEntryKey.class);
- Mockito.when(protocolEntry.getProtocol()).thenAnswer(
- (Answer<Class<? extends OvsdbBridgeProtocolBase>>) invocation -> OvsdbBridgeProtocolOpenflow10.class);
- when(protocolEntry.key()).thenReturn(protocolEntryKey);
- when(ovsdbBridgeAugmentation.getProtocolEntry()).thenReturn(Collections.singletonList(protocolEntry));
-
- ControllerEntry controllerEntry = mock(ControllerEntry.class);
- ControllerEntryKey controllerEntryKey = mock(ControllerEntryKey.class);
- when(controllerEntry.key()).thenReturn(controllerEntryKey);
- when(ovsdbBridgeAugmentation.getControllerEntry()).thenReturn(Collections.singletonList(controllerEntry));
-
- when(ovsdbBridgeAugmentation.getManagedBy()).thenReturn(ovsdbNodeRef);
-
- return bridgeNode;
+ ProtocolEntry protocolEntry = new ProtocolEntryBuilder()
+ .setProtocol(OvsdbBridgeProtocolOpenflow10.class)
+ .build();
+ ControllerEntry controllerEntry = new ControllerEntryBuilder().setTarget(new Uri("mock")).build();
+
+ return new NodeBuilder()
+ .setNodeId(new NodeId(new Uri(bridgeName)))
+ .addAugmentation(new OvsdbBridgeAugmentationBuilder()
+ .setManagedBy(new OvsdbNodeRef(iid))
+ .setProtocolEntry(Collections.singletonMap(protocolEntry.key(), protocolEntry))
+ .setControllerEntry(Collections.singletonMap(controllerEntry.key(), controllerEntry))
+ .build())
+ .build();
}
private Map<InstanceIdentifier<?>, DataObject> createExpectedConfigurationChanges(final Node bridgeNode) {
bridgeNodeIid.builder().augmentation(OvsdbBridgeAugmentation.class).build();
changes.put(bridgeNodeIid, bridgeNode);
changes.put(ovsdbBridgeIid, ovsdbBridge);
- for (ProtocolEntry protocolEntry : ovsdbBridge.getProtocolEntry()) {
+ for (ProtocolEntry protocolEntry : ovsdbBridge.getProtocolEntry().values()) {
KeyedInstanceIdentifier<ProtocolEntry, ProtocolEntryKey> protocolIid =
ovsdbBridgeIid.child(ProtocolEntry.class, protocolEntry.key());
changes.put(protocolIid, protocolEntry);
}
- for (ControllerEntry controller : ovsdbBridge.getControllerEntry()) {
+ for (ControllerEntry controller : ovsdbBridge.getControllerEntry().values()) {
KeyedInstanceIdentifier<ControllerEntry, ControllerEntryKey> controllerIid =
ovsdbBridgeIid.child(ControllerEntry.class, controller.key());
changes.put(controllerIid, controller);
package org.opendaylight.ovsdb.southbound.transactions.md;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
-import java.util.List;
import java.util.Map;
import java.util.Set;
import org.junit.Before;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.DatapathTypeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.DatapathTypeEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIds;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
Whitebox.invokeMethod(openVSwitchUpdateCommand, "setNewOtherConfigs", ovsdbNodeBuilder,
ImmutableMap.of("otherConfigKey", "otherConfigValue"));
- final List<OpenvswitchOtherConfigs> otherConfigsList = ovsdbNodeBuilder.getOpenvswitchOtherConfigs();
+ final Map<OpenvswitchOtherConfigsKey, OpenvswitchOtherConfigs> otherConfigsList =
+ ovsdbNodeBuilder.getOpenvswitchOtherConfigs();
assertEquals(1, otherConfigsList.size());
- final OpenvswitchOtherConfigs otherConfig = otherConfigsList.get(0);
+ final OpenvswitchOtherConfigs otherConfig = otherConfigsList.values().iterator().next();
assertEquals("otherConfigKey", otherConfig.getOtherConfigKey());
assertEquals("otherConfigValue", otherConfig.getOtherConfigValue());
}
Whitebox.invokeMethod(openVSwitchUpdateCommand, "setNewExternalIds", ovsdbNodeBuilder,
ImmutableMap.of("externalIdsKey", "externalIdsValue"));
- final List<OpenvswitchExternalIds> externalIdsList = ovsdbNodeBuilder.getOpenvswitchExternalIds();
+ final Map<OpenvswitchExternalIdsKey, OpenvswitchExternalIds> externalIdsList =
+ ovsdbNodeBuilder.getOpenvswitchExternalIds();
assertEquals(1, externalIdsList.size());
- final OpenvswitchExternalIds externalId = externalIdsList.get(0);
+ final OpenvswitchExternalIds externalId = externalIdsList.values().iterator().next();
assertEquals("externalIdsKey", externalId.getExternalIdKey());
assertEquals("externalIdsValue", externalId.getExternalIdValue());
}
Whitebox.invokeMethod(openVSwitchUpdateCommand, "setInterfaceTypes", ovsdbNodeBuilder, openVSwitch);
verify(openVSwitch).getIfaceTypesColumn();
- List<InterfaceTypeEntry> interfaceTypeEntries = ovsdbNodeBuilder.getInterfaceTypeEntry();
+ Map<InterfaceTypeEntryKey, InterfaceTypeEntry> interfaceTypeEntries = ovsdbNodeBuilder.getInterfaceTypeEntry();
assertEquals(14, interfaceTypeEntries.size());
}
Whitebox.invokeMethod(openVSwitchUpdateCommand, "setDataPathTypes", ovsdbNodeBuilder, openVSwitch);
verify(openVSwitch).getDatapathTypesColumn();
- List<DatapathTypeEntry> entries = ovsdbNodeBuilder.getDatapathTypeEntry();
+ Map<DatapathTypeEntryKey, DatapathTypeEntry> entries = ovsdbNodeBuilder.getDatapathTypeEntry();
assertEquals(2, entries.size());
- assertEquals(DatapathTypeNetdev.class, entries.get(0).getDatapathType());
- assertEquals(DatapathTypeSystem.class, entries.get(1).getDatapathType());
+ assertTrue(entries.containsKey(new DatapathTypeEntryKey(DatapathTypeNetdev.class)));
+ assertTrue(entries.containsKey(new DatapathTypeEntryKey(DatapathTypeSystem.class)));
}
@Test
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.ArrayList;
import java.util.HashMap;
-import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.junit.Before;
OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
when(node.augmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNodeAugmentation);
- List<Autoattach> autoAttachList = new ArrayList<>();
Autoattach aaEntry = mock(Autoattach.class);
- autoAttachList.add(aaEntry);
when(aaEntry.getAutoattachUuid()).thenReturn(new Uuid(AUTOATTACH_UUID.toString()));
- when(ovsdbNodeAugmentation.getAutoattach()).thenReturn(autoAttachList);
when(aaEntry.key()).thenReturn(aaKey);
+ when(ovsdbNodeAugmentation.getAutoattach()).thenReturn(Map.of(aaKey, aaEntry));
doNothing().when(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
}
private final Map<UUID,Bridge> updatedBridgeRows = new HashMap<>();
private final Map<UUID, Bridge> oldBridgeRows = new HashMap<>();
private OvsdbBridgeUpdateCommand ovsdbBridgeUpdateCommand;
- private Map<NodeId, Node> updatedBridgeNodes = new HashMap<>();
+ private final Map<NodeId, Node> updatedBridgeNodes = new HashMap<>();
@Before
public void setUp() throws Exception {
when(SouthboundMapper.createInstanceIdentifier(any(InstanceIdentifierCodec.class),
any(OvsdbConnectionInstance.class), any(Bridge.class)))
.thenReturn(bridgeIid);
- ManagedNodeEntry managedBridge = mock(ManagedNodeEntry.class);
+
+ ManagedNodeEntry managedBridge = new ManagedNodeEntryBuilder()
+ .setBridgeRef(new OvsdbBridgeRef(mock(InstanceIdentifier.class)))
+ .build();
+
ManagedNodeEntryBuilder managedNodeEntryBuilder = mock(ManagedNodeEntryBuilder.class);
PowerMockito.whenNew(ManagedNodeEntryBuilder.class).withNoArguments().thenReturn(managedNodeEntryBuilder);
PowerMockito.whenNew(OvsdbBridgeRef.class).withAnyArguments().thenReturn(mock(OvsdbBridgeRef.class));
.thenReturn(connectionNode);
//for logger
- List<ManagedNodeEntry> value = new ArrayList<>();
- value.add(managedBridge);
- when(ovsdbConnectionAugmentationBuilder.getManagedNodeEntry()).thenReturn(value);
+ when(ovsdbConnectionAugmentationBuilder.getManagedNodeEntry())
+ .thenReturn(Map.of(managedBridge.key(), managedBridge));
Node node = mock(Node.class);
when(connectionNode.build()).thenReturn(node);
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
when(node.augmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNodeAugmentation);
- List<ManagedNodeEntry> managedNodeEntries = new ArrayList<>();
- ManagedNodeEntry managedNodeEntry = mock(ManagedNodeEntry.class);
- managedNodeEntries.add(managedNodeEntry);
- when(ovsdbNodeAugmentation.getManagedNodeEntry()).thenReturn(managedNodeEntries);
InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
- OvsdbBridgeRef ovsdbBridgeRef = mock(OvsdbBridgeRef.class);
- when(managedNodeEntry.getBridgeRef()).thenReturn(ovsdbBridgeRef);
- when((InstanceIdentifier<Node>) ovsdbBridgeRef.getValue()).thenReturn(bridgeIid);
+ ManagedNodeEntry managedNodeEntry = new ManagedNodeEntryBuilder()
+ .setBridgeRef(new OvsdbBridgeRef(bridgeIid))
+ .build();
+
+ when(ovsdbNodeAugmentation.getManagedNodeEntry()).thenReturn(Map.of(managedNodeEntry.key(), managedNodeEntry));
Optional<Node> bridgeNode = Optional.of(node);
when(SouthboundUtil.readNode(transaction, bridgeIid)).thenReturn(bridgeNode);
import static org.mockito.Mockito.when;
import com.google.common.util.concurrent.FluentFuture;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.HashMap;
+import java.util.Map;
import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint32;
doReturn(true).when(ovsdbNodeRemoveCommand).checkIfOnlyConnectedManager(any(OvsdbNodeAugmentation.class));
- List<ManagedNodeEntry> listManagedNodeEntry = new ArrayList<>();
- ManagedNodeEntry managedNode = mock(ManagedNodeEntry.class);
- listManagedNodeEntry.add(managedNode);
- when(ovsdbNodeAugmentation.getManagedNodeEntry()).thenReturn(listManagedNodeEntry);
- OvsdbBridgeRef ovsdbBridgeRef = mock(OvsdbBridgeRef.class);
- when(managedNode.getBridgeRef()).thenReturn(ovsdbBridgeRef);
- when(ovsdbBridgeRef.getValue()).thenReturn(mock(InstanceIdentifier.class));
+ ManagedNodeEntry managedNode = new ManagedNodeEntryBuilder()
+ .setBridgeRef(new OvsdbBridgeRef(mock(InstanceIdentifier.class)))
+ .build();
+
+ when(ovsdbNodeAugmentation.getManagedNodeEntry()).thenReturn(Map.of(managedNode.key(), managedNode));
doNothing().when(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
ovsdbNodeRemoveCommand.execute(transaction);
- verify(ovsdbNodeAugmentation, times(2)).getManagedNodeEntry();
+ verify(ovsdbNodeAugmentation).getManagedNodeEntry();
verify(transaction, times(2)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
}
@Test
public void testCheckIfOnlyConnectedManager() throws Exception {
- OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
ManagerEntry manager = mock(ManagerEntry.class);
- List<ManagerEntry> listManagerEntry = new ArrayList<>();
- listManagerEntry.add(manager);
-
- //case 1: connectedManager > ONE_CONNECTED_MANAGER
ManagerEntry manager1 = mock(ManagerEntry.class);
- listManagerEntry.add(manager1);
- when(ovsdbNodeAugmentation.getManagerEntry()).thenReturn(listManagerEntry);
+ doReturn(new ManagerEntryKey(new Uri("manager"))).when(manager).key();
+ doReturn(new ManagerEntryKey(new Uri("manager1"))).when(manager1).key();
+
when(manager.isConnected()).thenReturn(true, false, true);
when(manager1.isConnected()).thenReturn(true, false, true);
- when(manager.getNumberOfConnections()).thenReturn(Uint32.valueOf(0));
+ when(manager.getNumberOfConnections()).thenReturn(Uint32.ZERO);
+
+ Map<ManagerEntryKey, ManagerEntry> listManagerEntry = new HashMap<>();
+ listManagerEntry.put(manager.key(), manager);
+ listManagerEntry.put(manager1.key(), manager1);
+
+ OvsdbNodeAugmentation ovsdbNodeAugmentation = new OvsdbNodeAugmentationBuilder()
+ .setManagerEntry(listManagerEntry)
+ .build();
+
+ //case 1: connectedManager > ONE_CONNECTED_MANAGER
assertEquals(false,
Whitebox.invokeMethod(ovsdbNodeRemoveCommand, "checkIfOnlyConnectedManager", ovsdbNodeAugmentation));
Whitebox.invokeMethod(ovsdbNodeRemoveCommand, "checkIfOnlyConnectedManager", ovsdbNodeAugmentation));
// case 4: when all the above don't apply
- listManagerEntry.remove(manager1);
+ listManagerEntry.remove(manager1.key());
assertEquals(true,
Whitebox.invokeMethod(ovsdbNodeRemoveCommand, "checkIfOnlyConnectedManager", ovsdbNodeAugmentation));
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.southbound.transactions.md;
import static org.junit.Assert.assertEquals;
import com.google.common.util.concurrent.FluentFuture;
import java.util.AbstractMap.SimpleEntry;
-import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.mockito.Matchers;
import org.mockito.Mockito;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
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.southbound.SouthboundUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
Node node = mock(Node.class);
OvsdbNodeAugmentation ovsdbNode = mock(OvsdbNodeAugmentation.class);
when(node.augmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNode);
- List<ManagedNodeEntry> managedNodes = new ArrayList<>();
- ManagedNodeEntry managedNodeEntry = mock(ManagedNodeEntry.class);
- managedNodes.add(managedNodeEntry);
- when(ovsdbNode.getManagedNodeEntry()).thenReturn(managedNodes);
- Node managedNode = mock(Node.class);
- OvsdbBridgeRef ovsdbBridgeRef = mock(OvsdbBridgeRef.class);
- when(managedNodeEntry.getBridgeRef()).thenReturn(ovsdbBridgeRef);
InstanceIdentifier<Node> iidNode = mock(InstanceIdentifier.class);
- when((InstanceIdentifier<Node>) ovsdbBridgeRef.getValue()).thenReturn(iidNode);
+
+ ManagedNodeEntry managedNodeEntry = new ManagedNodeEntryBuilder()
+ .setBridgeRef(new OvsdbBridgeRef(iidNode))
+ .build();
+ when(ovsdbNode.nonnullManagedNodeEntry()).thenCallRealMethod();
+ when(ovsdbNode.getManagedNodeEntry()).thenReturn(Map.of(managedNodeEntry.key(), managedNodeEntry));
+
+ Node managedNode = mock(Node.class);
Optional<Node> optionalNode = Optional.of(managedNode);
PowerMockito.doReturn(optionalNode).when(ovsdbPortUpdateCommand, "readNode", any(ReadWriteTransaction.class),
any(InstanceIdentifier.class));
PowerMockito.mockStatic(SouthboundUtil.class);
- PowerMockito.when(SouthboundUtil.readNode(Matchers.any(ReadWriteTransaction.class),
- Matchers.any(InstanceIdentifier.class)))
+ PowerMockito.when(SouthboundUtil.readNode(any(ReadWriteTransaction.class),
+ any(InstanceIdentifier.class)))
.thenReturn(optionalNode);
+
+ TerminationPoint terminationPoint = new TerminationPointBuilder().setTpId(new TpId(TP_NAME)).build();
+
TerminationPointBuilder tpBuilder = mock(TerminationPointBuilder.class);
- PowerMockito.whenNew(TerminationPointBuilder.class).withNoArguments().thenReturn(tpBuilder);
- PowerMockito.whenNew(TpId.class).withAnyArguments().thenReturn(mock(TpId.class));
- PowerMockito.whenNew(TerminationPointKey.class).withAnyArguments().thenReturn(mock(TerminationPointKey.class));
when(tpBuilder.withKey(any(TerminationPointKey.class))).thenReturn(tpBuilder);
-
- List<TerminationPoint> terminationPointList = new ArrayList<>();
- TerminationPoint terminationPoint = mock(TerminationPoint.class);
- terminationPointList.add(terminationPoint);
when(tpBuilder.build()).thenReturn(terminationPoint);
- when(managedNode.getTerminationPoint()).thenReturn(terminationPointList);
+
+ PowerMockito.whenNew(TerminationPointBuilder.class).withNoArguments().thenReturn(tpBuilder);
+
+ when(managedNode.nonnullTerminationPoint()).thenCallRealMethod();
+ when(managedNode.getTerminationPoint()).thenReturn(Map.of(terminationPoint.key(), terminationPoint));
when(managedNode.augmentation(OvsdbBridgeAugmentation.class))
.thenReturn(mock(OvsdbBridgeAugmentation.class));
- TpId tpId = new TpId(TP_NAME);
- when(terminationPoint.getTpId()).thenReturn(tpId);
Optional<InstanceIdentifier<Node>> testResult = Optional.of(iidNode);
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
when(ovsdbTerminationPointBuilder.setInterfaceUuid(any(Uuid.class))).thenReturn(ovsdbTerminationPointBuilder);
PowerMockito.mockStatic(SouthboundMapper.class);
- PowerMockito.when(SouthboundMapper.createInterfaceType(Matchers.anyString()))
- .thenAnswer(new Answer<Class<? extends InterfaceTypeBase>>() {
- public Class<? extends InterfaceTypeBase> answer(InvocationOnMock invocation) throws Exception {
- return InterfaceTypeInternal.class;
- }
- });
+ PowerMockito.when(SouthboundMapper.createInterfaceType(anyString()))
+ .thenAnswer(invocation -> InterfaceTypeInternal.class);
when(ovsdbTerminationPointBuilder.setInterfaceType(any(Class.class))).thenReturn(ovsdbTerminationPointBuilder);
suppress(method(OvsdbPortUpdateCommand.class, "updateOfPort", Interface.class,
OvsdbTerminationPointAugmentationBuilder.class));
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
- <version>1</version>
<scope>compile</scope>
</dependency>
<dependency>
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import java.lang.annotation.Annotation;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Properties;
import java.util.Set;
import javax.inject.Inject;
+import jersey.repackaged.com.google.common.collect.Maps;
import org.eclipse.jdt.annotation.Nullable;
import org.junit.After;
import org.junit.Assert;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.QosTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeExternalIdsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeOtherConfigs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeOtherConfigsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeOtherConfigsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.DatapathTypeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.DatapathTypeEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QueuesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.AutoattachExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.AutoattachExternalIdsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.AutoattachExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.Mappings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.MappingsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.MappingsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosExternalIdsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosOtherConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosOtherConfigBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosOtherConfigKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QueueList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QueueListBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QueueListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.queues.QueuesExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.queues.QueuesExternalIdsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.queues.QueuesExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.queues.QueuesOtherConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.queues.QueuesOtherConfigBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.queues.QueuesOtherConfigKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.Identifiable;
+import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.ops4j.pax.exam.Configuration;
import org.ops4j.pax.exam.Option;
import org.ops4j.pax.exam.junit.PaxExam;
@Test
public void testDpdkSwitch() throws InterruptedException {
ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portNumber);
- List<DatapathTypeEntry> datapathTypeEntries = ovsdbNode.augmentation(OvsdbNodeAugmentation.class)
- .getDatapathTypeEntry();
+ Map<DatapathTypeEntryKey, DatapathTypeEntry> datapathTypeEntries =
+ ovsdbNode.augmentation(OvsdbNodeAugmentation.class).nonnullDatapathTypeEntry();
if (datapathTypeEntries == null) {
LOG.info("DPDK not supported on this node.");
} else {
- for (DatapathTypeEntry dpTypeEntry : datapathTypeEntries) {
+ for (DatapathTypeEntry dpTypeEntry : datapathTypeEntries.values()) {
Class<? extends DatapathTypeBase> dpType = dpTypeEntry.getDatapathType();
String dpTypeStr = SouthboundConstants.DATAPATH_TYPE_MAP.get(dpType);
LOG.info("dp type is {}", dpTypeStr);
// Verify that each termination point has the specific DPDK ifType
for (String dpdkType : dpdkTypes) {
String testPortname = "test" + dpdkType + "port";
- Class<? extends InterfaceTypeBase> dpdkIfType = SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP
- .get(dpdkType);
- List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
- for (TerminationPoint terminationPoint : terminationPoints) {
+ Class<? extends InterfaceTypeBase> dpdkIfType =
+ SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP.get(dpdkType);
+ for (TerminationPoint terminationPoint
+ : terminationPointNode.nonnullTerminationPoint().values()) {
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation = terminationPoint
.augmentation(OvsdbTerminationPointAugmentation.class);
if (ovsdbTerminationPointAugmentation.getName().equals(testPortname)) {
public void testOpenVSwitchOtherConfig() throws InterruptedException {
OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode.augmentation(OvsdbNodeAugmentation.class);
Assert.assertNotNull(ovsdbNodeAugmentation);
- List<OpenvswitchOtherConfigs> otherConfigsList = ovsdbNodeAugmentation.getOpenvswitchOtherConfigs();
+ Map<OpenvswitchOtherConfigsKey, OpenvswitchOtherConfigs> otherConfigsList =
+ ovsdbNodeAugmentation.getOpenvswitchOtherConfigs();
if (otherConfigsList != null) {
- for (OpenvswitchOtherConfigs otherConfig : otherConfigsList) {
+ for (OpenvswitchOtherConfigs otherConfig : otherConfigsList.values()) {
if (otherConfig.getOtherConfigKey().equals("local_ip")) {
LOG.info("local_ip: {}", otherConfig.getOtherConfigValue());
break;
Assert.assertNotNull("bridge was not found: " + SouthboundITConstants.BRIDGE_NAME, bridge);
Assert.assertNotNull("ControllerEntry was not found: " + setControllerEntry.iterator().next(),
bridge.getControllerEntry());
- List<ControllerEntry> getControllerEntries = bridge.getControllerEntry();
- for (ControllerEntry entry : getControllerEntries) {
+ for (ControllerEntry entry : bridge.getControllerEntry().values()) {
if (entry.getTarget() != null) {
Assert.assertEquals(setUri.toString(), entry.getTarget().toString());
}
LogicalDatastoreType.OPERATIONAL);
operAa = getAutoAttach(ovsdbNodeAugmentation, new Uri(testAutoattachId));
Assert.assertNotNull(operAa);
- List<Mappings> operMappingsList = operAa.getMappings();
- for (Mappings operMappings: operMappingsList) {
- Assert.assertEquals(mappings.get(operMappingsList.indexOf(operMappings))
- .getMappingsKey(), operMappings.getMappingsKey());
- Assert.assertEquals(mappings.get(operMappingsList.indexOf(operMappings))
- .getMappingsValue(), operMappings.getMappingsValue());
+ Map<MappingsKey, Mappings> operMappingsList = operAa.getMappings();
+ for (Mappings operMappings : operMappingsList.values()) {
+ Assert.assertTrue(mappings.contains(operMappings));
}
- List<AutoattachExternalIds> operExternalIds = operAa.getAutoattachExternalIds();
+ Map<AutoattachExternalIdsKey, AutoattachExternalIds> operExternalIds =
+ operAa.getAutoattachExternalIds();
externalIds.add(new AutoattachExternalIdsBuilder()
.setAutoattachExternalIdKey(SouthboundConstants.AUTOATTACH_ID_EXTERNAL_ID_KEY)
.setAutoattachExternalIdValue(operAa.getAutoattachId().getValue())
.build());
- for (AutoattachExternalIds operExternalId : operExternalIds) {
- Assert.assertEquals(externalIds.get(operExternalIds.indexOf(operExternalId))
- .getAutoattachExternalIdKey(), operExternalId.getAutoattachExternalIdKey());
- Assert.assertEquals(externalIds.get(operExternalIds.indexOf(operExternalId))
- .getAutoattachExternalIdValue(), operExternalId.getAutoattachExternalIdValue());
+ for (AutoattachExternalIds operExternalId : operExternalIds.values()) {
+ Assert.assertTrue(externalIds.contains(operExternalId));
}
// DELETE: Delete AutoAttach table
}
}
- private Autoattach getAutoAttach(OvsdbNodeAugmentation ovsdbNodeAugmentation, Uri uri) {
+ private static Autoattach getAutoAttach(OvsdbNodeAugmentation ovsdbNodeAugmentation, Uri uri) {
if (ovsdbNodeAugmentation.getAutoattach() != null
&& !ovsdbNodeAugmentation.getAutoattach().isEmpty()) {
- for (Autoattach aa : ovsdbNodeAugmentation.getAutoattach()) {
+ for (Autoattach aa : ovsdbNodeAugmentation.getAutoattach().values()) {
if (aa.key().getAutoattachId().equals(uri)) {
return aa;
}
}
}
- private InstanceIdentifier<Node> getTpIid(ConnectionInfo connectionInfo, OvsdbBridgeAugmentation bridge) {
+ private static InstanceIdentifier<Node> getTpIid(ConnectionInfo connectionInfo, OvsdbBridgeAugmentation bridge) {
return SouthboundUtils.createInstanceIdentifier(connectionInfo, bridge.getBridgeName());
}
private OvsdbTerminationPointAugmentation getOvsdbTerminationPointAugmentation(
ConnectionInfo connectionInfo, String bridgeName, LogicalDatastoreType store, int index) {
- List<TerminationPoint> tpList = getBridgeNode(connectionInfo, bridgeName, store).getTerminationPoint();
+ Map<TerminationPointKey, TerminationPoint> tpList = getBridgeNode(connectionInfo, bridgeName, store)
+ .nonnullTerminationPoint();
if (tpList == null) {
return null;
}
- return tpList.get(index).augmentation(OvsdbTerminationPointAugmentation.class);
+ return Iterables.get(tpList.values(), index).augmentation(OvsdbTerminationPointAugmentation.class);
}
@Test
Assert.assertNotNull(terminationPointNode);
// Test read ifIndex
- List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
- for (TerminationPoint terminationPoint : terminationPoints) {
+ for (TerminationPoint terminationPoint : terminationPointNode.nonnullTerminationPoint().values()) {
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
terminationPoint.augmentation(OvsdbTerminationPointAugmentation.class);
if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
Assert.assertNotNull(terminationPointNode);
// READ
- List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
- for (TerminationPoint terminationPoint : terminationPoints) {
+ for (TerminationPoint terminationPoint : terminationPointNode.nonnullTerminationPoint().values()) {
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
terminationPoint.augmentation(OvsdbTerminationPointAugmentation.class);
if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
Assert.assertNotNull(terminationPointNode);
// READ
- List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
- for (TerminationPoint terminationPoint : terminationPoints) {
+ for (TerminationPoint terminationPoint : terminationPointNode.nonnullTerminationPoint().values()) {
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
terminationPoint.augmentation(OvsdbTerminationPointAugmentation.class);
if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
}
}
- private <T> void assertExpectedExist(List<T> expected, List<T> test) {
+ private static <I extends Identifier<T>, T extends Identifiable<I>> void assertExpectedExist(Map<I, T> expected,
+ Map<I, T> test) {
if (expected != null && test != null) {
- for (T exp : expected) {
- Assert.assertTrue("The retrieved values don't contain " + exp, test.contains(exp));
+ for (T exp : expected.values()) {
+ Assert.assertTrue("The retrieved values don't contain " + exp, test.containsValue(exp));
}
}
}
- private interface SouthboundTerminationPointHelper<T> {
+ private interface SouthboundTerminationPointHelper<I extends Identifier<T>, T extends Identifiable<I>> {
void writeValues(OvsdbTerminationPointAugmentationBuilder builder, List<T> values);
- List<T> readValues(OvsdbTerminationPointAugmentation augmentation);
+ Map<I, T> readValues(OvsdbTerminationPointAugmentation augmentation);
}
/*
*
* @see <code>SouthboundIT.generatePortExternalIdsTestCases()</code> for specific test case information
*/
- private <T> void testCRUDTerminationPoint(
- KeyValueBuilder<T> builder, String prefix, SouthboundTerminationPointHelper<T> helper)
+ private <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDTerminationPoint(
+ KeyValueBuilder<T> builder, String prefix, SouthboundTerminationPointHelper<I, T> helper)
throws InterruptedException {
final int terminationPointTestIndex = 0;
// updateFromTestCases represent the original test case value. updateToTestCases represent the new value after
// the update has been performed.
- List<SouthboundTestCase<T>> updateFromTestCases = generateKeyValueTestCases(builder, prefix + "From");
- List<SouthboundTestCase<T>> updateToTestCases = generateKeyValueTestCases(builder, prefix + "To");
+ List<SouthboundTestCase<I, T>> updateFromTestCases = generateKeyValueTestCases(builder, prefix + "From");
+ List<SouthboundTestCase<I, T>> updateToTestCases = generateKeyValueTestCases(builder, prefix + "To");
- for (SouthboundTestCase<T> updateFromTestCase : updateFromTestCases) {
- for (SouthboundTestCase<T> updateToTestCase : updateToTestCases) {
+ for (SouthboundTestCase<I, T> updateFromTestCase : updateFromTestCases) {
+ for (SouthboundTestCase<I, T> updateToTestCase : updateToTestCases) {
String testBridgeAndPortName = String.format("%s_%s", prefix, updateToTestCase.name);
// CREATE: Create the test bridge
getOvsdbTerminationPointAugmentation(connectionInfo, testBridgeAndPortName,
LogicalDatastoreType.CONFIGURATION, terminationPointTestIndex);
if (updateFromConfigurationTerminationPointAugmentation != null) {
- List<T> updateFromConfigurationValues =
+ Map<I, T> updateFromConfigurationValues =
helper.readValues(updateFromConfigurationTerminationPointAugmentation);
assertExpectedExist(updateFromTestCase.expectedValues, updateFromConfigurationValues);
}
getOvsdbTerminationPointAugmentation(connectionInfo, testBridgeAndPortName,
LogicalDatastoreType.OPERATIONAL, terminationPointTestIndex);
if (updateFromOperationalTerminationPointAugmentation != null) {
- List<T> updateFromOperationalValues =
+ Map<I, T> updateFromOperationalValues =
helper.readValues(updateFromOperationalTerminationPointAugmentation);
assertExpectedExist(updateFromTestCase.expectedValues, updateFromOperationalValues);
}
getOvsdbTerminationPointAugmentation(connectionInfo, testBridgeAndPortName,
LogicalDatastoreType.CONFIGURATION, terminationPointTestIndex);
if (updateToConfigurationTerminationPointAugmentation != null) {
- List<T> updateToConfigurationValues =
+ Map<I, T> updateToConfigurationValues =
helper.readValues(updateToConfigurationTerminationPointAugmentation);
assertExpectedExist(updateToTestCase.expectedValues, updateToConfigurationValues);
assertExpectedExist(updateFromTestCase.expectedValues, updateToConfigurationValues);
getOvsdbTerminationPointAugmentation(connectionInfo, testBridgeAndPortName,
LogicalDatastoreType.OPERATIONAL, terminationPointTestIndex);
if (updateToOperationalTerminationPointAugmentation != null) {
- List<T> updateToOperationalValues =
+ Map<I, T> updateToOperationalValues =
helper.readValues(updateToOperationalTerminationPointAugmentation);
if (updateFromTestCase.expectedValues != null) {
assertExpectedExist(updateToTestCase.expectedValues, updateToOperationalValues);
Assert.assertNotNull(terminationPointNode);
// READ
- List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation;
- for (TerminationPoint terminationPoint : terminationPoints) {
+ for (TerminationPoint terminationPoint : terminationPointNode.nonnullTerminationPoint().values()) {
ovsdbTerminationPointAugmentation = terminationPoint.augmentation(
OvsdbTerminationPointAugmentation.class);
if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
Thread.sleep(OVSDB_UPDATE_TIMEOUT);
terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
- terminationPoints = terminationPointNode.getTerminationPoint();
- for (TerminationPoint terminationPoint : terminationPoints) {
+ for (TerminationPoint terminationPoint : terminationPointNode.nonnullTerminationPoint().values()) {
ovsdbTerminationPointAugmentation = terminationPoint.augmentation(
OvsdbTerminationPointAugmentation.class);
if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
Assert.assertNotNull(terminationPointNode);
// READ
- List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
- for (TerminationPoint terminationPoint : terminationPoints) {
+ for (TerminationPoint terminationPoint : terminationPointNode.nonnullTerminationPoint().values()) {
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
terminationPoint.augmentation(OvsdbTerminationPointAugmentation.class);
if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
Thread.sleep(OVSDB_UPDATE_TIMEOUT);
terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
- terminationPoints = terminationPointNode.getTerminationPoint();
- for (TerminationPoint terminationPoint : terminationPoints) {
+ for (TerminationPoint terminationPoint : terminationPointNode.nonnullTerminationPoint().values()) {
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
terminationPoint.augmentation(OvsdbTerminationPointAugmentation.class);
if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
Assert.assertNotNull(terminationPointNode);
// READ
- List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
+ Collection<TerminationPoint> terminationPoints =
+ terminationPointNode.nonnullTerminationPoint().values();
for (TerminationPoint terminationPoint : terminationPoints) {
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
terminationPoint.augmentation(OvsdbTerminationPointAugmentation.class);
Thread.sleep(OVSDB_UPDATE_TIMEOUT);
terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
- terminationPoints = terminationPointNode.getTerminationPoint();
- for (TerminationPoint terminationPoint : terminationPoints) {
+ for (TerminationPoint terminationPoint : terminationPointNode.nonnullTerminationPoint().values()) {
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
terminationPoint.augmentation(OvsdbTerminationPointAugmentation.class);
if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
Assert.assertNotNull("Expected to find topology: " + topologyPath, topology);
Assert.assertNotNull("Expected to find some nodes" + topology.getNode());
LOG.info("expectedNodeId: {}, getNode: {}", expectedNodeId, topology.getNode());
- for (Node node : topology.getNode()) {
+ for (Node node : topology.nonnullNode().values()) {
if (node.getNodeId().getValue().equals(expectedNodeId.getValue())) {
foundNode = node;
break;
new BridgeOtherConfigsSouthboundHelper());
}
- private interface SouthboundBridgeHelper<T> {
+ private interface SouthboundBridgeHelper<I extends Identifier<T>, T extends Identifiable<I>> {
void writeValues(OvsdbBridgeAugmentationBuilder builder, List<T> values);
- List<T> readValues(OvsdbBridgeAugmentation augmentation);
+ Map<I, T> readValues(OvsdbBridgeAugmentation augmentation);
}
- private <T> void testCRUDBridge(String prefix, KeyValueBuilder<T> builder, SouthboundBridgeHelper<T> helper)
- throws InterruptedException {
+ private <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDBridge(String prefix,
+ KeyValueBuilder<T> builder, SouthboundBridgeHelper<I, T> helper) throws InterruptedException {
ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portNumber);
// updateFromTestCases represent the original test case value. updateToTestCases represent the new value after
// the update has been performed.
- List<SouthboundTestCase<T>> updateFromTestCases = generateKeyValueTestCases(builder, prefix + "From");
- List<SouthboundTestCase<T>> updateToTestCases = generateKeyValueTestCases(builder, prefix + "To");
- for (SouthboundTestCase<T> updateFromTestCase : updateFromTestCases) {
- for (SouthboundTestCase<T> updateToTestCase : updateToTestCases) {
+ List<SouthboundTestCase<I, T>> updateFromTestCases = generateKeyValueTestCases(builder, prefix + "From");
+ List<SouthboundTestCase<I, T>> updateToTestCases = generateKeyValueTestCases(builder, prefix + "To");
+ for (SouthboundTestCase<I, T> updateFromTestCase : updateFromTestCases) {
+ for (SouthboundTestCase<I, T> updateToTestCase : updateToTestCases) {
String testBridgeName = String.format("%s_%s", prefix, updateToTestCase.name);
// CREATE: Create the test bridge
// READ: Read the test bridge and ensure changes are propagated to the CONFIGURATION data store,
// then repeat for OPERATIONAL data store
- List<T> updateFromConfigurationExternalIds = helper.readValues(getBridge(connectionInfo, testBridgeName,
- LogicalDatastoreType.CONFIGURATION));
+ Map<I, T> updateFromConfigurationExternalIds = helper.readValues(getBridge(connectionInfo,
+ testBridgeName, LogicalDatastoreType.CONFIGURATION));
assertExpectedExist(updateFromTestCase.expectedValues, updateFromConfigurationExternalIds);
- List<T> updateFromOperationalExternalIds = helper.readValues(getBridge(connectionInfo, testBridgeName));
+ Map<I, T> updateFromOperationalExternalIds = helper.readValues(getBridge(connectionInfo,
+ testBridgeName));
assertExpectedExist(updateFromTestCase.expectedValues, updateFromOperationalExternalIds);
// UPDATE: update the values
// READ: the test bridge and ensure changes are propagated to the CONFIGURATION data store,
// then repeat for OPERATIONAL data store
- List<T> updateToConfigurationExternalIds = helper.readValues(getBridge(connectionInfo, testBridgeName,
+ Map<I, T> updateToConfigurationExternalIds = helper.readValues(getBridge(connectionInfo, testBridgeName,
LogicalDatastoreType.CONFIGURATION));
assertExpectedExist(updateToTestCase.expectedValues, updateToConfigurationExternalIds);
assertExpectedExist(updateFromTestCase.expectedValues, updateToConfigurationExternalIds);
- List<T> updateToOperationalExternalIds = helper.readValues(getBridge(connectionInfo, testBridgeName));
+ Map<I, T> updateToOperationalExternalIds = helper.readValues(getBridge(connectionInfo, testBridgeName));
if (updateFromTestCase.expectedValues != null) {
assertExpectedExist(updateToTestCase.expectedValues, updateToOperationalExternalIds);
assertExpectedExist(updateFromTestCase.expectedValues, updateToOperationalExternalIds);
ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portNumber);
Uri queueUri = new Uri("QUEUE-A1");
- try (TestQueue testQueue = new TestQueue(connectionInfo, queueUri, new Short("25"), null, null)) {
+ try (TestQueue testQueue = new TestQueue(connectionInfo, queueUri, Short.valueOf("25"), null, null)) {
OvsdbNodeAugmentation ovsdbNodeAugmentation = getOvsdbNode(connectionInfo,
LogicalDatastoreType.OPERATIONAL);
Queues operQueue = getQueue(queueUri, ovsdbNodeAugmentation);
Assert.assertNull(operQueue);
}
- private static class SouthboundQueuesExternalIdsHelper implements SouthboundQueueHelper<QueuesExternalIds> {
+ private static class SouthboundQueuesExternalIdsHelper
+ implements SouthboundQueueHelper<QueuesExternalIdsKey, QueuesExternalIds> {
@Override
public void writeValues(QueuesBuilder builder, List<QueuesExternalIds> values) {
builder.setQueuesExternalIds(values);
}
@Override
- public List<QueuesExternalIds> readValues(Queues queue) {
+ public Map<QueuesExternalIdsKey, QueuesExternalIds> readValues(Queues queue) {
return queue.getQueuesExternalIds();
}
}
- private static class SouthboundQueuesOtherConfigHelper implements SouthboundQueueHelper<QueuesOtherConfig> {
+ private static class SouthboundQueuesOtherConfigHelper
+ implements SouthboundQueueHelper<QueuesOtherConfigKey, QueuesOtherConfig> {
@Override
public void writeValues(QueuesBuilder builder, List<QueuesOtherConfig> values) {
builder.setQueuesOtherConfig(values);
}
@Override
- public List<QueuesOtherConfig> readValues(Queues queue) {
+ public Map<QueuesOtherConfigKey, QueuesOtherConfig> readValues(Queues queue) {
return queue.getQueuesOtherConfig();
}
}
- private interface SouthboundQueueHelper<T> {
+ private interface SouthboundQueueHelper<I extends Identifier<T>, T extends Identifiable<I>> {
void writeValues(QueuesBuilder builder, List<T> values);
- List<T> readValues(Queues queue);
+ Map<I, T> readValues(Queues queue);
}
- private Queues getQueue(Uri queueId, OvsdbNodeAugmentation node) {
- for (Queues queue : node.getQueues()) {
+ private static Queues getQueue(Uri queueId, OvsdbNodeAugmentation node) {
+ for (Queues queue : node.nonnullQueues().values()) {
if (queue.key().getQueueId().getValue().equals(queueId.getValue())) {
return queue;
}
return null;
}
- private static class SouthboundQosExternalIdsHelper implements SouthboundQosHelper<QosExternalIds> {
+ private static class SouthboundQosExternalIdsHelper
+ implements SouthboundQosHelper<QosExternalIdsKey, QosExternalIds> {
@Override
public void writeValues(QosEntriesBuilder builder, List<QosExternalIds> values) {
builder.setQosExternalIds(values);
}
@Override
- public List<QosExternalIds> readValues(QosEntries qos) {
+ public Map<QosExternalIdsKey, QosExternalIds> readValues(QosEntries qos) {
return qos.getQosExternalIds();
}
}
- private static class SouthboundQosOtherConfigHelper implements SouthboundQosHelper<QosOtherConfig> {
+ private static class SouthboundQosOtherConfigHelper
+ implements SouthboundQosHelper<QosOtherConfigKey, QosOtherConfig> {
@Override
public void writeValues(QosEntriesBuilder builder, List<QosOtherConfig> values) {
builder.setQosOtherConfig(values);
}
@Override
- public List<QosOtherConfig> readValues(QosEntries qos) {
+ public Map<QosOtherConfigKey, QosOtherConfig> readValues(QosEntries qos) {
return qos.getQosOtherConfig();
}
}
- private interface SouthboundQosHelper<T> {
+ private interface SouthboundQosHelper<I extends Identifier<T>, T extends Identifiable<I>> {
void writeValues(QosEntriesBuilder builder, List<T> values);
- List<T> readValues(QosEntries qos);
+ Map<I, T> readValues(QosEntries qos);
}
- private QosEntries getQos(Uri qosId, OvsdbNodeAugmentation node) {
- for (QosEntries qos : node.getQosEntries()) {
+ private static QosEntries getQos(Uri qosId, OvsdbNodeAugmentation node) {
+ for (QosEntries qos : node.nonnullQosEntries().values()) {
if (qos.key().getQosId().equals(qosId)) {
return qos;
}
return null;
}
- private <T> void testCRUDQueue(
- KeyValueBuilder<T> builder, String prefix, SouthboundQueueHelper<T> helper)
+ private <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDQueue(
+ KeyValueBuilder<T> builder, String prefix, SouthboundQueueHelper<I, T> helper)
throws InterruptedException {
ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portNumber);
// updateFromTestCases represent the original test case value. updateToTestCases represent the new value after
// the update has been performed.
- List<SouthboundTestCase<T>> updateFromTestCases = generateKeyValueTestCases(builder, prefix + "From");
- List<SouthboundTestCase<T>> updateToTestCases = generateKeyValueTestCases(builder, prefix + "To");
+ List<SouthboundTestCase<I, T>> updateFromTestCases = generateKeyValueTestCases(builder, prefix + "From");
+ List<SouthboundTestCase<I, T>> updateToTestCases = generateKeyValueTestCases(builder, prefix + "To");
- for (SouthboundTestCase<T> updateFromTestCase : updateFromTestCases) {
- for (SouthboundTestCase<T> updateToTestCase : updateToTestCases) {
+ for (SouthboundTestCase<I, T> updateFromTestCase : updateFromTestCases) {
+ for (SouthboundTestCase<I, T> updateToTestCase : updateToTestCases) {
String testQueueId = String.format("%s_%s", prefix, updateToTestCase.name);
// CREATE: and update the test queue with starting values.
try (TestQueue testQueue = new TestQueue(connectionInfo, new Uri(testQueueId),
- new Short("45"), null, null)) {
+ Short.valueOf("45"), null, null)) {
QueuesBuilder queuesBuilder = new QueuesBuilder();
queuesBuilder.setQueueId(new Uri(testQueueId));
InstanceIdentifier<Queues> queueIid = SouthboundUtils.createInstanceIdentifier(connectionInfo)
Queues queueFromConfig =
getQueue(new Uri(testQueueId), updateFromConfigurationOvsdbNodeAugmentation);
if (queueFromConfig != null) {
- List<T> updateFromConfigurationValues =
- helper.readValues(queueFromConfig);
- assertExpectedExist(updateFromTestCase.expectedValues, updateFromConfigurationValues);
+ assertExpectedExist(updateFromTestCase.expectedValues, helper.readValues(queueFromConfig));
}
queueOperationalListener.waitForUpdate(OVSDB_UPDATE_TIMEOUT);
LogicalDatastoreType.OPERATIONAL);
Queues queueFromOper = getQueue(new Uri(testQueueId), updateFromOperationalOvsdbNodeAugmentation);
if (queueFromOper != null) {
- List<T> updateFromOperationalValues =
- helper.readValues(queueFromOper);
- assertExpectedExist(updateFromTestCase.expectedValues, updateFromOperationalValues);
+ assertExpectedExist(updateFromTestCase.expectedValues, helper.readValues(queueFromOper));
}
// UPDATE: update the values
LogicalDatastoreType.CONFIGURATION);
Queues queueToConfig = getQueue(new Uri(testQueueId), updateToConfigurationOvsdbNodeAugmentation);
if (queueToConfig != null) {
- List<T> updateToConfigurationValues =
- helper.readValues(queueToConfig);
- assertExpectedExist(updateToTestCase.expectedValues, updateToConfigurationValues);
+ assertExpectedExist(updateToTestCase.expectedValues, helper.readValues(queueToConfig));
}
queueOperationalListener.waitForUpdate(OVSDB_UPDATE_TIMEOUT);
LogicalDatastoreType.OPERATIONAL);
Queues queueToOper = getQueue(new Uri(testQueueId), updateToOperationalOvsdbNodeAugmentation);
if (queueToOper != null) {
- List<T> updateToOperationalValues =
- helper.readValues(queueToOper);
- assertExpectedExist(updateToTestCase.expectedValues, updateToOperationalValues);
+ assertExpectedExist(updateToTestCase.expectedValues, helper.readValues(queueToOper));
}
// DELETE handled by TestQueue
String testQueueId = "testQueueDscp";
// CREATE: and update the test queue with starting values.
- try (TestQueue testQueue = new TestQueue(connectionInfo, new Uri(testQueueId), new Short("0"), null, null)) {
+ try (TestQueue testQueue = new TestQueue(connectionInfo, new Uri(testQueueId), (short) 0, null, null)) {
for (Short dscp = 1; dscp < 64; dscp++) {
QueuesBuilder queuesBuilder = new QueuesBuilder();
queuesBuilder.setQueueId(new Uri(testQueueId));
}
- private <T> void testCRUDQos(
- KeyValueBuilder<T> builder, String prefix, SouthboundQosHelper<T> helper)
+ private <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDQos(
+ KeyValueBuilder<T> builder, String prefix, SouthboundQosHelper<I, T> helper)
throws InterruptedException {
ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portNumber);
// updateFromTestCases represent the original test case value. updateToTestCases represent the new value after
// the update has been performed.
- List<SouthboundTestCase<T>> updateFromTestCases = generateKeyValueTestCases(builder, prefix + "From");
- List<SouthboundTestCase<T>> updateToTestCases = generateKeyValueTestCases(builder, prefix + "To");
+ List<SouthboundTestCase<I, T>> updateFromTestCases = generateKeyValueTestCases(builder, prefix + "From");
+ List<SouthboundTestCase<I, T>> updateToTestCases = generateKeyValueTestCases(builder, prefix + "To");
- for (SouthboundTestCase<T> updateFromTestCase : updateFromTestCases) {
- for (SouthboundTestCase<T> updateToTestCase : updateToTestCases) {
+ for (SouthboundTestCase<I, T> updateFromTestCase : updateFromTestCases) {
+ for (SouthboundTestCase<I, T> updateToTestCase : updateToTestCases) {
String testQosId = String.format("%s_%s", prefix, updateToTestCase.name);
// CREATE: and update the test qos with starting values.
LogicalDatastoreType.CONFIGURATION);
QosEntries qosFromConfig = getQos(new Uri(testQosId), updateFromConfigurationOvsdbNodeAugmentation);
if (qosFromConfig != null) {
- List<T> updateFromConfigurationValues =
- helper.readValues(qosFromConfig);
- assertExpectedExist(updateFromTestCase.expectedValues, updateFromConfigurationValues);
+ assertExpectedExist(updateFromTestCase.expectedValues, helper.readValues(qosFromConfig));
}
qosOperationalListener.waitForUpdate(OVSDB_UPDATE_TIMEOUT);
LogicalDatastoreType.OPERATIONAL);
QosEntries qosFromOper = getQos(new Uri(testQosId), updateFromOperationalOvsdbNodeAugmentation);
if (qosFromOper != null) {
- List<T> updateFromOperationalValues =
- helper.readValues(qosFromOper);
- assertExpectedExist(updateFromTestCase.expectedValues, updateFromOperationalValues);
+ assertExpectedExist(updateFromTestCase.expectedValues, helper.readValues(qosFromOper));
}
// UPDATE: update the values
LogicalDatastoreType.CONFIGURATION);
QosEntries qosToConfig = getQos(new Uri(testQosId), updateToConfigurationOvsdbNodeAugmentation);
if (qosToConfig != null) {
- List<T> updateToConfigurationValues =
- helper.readValues(qosToConfig);
- assertExpectedExist(updateToTestCase.expectedValues, updateToConfigurationValues);
+ assertExpectedExist(updateToTestCase.expectedValues, helper.readValues(qosToConfig));
}
qosOperationalListener.waitForUpdate(OVSDB_UPDATE_TIMEOUT);
LogicalDatastoreType.OPERATIONAL);
QosEntries qosToOper = getQos(new Uri(testQosId), updateToOperationalOvsdbNodeAugmentation);
if (qosToOper != null) {
- List<T> updateToOperationalValues =
- helper.readValues(qosToOper);
- assertExpectedExist(updateToTestCase.expectedValues, updateToOperationalValues);
+ assertExpectedExist(updateToTestCase.expectedValues, helper.readValues(qosToOper));
}
// DELETE handled by TestQueue
// CREATE: and update the test queue with starting values.
try (TestQos testQos = new TestQos(connectionInfo, new Uri(testQosId),
SouthboundMapper.createQosType(SouthboundConstants.QOS_LINUX_HTB), null, null);
- TestQueue testQueue1 = new TestQueue(connectionInfo, new Uri("queue1"), new Short("12"), null, null);
- TestQueue testQueue2 = new TestQueue(connectionInfo, new Uri("queue2"), new Short("35"), null, null)) {
+ TestQueue testQueue1 = new TestQueue(connectionInfo, new Uri("queue1"), Short.valueOf("12"), null,
+ null);
+ TestQueue testQueue2 = new TestQueue(connectionInfo, new Uri("queue2"), Short.valueOf("35"), null,
+ null)) {
QosEntriesBuilder qosBuilder = new QosEntriesBuilder();
qosBuilder.setQosId(new Uri(testQosId));
InstanceIdentifier<QosEntries> qosIid = SouthboundUtils.createInstanceIdentifier(connectionInfo)
OvsdbQueueRef queue2Ref = new OvsdbQueueRef(queue2Iid);
List<QueueList> queueList = new ArrayList<>();
- queueList.add(new QueueListBuilder().setQueueNumber(new Long("1")).setQueueRef(queue1Ref).build());
- queueList.add(new QueueListBuilder().setQueueNumber(new Long("2")).setQueueRef(queue2Ref).build());
+ queueList.add(new QueueListBuilder().setQueueNumber(Uint32.ONE).setQueueRef(queue1Ref).build());
+ queueList.add(new QueueListBuilder().setQueueNumber(Uint32.TWO).setQueueRef(queue2Ref).build());
qosBuilder.setQueueList(queueList);
LogicalDatastoreType.OPERATIONAL);
QosEntries operQos = getQos(new Uri(testQosId), ovsdbNodeAugmentation);
Assert.assertNotNull(operQos);
- List<QueueList> operQueueList = operQos.getQueueList();
+ Map<QueueListKey, QueueList> operQueueList = operQos.getQueueList();
Assert.assertNotNull(operQueueList);
for (QueueList queueEntry : queueList) {
Assert.assertTrue(isQueueInList(operQueueList, queueEntry));
// DELETE one queue from queue list and check that one remains
KeyedInstanceIdentifier<QueueList, QueueListKey> qosQueueIid = qosIid
- .child(QueueList.class, new QueueListKey(new Long("1")));
+ .child(QueueList.class, new QueueListKey(Uint32.ONE));
Assert.assertTrue(mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION, qosQueueIid));
qosOperationalListener.waitForUpdate(OVSDB_UPDATE_TIMEOUT);
// DELETE queue list and check that list is empty
qosQueueIid = qosIid
- .child(QueueList.class, new QueueListKey(new Long("1")));
+ .child(QueueList.class, new QueueListKey(Uint32.ONE));
Assert.assertTrue(mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION, qosQueueIid));
qosOperationalListener.waitForUpdate(OVSDB_UPDATE_TIMEOUT);
- private Boolean isQueueInList(List<QueueList> queueList, QueueList queue) {
- for (QueueList queueEntry : queueList) {
+ private static Boolean isQueueInList(Map<QueueListKey, QueueList> queueList, QueueList queue) {
+ for (QueueList queueEntry : queueList.values()) {
if (queueEntry.getQueueNumber().equals(queue.getQueueNumber())
&& queueEntry.getQueueRef().equals(queue.getQueueRef())) {
return true;
*
* @param <T> The type of data used for the test case.
*/
- private static final class SouthboundTestCase<T> {
+ private static final class SouthboundTestCase<I extends Identifier<T>, T extends Identifiable<I>> {
private final String name;
private final List<T> inputValues;
- private final List<T> expectedValues;
+ private final Map<I, T> expectedValues;
/**
* Creates an instance of a southbound test case.
SouthboundTestCase(final String name, final List<T> inputValues, final List<T> expectedValues) {
this.name = name;
this.inputValues = inputValues;
- this.expectedValues = expectedValues;
+ this.expectedValues = Maps.uniqueIndex(expectedValues, Identifiable::key);
}
}
*
* @param <T> The type of data used for the test case.
*/
- private static final class SouthboundTestCaseBuilder<T> {
+ private static final class SouthboundTestCaseBuilder<I extends Identifier<T>, T extends Identifiable<I>> {
private String name;
private List<T> inputValues;
private List<T> expectedValues;
* @param value The test case's name.
* @return The builder.
*/
- public SouthboundTestCaseBuilder<T> name(final String value) {
+ public SouthboundTestCaseBuilder<I, T> name(final String value) {
this.name = value;
return this;
}
* @return The builder.
*/
@SafeVarargs
- public final SouthboundTestCaseBuilder<T> input(final T... values) {
+ public final SouthboundTestCaseBuilder<I, T> input(final T... values) {
this.inputValues = Lists.newArrayList(values);
return this;
}
*
* @return The builder.
*/
- public SouthboundTestCaseBuilder<T> expectInputAsOutput() {
+ public SouthboundTestCaseBuilder<I, T> expectInputAsOutput() {
this.expectedValues = this.inputValues;
return this;
}
*
* @return The builder.
*/
- public SouthboundTestCaseBuilder<T> expectNoOutput() {
+ public SouthboundTestCaseBuilder<I, T> expectNoOutput() {
this.expectedValues = null;
return this;
}
*
* @return The test case.
*/
- public SouthboundTestCase<T> build() {
+ public SouthboundTestCase<I, T> build() {
return new SouthboundTestCase<>(name, inputValues, expectedValues);
}
}
* Generates the test cases involved in testing key-value-based data. See inline comments for descriptions of
* the particular cases considered.
*/
- private static <T> List<SouthboundTestCase<T>> generateKeyValueTestCases(
- KeyValueBuilder<T> builder, String testName) {
- List<SouthboundTestCase<T>> testCases = new ArrayList<>();
+ private static <I extends Identifier<T>, T extends Identifiable<I>> List<SouthboundTestCase<I, T>>
+ generateKeyValueTestCases(KeyValueBuilder<T> builder, String testName) {
+ List<SouthboundTestCase<I, T>> testCases = new ArrayList<>();
final String goodKey = "GoodKey";
final String goodValue = "GoodValue";
// Description: Create a termination point with one value
// Expected: A port is created with the single value specified below
final String testOneName = "TestOne" + testName;
- testCases.add(new SouthboundTestCaseBuilder<T>()
+ testCases.add(new SouthboundTestCaseBuilder<I, T>()
.name(testOneName)
.input(builder.build(testOneName, idKey, idValue))
.expectInputAsOutput()
// Description: Create a termination point with multiple (five) values
// Expected: A port is created with the five values specified below
final String testFiveName = "TestFive" + testName;
- testCases.add(new SouthboundTestCaseBuilder<T>()
+ testCases.add(new SouthboundTestCaseBuilder<I, T>()
.name(testFiveName)
.input(
builder.build(testFiveName, idKey, idValue),
// UNSPECIFIED)
// Expected: A port is created without any values
final String testOneGoodOneMalformedValueName = "TestOneGoodOneMalformedValue" + testName;
- testCases.add(new SouthboundTestCaseBuilder<T>()
+ testCases.add(new SouthboundTestCaseBuilder<I, T>()
.name(testOneGoodOneMalformedValueName)
.input(
builder.build(testOneGoodOneMalformedValueName, goodKey, goodValue),
return testCases;
}
- private static class PortExternalIdsSouthboundHelper implements SouthboundTerminationPointHelper<PortExternalIds> {
+ private static class PortExternalIdsSouthboundHelper
+ implements SouthboundTerminationPointHelper<PortExternalIdsKey, PortExternalIds> {
@Override
public void writeValues(OvsdbTerminationPointAugmentationBuilder builder, List<PortExternalIds> values) {
builder.setPortExternalIds(values);
}
@Override
- public List<PortExternalIds> readValues(OvsdbTerminationPointAugmentation augmentation) {
+ public Map<PortExternalIdsKey, PortExternalIds> readValues(OvsdbTerminationPointAugmentation augmentation) {
return augmentation.getPortExternalIds();
}
}
- private static class InterfaceExternalIdsSouthboundHelper implements
- SouthboundTerminationPointHelper<InterfaceExternalIds> {
+ private static class InterfaceExternalIdsSouthboundHelper
+ implements SouthboundTerminationPointHelper<InterfaceExternalIdsKey, InterfaceExternalIds> {
@Override
public void writeValues(
OvsdbTerminationPointAugmentationBuilder builder, List<InterfaceExternalIds> values) {
}
@Override
- public List<InterfaceExternalIds> readValues(OvsdbTerminationPointAugmentation augmentation) {
+ public Map<InterfaceExternalIdsKey, InterfaceExternalIds> readValues(
+ OvsdbTerminationPointAugmentation augmentation) {
return augmentation.getInterfaceExternalIds();
}
}
- private static class InterfaceLldpSouthboundHelper implements SouthboundTerminationPointHelper<InterfaceLldp> {
+ private static class InterfaceLldpSouthboundHelper
+ implements SouthboundTerminationPointHelper<InterfaceLldpKey, InterfaceLldp> {
@Override
public void writeValues(
OvsdbTerminationPointAugmentationBuilder builder, List<InterfaceLldp> values) {
}
@Override
- public List<InterfaceLldp> readValues(OvsdbTerminationPointAugmentation augmentation) {
+ public Map<InterfaceLldpKey, InterfaceLldp> readValues(OvsdbTerminationPointAugmentation augmentation) {
return augmentation.getInterfaceLldp();
}
}
- private static class OptionsSouthboundHelper implements SouthboundTerminationPointHelper<Options> {
+ private static class OptionsSouthboundHelper implements SouthboundTerminationPointHelper<OptionsKey, Options> {
@Override
public void writeValues(
OvsdbTerminationPointAugmentationBuilder builder, List<Options> values) {
}
@Override
- public List<Options> readValues(OvsdbTerminationPointAugmentation augmentation) {
+ public Map<OptionsKey, Options> readValues(OvsdbTerminationPointAugmentation augmentation) {
return augmentation.getOptions();
}
}
- private static class InterfaceOtherConfigsSouthboundHelper implements
- SouthboundTerminationPointHelper<InterfaceOtherConfigs> {
+ private static class InterfaceOtherConfigsSouthboundHelper
+ implements SouthboundTerminationPointHelper<InterfaceOtherConfigsKey, InterfaceOtherConfigs> {
@Override
public void writeValues(
OvsdbTerminationPointAugmentationBuilder builder, List<InterfaceOtherConfigs> values) {
}
@Override
- public List<InterfaceOtherConfigs> readValues(OvsdbTerminationPointAugmentation augmentation) {
+ public Map<InterfaceOtherConfigsKey, InterfaceOtherConfigs> readValues(
+ OvsdbTerminationPointAugmentation augmentation) {
return augmentation.getInterfaceOtherConfigs();
}
}
private static class PortOtherConfigsSouthboundHelper implements
- SouthboundTerminationPointHelper<PortOtherConfigs> {
+ SouthboundTerminationPointHelper<PortOtherConfigsKey, PortOtherConfigs> {
@Override
public void writeValues(
OvsdbTerminationPointAugmentationBuilder builder, List<PortOtherConfigs> values) {
}
@Override
- public List<PortOtherConfigs> readValues(OvsdbTerminationPointAugmentation augmentation) {
+ public Map<PortOtherConfigsKey, PortOtherConfigs> readValues(OvsdbTerminationPointAugmentation augmentation) {
return augmentation.getPortOtherConfigs();
}
}
- private static class BridgeExternalIdsSouthboundHelper implements SouthboundBridgeHelper<BridgeExternalIds> {
+ private static class BridgeExternalIdsSouthboundHelper
+ implements SouthboundBridgeHelper<BridgeExternalIdsKey, BridgeExternalIds> {
@Override
public void writeValues(
OvsdbBridgeAugmentationBuilder builder, List<BridgeExternalIds> values) {
}
@Override
- public List<BridgeExternalIds> readValues(OvsdbBridgeAugmentation augmentation) {
+ public Map<BridgeExternalIdsKey, BridgeExternalIds> readValues(OvsdbBridgeAugmentation augmentation) {
return augmentation.getBridgeExternalIds();
}
}
- private static class BridgeOtherConfigsSouthboundHelper implements SouthboundBridgeHelper<BridgeOtherConfigs> {
+ private static class BridgeOtherConfigsSouthboundHelper
+ implements SouthboundBridgeHelper<BridgeOtherConfigsKey, BridgeOtherConfigs> {
@Override
public void writeValues(
OvsdbBridgeAugmentationBuilder builder, List<BridgeOtherConfigs> values) {
}
@Override
- public List<BridgeOtherConfigs> readValues(OvsdbBridgeAugmentation augmentation) {
+ public Map<BridgeOtherConfigsKey, BridgeOtherConfigs> readValues(OvsdbBridgeAugmentation augmentation) {
return augmentation.getBridgeOtherConfigs();
}
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
* 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.utils.config;
import java.util.HashMap;
import java.util.Map;
-
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.FrameworkUtil;
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>javax.inject</groupId>
+ <artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
+ <optional>true</optional>
+ </dependency>
<!-- testing dependencies -->
<dependency>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<type>test-jar</type>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>javax.inject</groupId>
- <artifactId>javax.inject</artifactId>
- <version>1</version>
- <scope>compile</scope>
- </dependency>
</dependencies>
<build>
final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data) {
boolean result = false;
final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
- transaction.merge(logicalDatastoreType, path, data, true);
+ transaction.mergeParentStructureMerge(logicalDatastoreType, path, data);
FluentFuture<? extends @NonNull CommitInfo> future = transaction.commit();
try {
future.get();
final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data) {
boolean result = false;
final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
- transaction.put(logicalDatastoreType, path, data, true);
+ transaction.mergeParentStructurePut(logicalDatastoreType, path, data);
FluentFuture<? extends @NonNull CommitInfo> future = transaction.commit();
try {
future.get();
* 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.utils.mdsal.utils;
-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.MoreExecutors;
* {@link LogicalDatastoreType} which should be modified
* @param path
* {@link InstanceIdentifier} to read from
- * @return The {@link CheckedFuture} object to which you can assign a
+ * @return The {@link FluentFuture} object to which you can assign a
* callback
*/
public <D extends DataObject> FluentFuture<? extends @NonNull CommitInfo> delete(
* {@link InstanceIdentifier} for path to read
* @param <D>
* The data object type
- * @return The {@link CheckedFuture} object to which you can assign a
+ * @return The {@link FluentFuture} object to which you can assign a
* callback
*/
public <D extends DataObject> FluentFuture<? extends @NonNull CommitInfo> put(
final InstanceIdentifier<D> path,
final D data) {
final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
- transaction.put(logicalDatastoreType, path, data, true);
+ transaction.mergeParentStructurePut(logicalDatastoreType, path, data);
return transaction.commit();
}
* The data object type
* @param withParent
* Whether or not to create missing parent.
- * @return The {@link CheckedFuture} object to which you can assign a
+ * @return The {@link FluentFuture} object to which you can assign a
* callback
*/
+ // FIXME: eliminate the boolean flag here to separate out the distinct code paths
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);
+ if (withParent) {
+ transaction.mergeParentStructureMerge(logicalDatastoreType, path, data);
+ } else {
+ transaction.merge(logicalDatastoreType, path, data);
+ }
return transaction.commit();
}
* @param withParent
* Whether or not to create missing parent.
*/
+ // FIXME: eliminate the boolean flag here to separate out the distinct code paths
public <D extends DataObject> void merge(
final LogicalDatastoreType logicalDatastoreType,
final InstanceIdentifier<D> path,
* {@link InstanceIdentifier} for path to read
* @param <D>
* The data object type
- * @return The {@link CheckedFuture} object to which you can assign a
+ * @return The {@link FluentFuture} object to which you can assign a
* callback
*/
public <D extends DataObject> FluentFuture<Optional<D>> read(
}
/**
- * Assign a default callback to a {@link CheckedFuture}. It will either log
+ * Assign a default callback to a {@link FluentFuture}. It will either log
* a message at DEBUG level if the transaction succeed, or will log at ERROR
* level and throw an {@link IllegalStateException} if the transaction
* failed.
final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data) {
boolean result = false;
final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
- transaction.merge(logicalDatastoreType, path, data, true);
+ transaction.mergeParentStructureMerge(logicalDatastoreType, path, data);
FluentFuture<? extends CommitInfo> future = transaction.commit();
try {
future.get();
final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data) {
boolean result = false;
final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
- transaction.put(logicalDatastoreType, path, data, true);
+ transaction.mergeParentStructurePut(logicalDatastoreType, path, data);
FluentFuture<? extends CommitInfo> future = transaction.commit();
try {
future.get();
package org.opendaylight.ovsdb.utils.mdsal.utils;
-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.MoreExecutors;
final InstanceIdentifier<D> path,
final D data) {
final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
- transaction.put(logicalDatastoreType, path, data, true);
+ transaction.mergeParentStructurePut(logicalDatastoreType, path, data);
return transaction.commit();
}
* @return The {@link FluentFuture} object to which you can assign a
* callback
*/
+ // FIXME: eliminate the boolean flag here to separate out the distinct code paths
public <D extends DataObject> FluentFuture<? extends 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);
+ if (withParent) {
+ transaction.mergeParentStructureMerge(logicalDatastoreType, path, data);
+ } else {
+ transaction.merge(logicalDatastoreType, path, data);
+ }
return transaction.commit();
}
* @param withParent
* Whether or not to create missing parent.
*/
+ // FIXME: eliminate the boolean flag here to separate out the distinct code paths
public <D extends DataObject> void merge(
final LogicalDatastoreType logicalDatastoreType,
final InstanceIdentifier<D> path,
}
/**
- * Assign a default callback to a {@link CheckedFuture}. It will either log
+ * Assign a default callback to a {@link FluentFuture}. It will either log
* a message at DEBUG level if the transaction succeed, or will log at ERROR
* level and throw an {@link IllegalStateException} if the transaction
* failed.
package org.opendaylight.ovsdb.utils.mdsal.utils;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
-
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
* 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.utils.mdsal.utils;
import java.lang.management.ManagementFactory;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
-
import javax.management.InstanceNotFoundException;
import javax.management.MBeanException;
import javax.management.MBeanServer;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.ReflectionException;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return listOfShards;
}
-}
\ No newline at end of file
+}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
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)).mergeParentStructureMerge(any(LogicalDatastoreType.class),
+ any(InstanceIdentifier.class), any(DataObject.class));
verify(writeTransaction, times(1)).commit();
assertTrue("Error, the merge transaction failed", result);
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)).mergeParentStructurePut(any(LogicalDatastoreType.class),
+ any(InstanceIdentifier.class), any(DataObject.class));
verify(writeTransaction, times(1)).commit();
assertTrue("Error, the put transaction failed", result);
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
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)).mergeParentStructureMerge(any(LogicalDatastoreType.class),
+ any(InstanceIdentifier.class), any(DataObject.class));
verify(writeTransaction, times(1)).commit();
assertTrue("Error, the merge transaction failed", result);
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)).mergeParentStructurePut(any(LogicalDatastoreType.class),
+ any(InstanceIdentifier.class), any(DataObject.class));
verify(writeTransaction, times(1)).commit();
assertTrue("Error, the put transaction failed", result);
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
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>
- <artifactId>mdsal-artifacts</artifactId>
- <version>1.11.0</version>
+ <artifactId>controller-artifacts</artifactId>
+ <version>2.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
- </dependencyManagement>-->
+ </dependencyManagement>
<dependencies>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>odl-mdsal-broker</artifactId>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </dependency>
+
<dependency>
<groupId>org.opendaylight.ovsdb</groupId>
<artifactId>odl-ovsdb-southbound-api</artifactId>
<artifactId>utils.southbound-utils</artifactId>
<version>${project.version}</version>
</dependency>
-
- <!--<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>odl-mdsal-broker</artifactId>
- <type>xml</type>
- <classifier>features</classifier>
- </dependency>-->
</dependencies>
</project>
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
- <version>1</version>
<scope>compile</scope>
</dependency>
<dependency>
OvsdbBridgeAugmentation bridge =
southboundUtils.getBridge(connectionInfo, "br-int");
if (bridge != null && bridge.getControllerEntry() != null) {
- controllerEntry = bridge.getControllerEntry().iterator().next();
+ controllerEntry = bridge.getControllerEntry().values().iterator().next();
assertEquals(controllerTarget, controllerEntry.getTarget().getValue());
if (controllerEntry.isIsConnected()) {
LOG.info("isControllerConnected exit: true {}", controllerTarget);
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeOtherConfigsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsKey;
private static final String DISABLE_IN_BAND = "disable-in-band";
private static final String PATCH_PORT_TYPE = "patch";
// External ID key used for mapping between an OVSDB port and an interface name
- private static final String EXTERNAL_INTERFACE_ID_KEY = "iface-id";
+ private static final InterfaceExternalIdsKey EXTERNAL_INTERFACE_ID_KEY = new InterfaceExternalIdsKey("iface-id");
private static final String CREATED_BY = "created_by";
private static final String ODL = "odl";
private static final String FORMAT = "(\\d+)\\.(\\d+)\\.(\\d+)";
private static final Pattern PATTERN = Pattern.compile(FORMAT);
+ // DPDK interface type
+ private static final InterfaceTypeEntryKey DPDK_IFACE_KEY = new InterfaceTypeEntryKey(InterfaceTypeDpdk.class);
private final UtilsProvider provider;
OvsdbBridgeAugmentation bridgeAug = extractBridgeAugmentation(bridgeNode);
//Only add controller entries that do not already exist on this bridge
- List<ControllerEntry> existingControllerEntries = bridgeAug.getControllerEntry();
+ Map<ControllerEntryKey, ControllerEntry> existingControllerEntries = bridgeAug.getControllerEntry();
List<ControllerEntry> newControllerEntries = new ArrayList<>();
if (existingControllerEntries != null) {
NEW_ENTRY_LOOP:
for (ControllerEntry newEntry : createControllerEntries(controllers, maxBackoff, inactivityProbe)) {
- for (ControllerEntry existingEntry : existingControllerEntries) {
+ for (ControllerEntry existingEntry : existingControllerEntries.values()) {
if (newEntry.getTarget().equals(existingEntry.getTarget())) {
continue NEW_ENTRY_LOOP;
}
// Check if ovsdb node has manager entries
OvsdbNodeAugmentation ovsdbNodeAugmentation = extractOvsdbNode(node);
if (ovsdbNodeAugmentation != null) {
- List<ManagerEntry> managerEntries = ovsdbNodeAugmentation.getManagerEntry();
+ Map<ManagerEntryKey, ManagerEntry> managerEntries = ovsdbNodeAugmentation.getManagerEntry();
if (managerEntries != null && !managerEntries.isEmpty()) {
- for (ManagerEntry managerEntry : managerEntries) {
+ for (ManagerEntry managerEntry : managerEntries.values()) {
if (managerEntry == null || managerEntry.getTarget() == null) {
continue;
}
public boolean isBridgeOnOvsdbNode(Node ovsdbNode, String bridgeName) {
OvsdbNodeAugmentation ovsdbNodeAugmentation = extractNodeAugmentation(ovsdbNode);
if (ovsdbNodeAugmentation != null) {
- List<ManagedNodeEntry> managedNodes = ovsdbNodeAugmentation.getManagedNodeEntry();
+ Map<ManagedNodeEntryKey, ManagedNodeEntry> managedNodes = ovsdbNodeAugmentation.getManagedNodeEntry();
if (managedNodes != null) {
- for (ManagedNodeEntry managedNode : managedNodes) {
+ for (ManagedNodeEntry managedNode : managedNodes.values()) {
if (matchesBridgeName(managedNode, bridgeName)) {
return true;
}
}
public boolean isOvsdbNodeDpdk(Node ovsdbNode) {
- boolean found = false;
OvsdbNodeAugmentation ovsdbNodeAugmentation = extractNodeAugmentation(ovsdbNode);
if (ovsdbNodeAugmentation != null) {
- List<InterfaceTypeEntry> ifTypes = ovsdbNodeAugmentation.getInterfaceTypeEntry();
+ Map<InterfaceTypeEntryKey, InterfaceTypeEntry> ifTypes = ovsdbNodeAugmentation.getInterfaceTypeEntry();
if (ifTypes != null) {
- for (InterfaceTypeEntry ifType : ifTypes) {
- if (ifType.getInterfaceType().equals(InterfaceTypeDpdk.class)) {
- found = true;
- break;
- }
+ if (ifTypes.containsKey(DPDK_IFACE_KEY)) {
+ return true;
}
}
}
- return found;
+ return false;
}
private static List<ControllerEntry> createControllerEntries(List<String> controllersStr,
LOG.error("extractTerminationPointAugmentations: Node value is null");
return Collections.emptyList();
}
- List<TerminationPoint> terminationPoints = node.getTerminationPoint();
+ Map<TerminationPointKey, TerminationPoint> terminationPoints = node.getTerminationPoint();
if (terminationPoints != null && !terminationPoints.isEmpty()) {
- for (TerminationPoint tp : terminationPoints) {
+ for (TerminationPoint tp : terminationPoints.values()) {
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
tp.augmentation(OvsdbTerminationPointAugmentation.class);
if (ovsdbTerminationPointAugmentation != null) {
* Get all OVSDB nodes from topology.
* @return a list of nodes or null if the topology could not found
*/
- public List<Node> getOvsdbNodes() {
+ public Map<NodeKey, Node> getOvsdbNodes() {
InstanceIdentifier<Topology> inst = InstanceIdentifier.create(NetworkTopology.class).child(Topology.class,
new TopologyKey(OVSDB_TOPOLOGY_ID));
Topology topology = provider.read(LogicalDatastoreType.OPERATIONAL, inst);
}
}
- if (ovsdbNode != null && ovsdbNode.getOpenvswitchOtherConfigs() != null) {
- for (OpenvswitchOtherConfigs openvswitchOtherConfigs : ovsdbNode.getOpenvswitchOtherConfigs()) {
- if (openvswitchOtherConfigs.getOtherConfigKey().equals(key)) {
- return openvswitchOtherConfigs.getOtherConfigValue();
- }
+ if (ovsdbNode != null) {
+ final OpenvswitchOtherConfigs found = ovsdbNode.nonnullOpenvswitchOtherConfigs()
+ .get(new OpenvswitchOtherConfigsKey(key));
+ if (found != null) {
+ return found.getOtherConfigValue();
}
}
}
public static TerminationPoint getTerminationPointByExternalId(final Node bridgeNode, final String interfaceName) {
- if (bridgeNode.getTerminationPoint() != null) {
- for (TerminationPoint tp : bridgeNode.getTerminationPoint()) {
+ final Map<TerminationPointKey, TerminationPoint> tps = bridgeNode.getTerminationPoint();
+ if (tps != null) {
+ for (TerminationPoint tp : tps.values()) {
OvsdbTerminationPointAugmentation ovsdbTp = tp.augmentation(OvsdbTerminationPointAugmentation.class);
String externalIdValue = getExternalInterfaceIdValue(ovsdbTp);
if (externalIdValue != null && externalIdValue.equals(interfaceName)) {
// This utility shouldn't be called often, as it reads all OVSDB nodes each time - not good for scale
public Node getNodeByTerminationPointExternalId(final String interfaceName) {
- List<Node> nodes = getOvsdbNodes();
+ Map<NodeKey, Node> nodes = getOvsdbNodes();
if (nodes != null) {
- for (Node node : nodes) {
+ for (Node node : nodes.values()) {
TerminationPoint tp = getTerminationPointByExternalId(node, interfaceName);
if (tp != null) {
return node;
public static String getExternalInterfaceIdValue(final OvsdbTerminationPointAugmentation ovsdbTp) {
if (ovsdbTp != null) {
- List<InterfaceExternalIds> ifaceExtIds = ovsdbTp.getInterfaceExternalIds();
+ Map<InterfaceExternalIdsKey, InterfaceExternalIds> ifaceExtIds = ovsdbTp.getInterfaceExternalIds();
if (ifaceExtIds != null) {
- for (InterfaceExternalIds entry : ifaceExtIds) {
- if (entry.getExternalIdKey().equals(EXTERNAL_INTERFACE_ID_KEY)) {
- return entry.getExternalIdValue();
- }
+ final InterfaceExternalIds entry = ifaceExtIds.get(EXTERNAL_INTERFACE_ID_KEY);
+ if (entry != null) {
+ return entry.getExternalIdValue();
}
}
}
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>yang-binding</artifactId>
+ </dependency>
</dependencies>
<build>
*/
package org.opendaylight.ovsdb.utils.yang;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.binding.Identifiable;
+import org.opendaylight.yangtools.yang.binding.Identifier;
/**
* YANG utility functions.
* @param <V> The value type.
* @return The map.
*/
- @NonNull
- public static <T, K, V> Map<K, V> copyYangKeyValueListToMap(@NonNull Map<K, V> map, @Nullable Iterable<T> yangList,
- @NonNull Function<T, K> keyExtractor,
- @NonNull Function<T, V> valueExtractor) {
+ public static <T, K, V> @NonNull Map<K, V> copyYangKeyValueListToMap(@NonNull Map<K, V> map,
+ @Nullable Iterable<T> yangList, @NonNull Function<T, K> keyExtractor,
+ @NonNull Function<T, V> valueExtractor) {
if (yangList != null) {
for (T yangValue : yangList) {
K key = keyExtractor.apply(yangValue);
V value = valueExtractor.apply(yangValue);
- Preconditions.checkNotNull(key);
- Preconditions.checkNotNull(value);
- map.put(key, value);
+ map.put(requireNonNull(key), requireNonNull(value));
}
}
return map;
}
+ /**
+ * Copies a list of YANG key-value items to the given map. Any {@code null} key or value will cause an error.
+ *
+ * @param map The map to fill.
+ * @param yangList The map of YANG key-value items.
+ * @param keyExtractor The key extractor function to use.
+ * @param valueExtractor The value extractor function to use.
+ * @param <T> The YANG item type.
+ * @param <K> The key type.
+ * @param <V> The value type.
+ * @return The map.
+ */
+ public static <I extends Identifier<T>, T extends Identifiable<I>, K, V>
+ @NonNull Map<K, V> copyYangKeyValueListToMap(@NonNull Map<K, V> map,
+ @Nullable Map<I, T> yangList, @NonNull Function<T, K> keyExtractor,
+ @NonNull Function<T, V> valueExtractor) {
+ if (yangList != null) {
+ return copyYangKeyValueListToMap(map, yangList.values(), keyExtractor, valueExtractor);
+ }
+ return map;
+ }
+
/**
* Converts a list of YANG key-value items to a map.
*
* @param <V> The value type.
* @return The map.
*/
- @NonNull
- public static <T, K, V> Map<K, V> convertYangKeyValueListToMap(@Nullable Iterable<T> yangList,
- @NonNull Function<T, K> keyExtractor,
- @NonNull Function<T, V> valueExtractor) {
+ public static <T, K, V> @NonNull Map<K, V> convertYangKeyValueListToMap(@Nullable Iterable<T> yangList,
+ @NonNull Function<T, K> keyExtractor, @NonNull Function<T, V> valueExtractor) {
+ return copyYangKeyValueListToMap(new HashMap<>(), yangList, keyExtractor, valueExtractor);
+ }
+
+ /**
+ * Converts a list of YANG key-value items to a map.
+ *
+ * @param yangList The map of YANG key-value items.
+ * @param keyExtractor The key extractor function to use.
+ * @param valueExtractor The value extractor function to use.
+ * @param <T> The YANG item type.
+ * @param <K> The key type.
+ * @param <V> The value type.
+ * @return The map.
+ */
+ public static <I extends Identifier<T>, T extends Identifiable<I>, K, V> @NonNull Map<K, V>
+ convertYangKeyValueListToMap(@Nullable Map<I, T> yangList,
+ @NonNull Function<T, K> keyExtractor, @NonNull Function<T, V> valueExtractor) {
return copyYangKeyValueListToMap(new HashMap<>(), yangList, keyExtractor, valueExtractor);
}
}
Code Review / ovsdb.git / commitdiff