<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>9.0.4</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
- <version>3.0.1</version>
+ <version>4.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>aaa-artifacts</artifactId>
- <version>0.15.5</version>
+ <version>0.16.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.controller</groupId>
<artifactId>mdsal-it-parent</artifactId>
- <version>5.0.5</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>9.0.4</version>
+ <version>10.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>9.0.4</version>
+ <version>10.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-hwvtepsouthbound-api-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-hwvtepsouthbound-api" version="${project.version}">
- <feature version="[9,10)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
- <feature version="[9,10)">odl-mdsal-model-odl-l2-types</feature>
+ <feature version="[10,11)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[10,11)">odl-mdsal-model-odl-l2-types</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>odl-restconf</artifactId>
- <version>3.0.5</version>
+ <version>4.0.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>odl-mdsal-apidocs</artifactId>
- <version>3.0.5</version>
+ <version>4.0.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.ovsdb</groupId>
<version>${project.version}</version>
</dependency>
<dependency>
- <groupId>javax.annotation</groupId>
- <artifactId>javax.annotation-api</artifactId>
+ <groupId>jakarta.annotation</groupId>
+ <artifactId>jakarta.annotation-api</artifactId>
<optional>true</optional>
</dependency>
<dependency>
long PORT_OPEN_MAX_DELAY_IN_MINS = 5;
String IID_OTHER_CONFIG_KEY = "opendaylight-iid";
String UUID = "uuid";
- ImmutableBiMap<Class<? extends EncapsulationTypeBase>,String> ENCAPS_TYPE_MAP
- = new ImmutableBiMap.Builder<Class<? extends EncapsulationTypeBase>,String>()
- .put(EncapsulationTypeVxlanOverIpv4.class,"vxlan_over_ipv4").build();
+ ImmutableBiMap<EncapsulationTypeBase, String> ENCAPS_TYPE_MAP =
+ ImmutableBiMap.<EncapsulationTypeBase, String>builder()
+ .put(EncapsulationTypeVxlanOverIpv4.VALUE,"vxlan_over_ipv4")
+ .build();
MacAddress UNKNOWN_DST_MAC = new MacAddress("00:00:00:00:00:00");
String UNKNOWN_DST_STRING = "unknown-dst";
String HWVTEP_URI_PREFIX = "hwvtep";
private HwvtepSouthboundMapper() {
}
- public static InstanceIdentifier<Node> createInstanceIdentifier(NodeId nodeId) {
+ public static InstanceIdentifier<Node> createInstanceIdentifier(final NodeId nodeId) {
return InstanceIdentifier
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID))
.child(Node.class,new NodeKey(nodeId));
}
- public static InstanceIdentifier<Node> createInstanceIdentifier(OvsdbClient client) {
+ public static InstanceIdentifier<Node> createInstanceIdentifier(final OvsdbClient client) {
return createInstanceIdentifier(createIpAddress(client.getConnectionInfo().getRemoteAddress()),
new PortNumber(Uint16.valueOf(client.getConnectionInfo().getRemotePort())));
}
- private static InstanceIdentifier<Node> createInstanceIdentifier(IpAddress ip, PortNumber port) {
+ private static InstanceIdentifier<Node> createInstanceIdentifier(final IpAddress ip, final PortNumber port) {
String uriString = HwvtepSouthboundConstants.HWVTEP_URI_PREFIX + "://"
+ ip.stringValue() + ":" + port.getValue();
Uri uri = new Uri(uriString);
return path;
}
- public static InstanceIdentifier<Node> createInstanceIdentifier(HwvtepConnectionInstance client,
- PhysicalSwitch physicalSwitch) {
+ public static InstanceIdentifier<Node> createInstanceIdentifier(final HwvtepConnectionInstance client,
+ final PhysicalSwitch physicalSwitch) {
//TODO: Clean this up
return createInstanceIdentifier(client, new HwvtepNodeName(physicalSwitch.getName()));
}
- public static InstanceIdentifier<Node> createInstanceIdentifier(HwvtepConnectionInstance client,
- HwvtepNodeName psName) {
+ public static InstanceIdentifier<Node> createInstanceIdentifier(final HwvtepConnectionInstance client,
+ final HwvtepNodeName psName) {
NodeKey nodeKey = new NodeKey(createManagedNodeId(client, psName));
return InstanceIdentifier.builder(NetworkTopology.class)
.child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID))
.child(Node.class, nodeKey).build();
}
- public static InstanceIdentifier<LogicalSwitches> createInstanceIdentifier(HwvtepConnectionInstance client,
- LogicalSwitch logicalSwitch) {
+ public static InstanceIdentifier<LogicalSwitches> createInstanceIdentifier(final HwvtepConnectionInstance client,
+ final LogicalSwitch logicalSwitch) {
InstanceIdentifier<LogicalSwitches> iid = null;
iid = InstanceIdentifier.builder(NetworkTopology.class)
.child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID))
.build();
}
- public static InstanceIdentifier<Tunnels> createInstanceIdentifier(InstanceIdentifier<Node> nodeIid,
- InstanceIdentifier<TerminationPoint> localTpIid, InstanceIdentifier<TerminationPoint> remoteTpIid) {
+ public static InstanceIdentifier<Tunnels> createInstanceIdentifier(final InstanceIdentifier<Node> nodeIid,
+ final InstanceIdentifier<TerminationPoint> localTpIid,
+ final InstanceIdentifier<TerminationPoint> remoteTpIid) {
TunnelsKey tunnelsKey = new TunnelsKey(new HwvtepPhysicalLocatorRef(localTpIid),
new HwvtepPhysicalLocatorRef(remoteTpIid));
return tunnelInstanceId;
}
- public static InstanceIdentifier<TerminationPoint> createInstanceIdentifier(InstanceIdentifier<Node> nodeIid,
- PhysicalLocator physicalLocator) {
+ public static InstanceIdentifier<TerminationPoint> createInstanceIdentifier(final InstanceIdentifier<Node> nodeIid,
+ final PhysicalLocator physicalLocator) {
return nodeIid.child(TerminationPoint.class, getTerminationPointKey(physicalLocator));
}
- public static InstanceIdentifier<VlanBindings> createInstanceIdentifier(HwvtepConnectionInstance client,
- InstanceIdentifier<TerminationPoint> tpPath, VlanBindings vlanBindings) {
+ public static InstanceIdentifier<VlanBindings> createInstanceIdentifier(final HwvtepConnectionInstance client,
+ final InstanceIdentifier<TerminationPoint> tpPath, final VlanBindings vlanBindings) {
return tpPath.augmentation(HwvtepPhysicalPortAugmentation.class).child(VlanBindings.class,
new VlanBindingsKey(vlanBindings.key()));
return path;
}
- public static NodeId createManagedNodeId(InstanceIdentifier<Node> iid) {
+ public static NodeId createManagedNodeId(final InstanceIdentifier<Node> iid) {
NodeKey nodeKey = iid.firstKeyOf(Node.class);
return nodeKey.getNodeId();
}
- public static NodeId createManagedNodeId(HwvtepConnectionInstance client, HwvtepNodeName psName) {
+ public static NodeId createManagedNodeId(final HwvtepConnectionInstance client, final HwvtepNodeName psName) {
String nodeString = client.getNodeKey().getNodeId().getValue()
+ "/" + HwvtepSouthboundConstants.PSWITCH_URI_PREFIX + "/" + psName.getValue();
NodeId nodeId = new NodeId(new Uri(nodeString));
return nodeId;
}
- public static IpAddress createIpAddress(InetAddress address) {
+ public static IpAddress createIpAddress(final InetAddress address) {
IpAddress ip = null;
if (address instanceof Inet4Address) {
ip = createIpAddress((Inet4Address)address);
return ip;
}
- public static IpAddress createIpAddress(Inet4Address address) {
+ public static IpAddress createIpAddress(final Inet4Address address) {
return IetfInetUtil.INSTANCE.ipAddressFor(address);
}
- public static IpAddress createIpAddress(Inet6Address address) {
+ public static IpAddress createIpAddress(final Inet6Address address) {
Ipv6Address ipv6 = new Ipv6Address(address.getHostAddress());
return new IpAddress(ipv6);
}
- public static ConnectionInfo createConnectionInfo(OvsdbClient client) {
+ public static ConnectionInfo createConnectionInfo(final OvsdbClient client) {
ConnectionInfoBuilder connectionInfoBuilder = new ConnectionInfoBuilder();
connectionInfoBuilder.setRemoteIp(createIpAddress(client.getConnectionInfo().getRemoteAddress()));
connectionInfoBuilder.setRemotePort(new PortNumber(Uint16.valueOf(client.getConnectionInfo().getRemotePort())));
return connectionInfoBuilder.build();
}
- public static ConnectionInfo suppressLocalIpPort(ConnectionInfo connectionInfo) {
+ public static ConnectionInfo suppressLocalIpPort(final ConnectionInfo connectionInfo) {
ConnectionInfoBuilder connectionInfoBuilder = new ConnectionInfoBuilder();
connectionInfoBuilder.setRemoteIp(connectionInfo.getRemoteIp());
connectionInfoBuilder.setRemotePort(connectionInfo.getRemotePort());
return connectionInfoBuilder.build();
}
- public static InetAddress createInetAddress(IpAddress ip) throws UnknownHostException {
+ public static InetAddress createInetAddress(final IpAddress ip) throws UnknownHostException {
if (ip.getIpv4Address() != null) {
return InetAddresses.forString(ip.getIpv4Address().getValue());
} else if (ip.getIpv6Address() != null) {
}
}
- public static InstanceIdentifier<Node> getInstanceIdentifier(Global global) {
+ public static InstanceIdentifier<Node> getInstanceIdentifier(final Global global) {
String nodeString = HwvtepSouthboundConstants.HWVTEP_URI_PREFIX + "://"
+ HwvtepSouthboundConstants.UUID + "/" + global.getUuid().toString();
NodeId nodeId = new NodeId(new Uri(nodeString));
.build();
}
- public static Class<? extends EncapsulationTypeBase> createEncapsulationType(String type) {
+ public static EncapsulationTypeBase createEncapsulationType(final String type) {
if (requireNonNull(type).isEmpty()) {
- return EncapsulationTypeVxlanOverIpv4.class;
+ return EncapsulationTypeVxlanOverIpv4.VALUE;
}
return HwvtepSouthboundConstants.ENCAPS_TYPE_MAP.inverse().get(type);
}
- public static TerminationPointKey getTerminationPointKey(PhysicalLocator physicalLocator) {
+ public static TerminationPointKey getTerminationPointKey(final PhysicalLocator physicalLocator) {
TerminationPointKey tpKey = null;
if (physicalLocator.getEncapsulationTypeColumn().getData() != null
&& physicalLocator.getDstIpColumn().getData() != null) {
return transaction.read(logicalDatastoreType, connectionIid).get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Read failed from datastore for Node : {}",connectionIid,e);
- throw new RuntimeException(e);
+ throw new IllegalStateException(e);
}
}
return transaction.read(logicalDatastoreType, connectionIid).get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Read failed from datastore for Node : {}",connectionIid,e);
- throw new RuntimeException(e);
+ throw new IllegalStateException(e);
}
}
return transaction.read(logicalDatastoreType, connectionIid).get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Read failed from datastore for Node : {}",connectionIid,e);
- throw new RuntimeException(e);
+ throw new IllegalStateException(e);
}
}
public HwvtepOperationalState(final DataBroker db, final HwvtepConnectionInstance connectionInstance,
final Collection<DataTreeModification<Node>> changes) {
this.connectionInstance = connectionInstance;
- this.deviceInfo = connectionInstance.getDeviceInfo();
+ deviceInfo = connectionInstance.getDeviceInfo();
this.db = db;
this.changes = changes;
- this.transaction = db.newReadWriteTransaction();
+ transaction = db.newReadWriteTransaction();
}
public HwvtepOperationalState(final HwvtepConnectionInstance connectionInstance) {
this.connectionInstance = connectionInstance;
- this.deviceInfo = connectionInstance.getDeviceInfo();
- this.db = connectionInstance.getDataBroker();
- this.changes = null;
+ deviceInfo = connectionInstance.getDeviceInfo();
+ db = connectionInstance.getDataBroker();
+ changes = null;
transaction = connectionInstance.getDataBroker().newReadWriteTransaction();
Optional<Node> readNode = new MdsalUtils(db).readOptional(LogicalDatastoreType.OPERATIONAL,
connectionInstance.getInstanceIdentifier());
}
public Optional<HwvtepPhysicalLocatorAugmentation> getPhysicalLocatorAugmentation(final InstanceIdentifier<?> iid,
- final IpAddress dstIp, final Class<? extends EncapsulationTypeBase> encapType) {
+ final IpAddress dstIp, final EncapsulationTypeBase encapType) {
Optional<Map<TerminationPointKey, TerminationPoint>> nodeOptional =
getTerminationPointList(requireNonNull(iid));
if (nodeOptional.isPresent()) {
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import com.google.common.collect.Lists;
import java.util.Collection;
-import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalLocatorSet;
import org.opendaylight.ovsdb.utils.mdsal.utils.MdsalUtils;
import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionType;
-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.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.EncapsulationTypeVxlanOverIpv4;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepNodeName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentation;
}
HwvtepPhysicalLocatorAugmentationBuilder builder = new HwvtepPhysicalLocatorAugmentationBuilder();
HwvtepPhysicalLocatorAugmentation locatorAugmentation = null;
- builder.setEncapsulationType(EncapsulationTypeVxlanOverIpv4.class);
+ builder.setEncapsulationType(EncapsulationTypeVxlanOverIpv4.VALUE);
String tepKey = iid.firstKeyOf(TerminationPoint.class).getTpId().getValue();
String ip = tepKey.substring(tepKey.indexOf(":") + 1);
- builder.setDstIp(IpAddressBuilder.getDefaultInstance(ip));
+ builder.setDstIp(parseIpAddress(ip));
locatorAugmentation = builder.build();
locatorUuid = TransactUtils.createPhysicalLocator(transaction, locatorAugmentation, operationalState);
operationalState.updateCurrentTxData(TerminationPoint.class, iid, locatorUuid);
return new UUID(locatorUuid);
}
+ public static IpAddress parseIpAddress(final String ipAddress) {
+ try {
+ return new IpAddress(new Ipv4Address(ipAddress));
+ } catch (IllegalArgumentException e) {
+ LOG.debug("Failed to interpret {} as an Ipv4Address", ipAddress, e);
+ }
+ return new IpAddress(new Ipv6Address(ipAddress));
+ }
+
private static void setEncapsulationType(final PhysicalLocator physicalLocator,
final HwvtepPhysicalLocatorAugmentation inputLocator) {
if (inputLocator.getEncapsulationType() != null) {
static String sanitizeUUID(final String nodeName) {
//ovs is not accepting '-' in the named uuids
- return nodeName.replaceAll("-", "_");
+ return nodeName.replace('-', '_');
}
public static String getLogicalSwitchId(final LogicalSwitches lswitch) {
}
return null;
}
- LogicalSwitchUpdateCommand cmd = new LogicalSwitchUpdateCommand(operationalState, Collections.emptyList());
+ LogicalSwitchUpdateCommand cmd = new LogicalSwitchUpdateCommand(operationalState, List.of());
MdsalUtils mdsalUtils = new MdsalUtils(operationalState.getDataBroker());
LogicalSwitches ls = mdsalUtils.read(LogicalDatastoreType.CONFIGURATION, lswitchIid);
if (ls != null) {
- cmd.updateLogicalSwitch(transaction, lswitchIid.firstIdentifierOf(Node.class), Lists.newArrayList(ls));
+ cmd.updateLogicalSwitch(transaction, lswitchIid.firstIdentifierOf(Node.class), List.of(ls));
} else {
LOG.error("Could not find logical switch in config ds {}", lswitchIid);
return null;
TerminationPoint.class, iid);
if (deviceData != null) {
Object data = deviceData.getData();
- if (data instanceof PhysicalLocator) {
- PhysicalLocator locator = (PhysicalLocator) data;
+ if (data instanceof PhysicalLocator locator) {
locatorsInfo.add(new StringBuilder(locator.getUuid().toString()).append(" ")
.append(locator.getDstIpColumn().getData()).toString());
} else {
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
+import org.opendaylight.ovsdb.hwvtepsouthbound.transact.TransactUtils;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.schema.hardwarevtep.McastMacsLocal;
import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalLocator;
import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalLocatorSet;
-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.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;
private static void setIpAddress(LocalMcastMacsBuilder macLocalBuilder, McastMacsLocal macLocal) {
if (macLocal.getIpAddr() != null && !macLocal.getIpAddr().isEmpty()) {
- macLocalBuilder.setIpaddr(IpAddressBuilder.getDefaultInstance(macLocal.getIpAddr()));
+ macLocalBuilder.setIpaddr(TransactUtils.parseIpAddress(macLocal.getIpAddr()));
}
}
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
+import org.opendaylight.ovsdb.hwvtepsouthbound.transact.TransactUtils;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.schema.hardwarevtep.McastMacsRemote;
import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalLocator;
import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalLocatorSet;
-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.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;
private static void setIpAddress(RemoteMcastMacsBuilder macRemoteBuilder, McastMacsRemote macRemote) {
if (macRemote.getIpAddr() != null && !macRemote.getIpAddr().isEmpty()) {
- macRemoteBuilder.setIpaddr(IpAddressBuilder.getDefaultInstance(macRemote.getIpAddr()));
+ macRemoteBuilder.setIpaddr(TransactUtils.parseIpAddress(macRemote.getIpAddr()));
}
}
* 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.Map;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
+import org.opendaylight.ovsdb.hwvtepsouthbound.transact.TransactUtils;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalLocator;
-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.HwvtepPhysicalLocatorAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
private static void setDstIp(HwvtepPhysicalLocatorAugmentationBuilder tpAugmentationBuilder,
PhysicalLocator locator) {
- tpAugmentationBuilder.setDstIp(IpAddressBuilder.getDefaultInstance(locator.getDstIpColumn().getData()));
+ tpAugmentationBuilder.setDstIp(TransactUtils.parseIpAddress(locator.getDstIpColumn().getData()));
}
}
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
+import org.opendaylight.ovsdb.hwvtepsouthbound.transact.TransactUtils;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.schema.hardwarevtep.Tunnel;
import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionType;
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.HwvtepGlobalAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalRef;
private static InstanceIdentifier<TunnelIps> getTunnelIpIid(final String tunnelIp,
final InstanceIdentifier<Node> psIid) {
- IpAddress ip = IpAddressBuilder.getDefaultInstance(tunnelIp);
+ IpAddress ip = TransactUtils.parseIpAddress(tunnelIp);
TunnelIps tunnelIps = new TunnelIpsBuilder().withKey(new TunnelIpsKey(ip)).setTunnelIpsKey(ip).build();
return psIid.augmentation(PhysicalSwitchAugmentation.class).child(TunnelIps.class, tunnelIps.key());
}
transaction.delete(LogicalDatastoreType.OPERATIONAL, tunnelIpsInstanceIdentifier);
}
for (String tunnelIp : addedTunnelIps) {
- IpAddress ip = IpAddressBuilder.getDefaultInstance(tunnelIp);
+ IpAddress ip = TransactUtils.parseIpAddress(tunnelIp);
InstanceIdentifier<TunnelIps> tunnelIpsInstanceIdentifier = getTunnelIpIid(tunnelIp, psIid);
TunnelIps tunnelIps = new TunnelIpsBuilder().withKey(new TunnelIpsKey(ip)).setTunnelIpsKey(ip).build();
transaction.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, tunnelIpsInstanceIdentifier,
&& !phySwitch.getManagementIpsColumn().getData().isEmpty()) {
var mgmtIps = phySwitch.getManagementIpsColumn().getData().stream()
.map(ip -> new ManagementIpsBuilder()
- .setManagementIpsKey(IpAddressBuilder.getDefaultInstance(ip))
+ .setManagementIpsKey(TransactUtils.parseIpAddress(ip))
.build())
.collect(BindingMap.toMap());
psAugmentationBuilder.setManagementIps(mgmtIps);
* 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.Collection;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
+import org.opendaylight.ovsdb.hwvtepsouthbound.transact.TransactUtils;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalLocator;
import org.opendaylight.ovsdb.schema.hardwarevtep.UcastMacsLocal;
import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionType;
-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.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;
InstanceIdentifier<Node> nodeIid = getOvsdbConnectionInstance().getInstanceIdentifier();
LocalUcastMacsBuilder ucmlBuilder = new LocalUcastMacsBuilder();
if (ucml.getIpAddr() != null && !ucml.getIpAddr().isEmpty()) {
- ucmlBuilder.setIpaddr(IpAddressBuilder.getDefaultInstance(ucml.getIpAddr()));
+ ucmlBuilder.setIpaddr(TransactUtils.parseIpAddress(ucml.getIpAddr()));
}
ucmlBuilder.setMacEntryKey(new MacAddress(ucml.getMac()));
ucmlBuilder.setMacEntryUuid(new Uuid(ucml.getUuid().toString()));
* 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.Collection;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
+import org.opendaylight.ovsdb.hwvtepsouthbound.transact.TransactUtils;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.schema.hardwarevtep.LogicalSwitch;
import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalLocator;
import org.opendaylight.ovsdb.schema.hardwarevtep.UcastMacsRemote;
-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.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;
rumBuilder.setMacEntryKey(new MacAddress(macRemote.getMac()));
rumBuilder.setMacEntryUuid(new Uuid(macRemote.getUuid().toString()));
if (macRemote.getIpAddr() != null && !macRemote.getIpAddr().isEmpty()) {
- rumBuilder.setIpaddr(IpAddressBuilder.getDefaultInstance(macRemote.getIpAddr()));
+ rumBuilder.setIpaddr(TransactUtils.parseIpAddress(macRemote.getIpAddr()));
}
if (macRemote.getLocatorColumn() != null
&& macRemote.getLocatorColumn().getData() != null) {
import java.util.List;
import java.util.Map;
import java.util.UUID;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
+import org.opendaylight.ovsdb.hwvtepsouthbound.transact.TransactUtils;
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;
public static RemoteUcastMacs buildRemoteUcastMacs(InstanceIdentifier<Node> nodeIid, String vmMac,
String vmip, String tepIp, String logicalSwitchName) {
RemoteUcastMacsBuilder ucmlBuilder = new RemoteUcastMacsBuilder();
- ucmlBuilder.setIpaddr(IpAddressBuilder.getDefaultInstance(vmip));
+ ucmlBuilder.setIpaddr(TransactUtils.parseIpAddress(vmip));
ucmlBuilder.setMacEntryKey(new MacAddress(vmMac));
ucmlBuilder.setMacEntryUuid(getUUid(vmMac));
ucmlBuilder.setLocatorRef(buildLocatorRef(nodeIid, tepIp));
tpBuilder.addAugmentation(new HwvtepPhysicalLocatorAugmentationBuilder()
.setPhysicalLocatorUuid(getUUid(ip))
.setEncapsulationType(HwvtepSouthboundMapper.createEncapsulationType(VXLAN_OVER_IPV4))
- .setDstIp(IpAddressBuilder.getDefaultInstance(ip))
+ .setDstIp(TransactUtils.parseIpAddress(ip))
.build());
}
return tpBuilder.build();
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>odl-aaa-cert</artifactId>
- <version>0.15.5</version>
+ <version>0.16.0</version>
<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="[10,11)">odl-jackson-2.13</feature>
- <feature version="[10,11)">odl-netty-4</feature>
- <feature version="[0.15,1)">odl-aaa-cert</feature>
+ <feature version="[11,12)">odl-jackson-2.13</feature>
+ <feature version="[11,12)">odl-netty-4</feature>
+ <feature version="[0.16,1)">odl-aaa-cert</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>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.ovsdb</groupId>
<optional>true</optional>
</dependency>
<dependency>
- <groupId>javax.annotation</groupId>
- <artifactId>javax.annotation-api</artifactId>
+ <groupId>jakarta.annotation</groupId>
+ <artifactId>jakarta.annotation-api</artifactId>
<optional>true</optional>
</dependency>
private static final ObjectWriter PRETTY_WRITER = new ObjectMapper().writerWithDefaultPrettyPrinter();
private JsonUtils() {
+ // Hidden on purpose
}
public static String prettyString(final Object jsonNode) {
try {
return PRETTY_WRITER.writeValueAsString(jsonNode);
} catch (JsonProcessingException e) {
- throw new RuntimeException(e);
+ throw new IllegalStateException(e);
}
}
}
return instance.newInstance(this);
} catch (InstantiationException | IllegalAccessException
| InvocationTargetException | NoSuchMethodException e) {
- throw new RuntimeException("exception constructing instance of clazz " + clazz, e);
+ throw new IllegalStateException("exception constructing instance of clazz " + clazz, e);
}
}
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import com.google.common.collect.Range;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.lang.reflect.Method;
import java.util.Locale;
import org.eclipse.jdt.annotation.NonNull;
}
abstract static class FailedInvoker extends Invoker {
+ @SuppressFBWarnings(value = "THROWS_METHOD_THROWS_RUNTIMEEXCEPTION", justification = "Polymorphic throw")
@Override
final Object invokeMethod(final Row<GenericTableSchema> row, final Object proxy, final Object[] args) {
throw newException();
builder.put(method, prototype);
}
}
- this.prototypes = builder.build();
+ prototypes = builder.build();
}
static MethodDispatch forTarget(final Class<?> target) {
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<module>southbound</module>
<module>utils</module>
</modules>
+
+ <build>
+ <pluginManagement>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ <!-- https://issues.apache.org/jira/browse/MJAVADOC-649 -->
+ <version>3.1.1</version>
+ </plugin>
+ </plugins>
+ </pluginManagement>
+ </build>
</project>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>9.0.4</version>
+ <version>10.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-southbound-api-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-southbound-api" version="${project.version}">
- <feature version="[9,10)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
- <feature version="[9,10)">odl-mdsal-model-odl-l2-types</feature>
+ <feature version="[10,11)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[10,11)">odl-mdsal-model-odl-l2-types</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>odl-restconf</artifactId>
- <version>3.0.5</version>
+ <version>4.0.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>odl-mdsal-apidocs</artifactId>
- <version>3.0.5</version>
+ <version>4.0.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
- <version>3.0.1</version>
+ <version>4.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<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="[10,11)">odl-jackson-2.13</feature>
- <feature version="[3,4)">odl-infrautils-diagstatus</feature>
- <feature version="[3,4)">odl-infrautils-ready</feature>
+ <feature version="[11,12)">odl-jackson-2.13</feature>
+ <feature version="[4,5)">odl-infrautils-diagstatus</feature>
+ <feature version="[4,5)">odl-infrautils-ready</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>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<optional>true</optional>
</dependency>
<dependency>
- <groupId>javax.annotation</groupId>
- <artifactId>javax.annotation-api</artifactId>
+ <groupId>jakarta.annotation</groupId>
+ <artifactId>jakarta.annotation-api</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.sonarsource.java</groupId>
<artifactId>sonar-jacoco-listeners</artifactId>
- <version>${sonar-jacoco-listeners.version}</version>
<scope>test</scope>
</dependency>
<dependency>
public static final String CREATED_BY = "created_by";
public static final String ODL = "odl";
- public static final ImmutableBiMap<Class<? extends OvsdbBridgeProtocolBase>, String> OVSDB_PROTOCOL_MAP =
- ImmutableBiMap.<Class<? extends OvsdbBridgeProtocolBase>, String>builder()
- .put(OvsdbBridgeProtocolOpenflow10.class, "OpenFlow10")
- .put(OvsdbBridgeProtocolOpenflow11.class, "OpenFlow11")
- .put(OvsdbBridgeProtocolOpenflow12.class, "OpenFlow12")
- .put(OvsdbBridgeProtocolOpenflow13.class, "OpenFlow13")
- .put(OvsdbBridgeProtocolOpenflow14.class, "OpenFlow14")
- .put(OvsdbBridgeProtocolOpenflow15.class, "OpenFlow15")
+ public static final ImmutableBiMap<OvsdbBridgeProtocolBase, String> OVSDB_PROTOCOL_MAP =
+ ImmutableBiMap.<OvsdbBridgeProtocolBase, String>builder()
+ .put(OvsdbBridgeProtocolOpenflow10.VALUE, "OpenFlow10")
+ .put(OvsdbBridgeProtocolOpenflow11.VALUE, "OpenFlow11")
+ .put(OvsdbBridgeProtocolOpenflow12.VALUE, "OpenFlow12")
+ .put(OvsdbBridgeProtocolOpenflow13.VALUE, "OpenFlow13")
+ .put(OvsdbBridgeProtocolOpenflow14.VALUE, "OpenFlow14")
+ .put(OvsdbBridgeProtocolOpenflow15.VALUE, "OpenFlow15")
.build();
- public static final ImmutableBiMap<Class<? extends OvsdbFailModeBase>, String> OVSDB_FAIL_MODE_MAP =
- ImmutableBiMap.of(
- OvsdbFailModeStandalone.class, "standalone",
- OvsdbFailModeSecure.class, "secure");
+ public static final ImmutableBiMap<OvsdbFailModeBase, String> OVSDB_FAIL_MODE_MAP = ImmutableBiMap.of(
+ OvsdbFailModeStandalone.VALUE, "standalone",
+ OvsdbFailModeSecure.VALUE, "secure");
public static final String IID_EXTERNAL_ID_KEY = "opendaylight-iid";
public static final String QOS_ID_EXTERNAL_ID_KEY = "opendaylight-qos-id";
private static final String N_CONNECTIONS_STR = "n_connections";
@VisibleForTesting
- public static final ImmutableBiMap<Class<? extends DatapathTypeBase>, String> DATAPATH_TYPE_MAP =
- ImmutableBiMap.of(
- DatapathTypeSystem.class, "system",
- DatapathTypeNetdev.class, "netdev");
+ public static final ImmutableBiMap<DatapathTypeBase, String> DATAPATH_TYPE_MAP = ImmutableBiMap.of(
+ DatapathTypeSystem.VALUE, "system",
+ DatapathTypeNetdev.VALUE, "netdev");
@VisibleForTesting
- public static final ImmutableBiMap<String, Class<? extends InterfaceTypeBase>> OVSDB_INTERFACE_TYPE_MAP =
- ImmutableBiMap.<String, Class<? extends InterfaceTypeBase>>builder()
- .put("internal", InterfaceTypeInternal.class)
- .put("vxlan", InterfaceTypeVxlan.class)
- .put("vxlan-gpe", InterfaceTypeVxlanGpe.class)
- .put("patch", InterfaceTypePatch.class)
- .put("system", InterfaceTypeSystem.class)
- .put("tap", InterfaceTypeTap.class)
- .put("geneve", InterfaceTypeGeneve.class)
- .put("gre", InterfaceTypeGre.class)
- .put("ipsec_gre", InterfaceTypeIpsecGre.class)
- .put("gre64", InterfaceTypeGre64.class)
- .put("ipsec_gre64", InterfaceTypeIpsecGre64.class)
- .put("lisp", InterfaceTypeLisp.class)
- .put("dpdk", InterfaceTypeDpdk.class)
- .put("dpdkr", InterfaceTypeDpdkr.class)
- .put("dpdkvhost", InterfaceTypeDpdkvhost.class)
- .put("dpdkvhostuser", InterfaceTypeDpdkvhostuser.class)
- .put("dpdkvhostuserclient", InterfaceTypeDpdkvhostuserclient.class)
- .put("stt", InterfaceTypeStt.class)
+ public static final ImmutableBiMap<String, InterfaceTypeBase> OVSDB_INTERFACE_TYPE_MAP =
+ ImmutableBiMap.<String, InterfaceTypeBase>builder()
+ .put("internal", InterfaceTypeInternal.VALUE)
+ .put("vxlan", InterfaceTypeVxlan.VALUE)
+ .put("vxlan-gpe", InterfaceTypeVxlanGpe.VALUE)
+ .put("patch", InterfaceTypePatch.VALUE)
+ .put("system", InterfaceTypeSystem.VALUE)
+ .put("tap", InterfaceTypeTap.VALUE)
+ .put("geneve", InterfaceTypeGeneve.VALUE)
+ .put("gre", InterfaceTypeGre.VALUE)
+ .put("ipsec_gre", InterfaceTypeIpsecGre.VALUE)
+ .put("gre64", InterfaceTypeGre64.VALUE)
+ .put("ipsec_gre64", InterfaceTypeIpsecGre64.VALUE)
+ .put("lisp", InterfaceTypeLisp.VALUE)
+ .put("dpdk", InterfaceTypeDpdk.VALUE)
+ .put("dpdkr", InterfaceTypeDpdkr.VALUE)
+ .put("dpdkvhost", InterfaceTypeDpdkvhost.VALUE)
+ .put("dpdkvhostuser", InterfaceTypeDpdkvhostuser.VALUE)
+ .put("dpdkvhostuserclient", InterfaceTypeDpdkvhostuserclient.VALUE)
+ .put("stt", InterfaceTypeStt.VALUE)
.build();
- private static final ImmutableBiMap<Class<? extends QosTypeBase>, String> QOS_TYPE_MAP =
- ImmutableBiMap.<Class<? extends QosTypeBase>, String>builder()
- .put(QosTypeLinuxHtb.class, SouthboundConstants.QOS_LINUX_HTB)
- .put(QosTypeLinuxHfsc.class, SouthboundConstants.QOS_LINUX_HFSC)
- .put(QosTypeLinuxSfq.class, SouthboundConstants.QOS_LINUX_SFQ)
- .put(QosTypeLinuxCodel.class, SouthboundConstants.QOS_LINUX_CODEL)
- .put(QosTypeLinuxFqCodel.class, SouthboundConstants.QOS_LINUX_FQ_CODEL)
- .put(QosTypeEgressPolicer.class, SouthboundConstants.QOS_EGRESS_POLICER)
+ private static final ImmutableBiMap<QosTypeBase, String> QOS_TYPE_MAP =
+ ImmutableBiMap.<QosTypeBase, String>builder()
+ .put(QosTypeLinuxHtb.VALUE, SouthboundConstants.QOS_LINUX_HTB)
+ .put(QosTypeLinuxHfsc.VALUE, SouthboundConstants.QOS_LINUX_HFSC)
+ .put(QosTypeLinuxSfq.VALUE, SouthboundConstants.QOS_LINUX_SFQ)
+ .put(QosTypeLinuxCodel.VALUE, SouthboundConstants.QOS_LINUX_CODEL)
+ .put(QosTypeLinuxFqCodel.VALUE, SouthboundConstants.QOS_LINUX_FQ_CODEL)
+ .put(QosTypeEgressPolicer.VALUE, SouthboundConstants.QOS_EGRESS_POLICER)
.build();
private SouthboundMapper() {
-
+ // Hidden on purpose
}
public static IpAddress createIpAddress(final InetAddress address) {
}
public static String createDatapathType(final OvsdbBridgeAugmentation mdsalbridge) {
- String datapathtype = DATAPATH_TYPE_MAP.get(DatapathTypeSystem.class);
+ String datapathtype = DATAPATH_TYPE_MAP.get(DatapathTypeSystem.VALUE);
- if (mdsalbridge.getDatapathType() != null && !mdsalbridge.getDatapathType().equals(DatapathTypeBase.class)) {
+ if (mdsalbridge.getDatapathType() != null && !mdsalbridge.getDatapathType().equals(DatapathTypeBase.VALUE)) {
datapathtype = DATAPATH_TYPE_MAP.get(mdsalbridge.getDatapathType());
if (datapathtype == null) {
- throw new IllegalArgumentException("Unknown datapath type " + mdsalbridge.getDatapathType().getName());
+ throw new IllegalArgumentException("Unknown datapath type " + mdsalbridge.getDatapathType());
}
}
return datapathtype;
}
- public static Class<? extends DatapathTypeBase> createDatapathType(final String type) {
+ public static DatapathTypeBase createDatapathType(final String type) {
if (type.isEmpty()) {
- return DatapathTypeSystem.class;
+ return DatapathTypeSystem.VALUE;
}
return DATAPATH_TYPE_MAP.inverse().get(type);
}
Map<ProtocolEntryKey, ProtocolEntry> entries = ovsdbBridgeNode.getProtocolEntry();
if (entries != null) {
for (ProtocolEntry protocol : entries.values()) {
- Class<? extends OvsdbBridgeProtocolBase> lookup = protocol.getProtocol();
+ final 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;
}
- public static Class<? extends InterfaceTypeBase> createInterfaceType(final String type) {
+ public static InterfaceTypeBase createInterfaceType(final String type) {
return OVSDB_INTERFACE_TYPE_MAP.get(requireNonNull(type));
}
- public static String createOvsdbInterfaceType(final Class<? extends InterfaceTypeBase> mdsaltype) {
+ public static String createOvsdbInterfaceType(final InterfaceTypeBase mdsaltype) {
return OVSDB_INTERFACE_TYPE_MAP.inverse().get(requireNonNull(mdsaltype));
}
}
List<ProtocolEntry> protocolList = new ArrayList<>();
if (protocols != null && !protocols.isEmpty()) {
- ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
- SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
+ ImmutableBiMap<String, OvsdbBridgeProtocolBase> mapper = SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
for (String protocol : protocols) {
if (protocol != null) {
- final Class<? extends OvsdbBridgeProtocolBase> mapped = mapper.get(protocol);
+ final OvsdbBridgeProtocolBase mapped = mapper.get(protocol);
if (mapped != null) {
protocolList.add(new ProtocolEntryBuilder().setProtocol(mapped).build());
}
* @param type the QoS type to match {@link String}
* @return class matching the input QoS type {@link QosTypeBase}
*/
- public static Class<? extends QosTypeBase> createQosType(final String type) {
+ public static QosTypeBase createQosType(final String type) {
requireNonNull(type);
if (type.isEmpty()) {
LOG.info("QoS type not supplied");
- return QosTypeBase.class;
+ return QosTypeBase.VALUE;
+ }
+
+ ImmutableBiMap<String, QosTypeBase> mapper = QOS_TYPE_MAP.inverse();
+ if (mapper.get(type) == null) {
+ LOG.info("QoS type not found in model: {}", type);
+ return QosTypeBase.VALUE;
} else {
- ImmutableBiMap<String, Class<? extends QosTypeBase>> mapper = QOS_TYPE_MAP.inverse();
- if (mapper.get(type) == null) {
- LOG.info("QoS type not found in model: {}", type);
- return QosTypeBase.class;
- } else {
- return mapper.get(type);
- }
+ return mapper.get(type);
}
}
- public static String createQosType(final Class<? extends QosTypeBase> qosTypeClass) {
- String qosType = QOS_TYPE_MAP.get(QosTypeBase.class);
+ public static String createQosType(final QosTypeBase qosTypeClass) {
+ String qosType = QOS_TYPE_MAP.get(QosTypeBase.VALUE);
- if (qosTypeClass != null && !qosTypeClass.equals(QosTypeBase.class)) {
+ if (qosTypeClass != null && !qosTypeClass.equals(QosTypeBase.VALUE)) {
qosType = QOS_TYPE_MAP.get(qosTypeClass);
if (qosType == null) {
- throw new IllegalArgumentException("Unknown QoS type" + qosTypeClass.getName());
+ throw new IllegalArgumentException("Unknown QoS type" + qosTypeClass);
}
}
return qosType;
// Note: erasure makes this safe in combination with the typecheck below
InstanceIdentifier<Node> path = (InstanceIdentifier<Node>) ref.getValue();
- FluentFuture<Optional<Node>> nf = transaction.read(
- LogicalDatastoreType.OPERATIONAL, path);
+ FluentFuture<Optional<Node>> nf = transaction.read(LogicalDatastoreType.OPERATIONAL, path);
transaction.close();
Optional<Node> optional = nf.get();
if (optional != null && optional.isPresent()) {
}
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Read Operational/DS for Node failed! {}", connectionIid, e);
- throw new RuntimeException(e);
+ throw new IllegalStateException(e);
}
return node;
}
}
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Read Operational/DS for Node failed! {}", connectionIid, e);
- throw new RuntimeException(e);
+ throw new IllegalStateException(e);
}
return node;
}
String interfaceNamedUuid = "Interface_" + SouthboundMapper.getRandomUuid();
Interface interfaceOvs = transaction.getTypedRowWrapper(Interface.class);
interfaceOvs.setName(ovsdbManagedNode.getBridgeName().getValue());
- interfaceOvs.setType(SouthboundMapper.createOvsdbInterfaceType(InterfaceTypeInternal.class));
+ interfaceOvs.setType(SouthboundMapper.createOvsdbInterfaceType(InterfaceTypeInternal.VALUE));
Insert<GenericTableSchema> result = op.insert(interfaceOvs).withId(interfaceNamedUuid);
transaction.add(result);
return result;
private static void createInterfaceType(final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
- Class<? extends InterfaceTypeBase> mdsaltype = terminationPoint.getInterfaceType();
+ InterfaceTypeBase mdsaltype = terminationPoint.getInterfaceType();
if (mdsaltype != null) {
ovsInterface.setType(SouthboundMapper.createOvsdbInterfaceType(mdsaltype));
}
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.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.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
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.DatapathId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
for (String protocol : oldBridge.getProtocolsColumn().getData()) {
if (bridge.getProtocolsColumn() == null || !bridge.getProtocolsColumn().getData()
.contains(protocol)) {
- Class<? extends OvsdbBridgeProtocolBase> proto = SouthboundConstants.OVSDB_PROTOCOL_MAP
- .inverse().get(protocol);
+ OvsdbBridgeProtocolBase proto = SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse().get(protocol);
InstanceIdentifier<ProtocolEntry> iid = bridgeIid
.augmentation(OvsdbBridgeAugmentation.class)
- .child(ProtocolEntry.class,
- new ProtocolEntryKey(proto));
+ .child(ProtocolEntry.class, new ProtocolEntryKey(proto));
result.add(iid);
}
}
IpAddress bridgeControllerIpAddress = null;
for (String targetElement : controllerTarget) {
if (InetAddresses.isInetAddress(targetElement)) {
- bridgeControllerIpAddress = IpAddressBuilder.getDefaultInstance(targetElement);
+ bridgeControllerIpAddress = parseIpAddress(targetElement);
continue;
}
if (NumberUtils.isCreatable(targetElement)) {
}
}
+ private static IpAddress parseIpAddress(final String ipAddress) {
+ try {
+ return new IpAddress(new Ipv4Address(ipAddress));
+ } catch (IllegalArgumentException e) {
+ LOG.debug("Failed to interpret {} as an Ipv4Address", ipAddress, e);
+ }
+ return new IpAddress(new Ipv6Address(ipAddress));
+ }
+
private InstanceIdentifier<Node> getInstanceIdentifier(Bridge bridge) {
return SouthboundMapper.createInstanceIdentifier(instanceIdentifierCodec, getOvsdbConnectionInstance(),
bridge);
import com.google.common.collect.ImmutableSet;
import java.util.Collections;
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
private DOMSchemaService schemaService;
@Before
- public void setUp() throws IllegalArgumentException, IllegalAccessException {
+ public void setUp() throws IllegalAccessException {
when(context.getQName()).thenReturn(SchemaContext.NAME);
dataSchemaContextTree = DataSchemaContextTree.from(context);
}
@Test
+ @Ignore("Mocking of sealed interfaces. This needs proper test data.")
public void testSerialize() {
InstanceIdentifier<?> iid = mock(InstanceIdentifier.class);
YangInstanceIdentifier yiid = mock(YangInstanceIdentifier.class);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.southbound;
import static org.junit.Assert.assertEquals;
import java.util.Set;
import org.junit.Test;
import org.mockito.Mockito;
-import org.mockito.stubbing.Answer;
import org.opendaylight.ovsdb.lib.OvsdbClient;
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.schema.openvswitch.Manager;
import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
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.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
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.DatapathId;
-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.DatapathTypeSystem;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
@Test
public void testCreateIpAddress() throws Exception {
- IpAddress ipAddress = IpAddressBuilder.getDefaultInstance("127.0.0.1");
+ IpAddress ipAddress = new IpAddress(new Ipv4Address("127.0.0.1"));
InetAddress inetAddress = InetAddress.getByAddress(new byte[] {127, 0, 0, 1});
assertEquals("Incorrect IP address created", ipAddress, SouthboundMapper.createIpAddress(inetAddress));
}
@Test
public void testCreateInetAddress() throws Exception {
// IPv4 address
- IpAddress ipV4Address = IpAddressBuilder.getDefaultInstance("99.99.99.99");
+ IpAddress ipV4Address = new IpAddress(new Ipv4Address("99.99.99.99"));
assertEquals("Incorrect InetAddress received", InetAddress.getByAddress(new byte[] {99, 99, 99, 99}),
SouthboundMapper.createInetAddress(ipV4Address));
// IPv6 address
- IpAddress ipV6Address = IpAddressBuilder.getDefaultInstance("0000:0000:0000:0000:0000:9999:FE1E:8329");
+ IpAddress ipV6Address = new IpAddress(new Ipv6Address("0000:0000:0000:0000:0000:9999:FE1E:8329"));
assertEquals("Incorrect InetAddress received", InetAddress.getByAddress(
new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (byte) 0x99, (byte) 0x99, (byte) 0xFE, 0x1E, (byte) 0x83,
0x29 }),
@Test
public void testCreateDatapathType() throws Exception {
OvsdbBridgeAugmentation mdsalbridge = mock(OvsdbBridgeAugmentation.class);
- when(mdsalbridge.getDatapathType()).thenAnswer(
- (Answer<Class<? extends DatapathTypeBase>>) invocation -> DatapathTypeNetdev.class);
+ when(mdsalbridge.getDatapathType()).thenReturn(DatapathTypeNetdev.VALUE);
assertEquals("netdev", SouthboundMapper.createDatapathType(mdsalbridge));
- when(mdsalbridge.getDatapathType()).thenAnswer(
- (Answer<Class<? extends DatapathTypeBase>>) invocation -> DatapathTypeSystem.class);
+ when(mdsalbridge.getDatapathType()).thenReturn(DatapathTypeSystem.VALUE);
assertEquals("system", SouthboundMapper.createDatapathType(mdsalbridge));
}
@Test
public void testCreateDatapathType1() {
- assertEquals(DatapathTypeSystem.class, SouthboundMapper.createDatapathType(""));
- assertEquals(DatapathTypeSystem.class, SouthboundMapper.createDatapathType("system"));
- assertEquals(DatapathTypeNetdev.class, SouthboundMapper.createDatapathType("netdev"));
+ assertEquals(DatapathTypeSystem.VALUE, SouthboundMapper.createDatapathType(""));
+ assertEquals(DatapathTypeSystem.VALUE, SouthboundMapper.createDatapathType("system"));
+ assertEquals(DatapathTypeNetdev.VALUE, SouthboundMapper.createDatapathType("netdev"));
}
@Test
public void testCreateOvsdbBridgeProtocols() {
OvsdbBridgeAugmentation ovsdbBridgeNode = mock(OvsdbBridgeAugmentation.class);
- List<ProtocolEntry> protocolList = new ArrayList<>();
ProtocolEntry protocolEntry = new ProtocolEntryBuilder()
- .setProtocol(OvsdbBridgeProtocolOpenflow10.class)
+ .setProtocol(OvsdbBridgeProtocolOpenflow10.VALUE)
.build();
when(ovsdbBridgeNode.getProtocolEntry()).thenReturn(Map.of(protocolEntry.key(), protocolEntry));
@Test
public void testCreateInterfaceType() {
- assertEquals(InterfaceTypeInternal.class, SouthboundMapper.createInterfaceType("internal"));
- assertEquals(InterfaceTypeVxlan.class, SouthboundMapper.createInterfaceType("vxlan"));
+ assertEquals(InterfaceTypeInternal.VALUE, SouthboundMapper.createInterfaceType("internal"));
+ assertEquals(InterfaceTypeVxlan.VALUE, SouthboundMapper.createInterfaceType("vxlan"));
}
@Test
public void testCreateOvsdbInterfaceType() {
- assertEquals("internal", SouthboundMapper.createOvsdbInterfaceType(InterfaceTypeInternal.class));
- assertEquals("vxlan", SouthboundMapper.createOvsdbInterfaceType(InterfaceTypeVxlan.class));
+ assertEquals("internal", SouthboundMapper.createOvsdbInterfaceType(InterfaceTypeInternal.VALUE));
+ assertEquals("vxlan", SouthboundMapper.createOvsdbInterfaceType(InterfaceTypeVxlan.VALUE));
}
@SuppressWarnings("unchecked")
List<ProtocolEntry> returnedProtocols = SouthboundMapper.createMdsalProtocols(bridge);
assertEquals(value.size(), returnedProtocols.size());
- assertEquals(OvsdbBridgeProtocolOpenflow10.class, returnedProtocols.get(0).getProtocol());
+ assertEquals(OvsdbBridgeProtocolOpenflow10.VALUE, returnedProtocols.get(0).getProtocol());
}
@SuppressWarnings("unchecked")
when(client.getConnectionInfo().getLocalPort()).thenReturn(8081);
ConnectionInfo returnedConnectionInfo = SouthboundMapper.createConnectionInfo(client);
- assertEquals(IpAddressBuilder.getDefaultInstance("1.2.3.4"), returnedConnectionInfo.getRemoteIp());
+ assertEquals(new IpAddress(new Ipv4Address("1.2.3.4")), returnedConnectionInfo.getRemoteIp());
assertEquals(8080, returnedConnectionInfo.getRemotePort().getValue().toJava());
- assertEquals(IpAddressBuilder.getDefaultInstance("1.2.3.5"), returnedConnectionInfo.getLocalIp());
+ assertEquals(new IpAddress(new Ipv4Address("1.2.3.5")), returnedConnectionInfo.getLocalIp());
assertEquals(8081, returnedConnectionInfo.getLocalPort().getValue().toJava());
}
@Test
public void testSuppressLocalIpPort() throws Exception {
ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
- IpAddress ipAddress = IpAddressBuilder.getDefaultInstance("1.2.3.4");
+ IpAddress ipAddress = new IpAddress(new Ipv4Address("1.2.3.4"));
when(connectionInfo.getRemoteIp()).thenReturn(ipAddress);
PortNumber portNumber = PortNumber.getDefaultInstance("8080");
when(connectionInfo.getRemotePort()).thenReturn(portNumber);
private Node createBridgeNode(final String bridgeName) {
ProtocolEntry protocolEntry = new ProtocolEntryBuilder()
- .setProtocol(OvsdbBridgeProtocolOpenflow10.class)
+ .setProtocol(OvsdbBridgeProtocolOpenflow10.VALUE)
.build();
ControllerEntry controllerEntry = new ControllerEntryBuilder().setTarget(new Uri("mock")).build();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.southbound.transactions.md;
import static org.junit.Assert.assertEquals;
verify(openVSwitch).getDatapathTypesColumn();
Map<DatapathTypeEntryKey, DatapathTypeEntry> entries = ovsdbNodeBuilder.getDatapathTypeEntry();
assertEquals(2, entries.size());
- assertTrue(entries.containsKey(new DatapathTypeEntryKey(DatapathTypeNetdev.class)));
- assertTrue(entries.containsKey(new DatapathTypeEntryKey(DatapathTypeSystem.class)));
+ assertTrue(entries.containsKey(new DatapathTypeEntryKey(DatapathTypeNetdev.VALUE)));
+ assertTrue(entries.containsKey(new DatapathTypeEntryKey(DatapathTypeSystem.VALUE)));
}
@Test
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
-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.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.DatapathId;
-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.DatapathTypeSystem;
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;
when(bridge.getDatapathTypeColumn()).thenReturn(column);
when(column.getData()).thenReturn("system");
PowerMockito.mockStatic(SouthboundMapper.class);
- when(SouthboundMapper.createDatapathType(anyString()))
- .thenAnswer((Answer<Class<? extends DatapathTypeBase>>) invocation -> DatapathTypeSystem.class);
+ when(SouthboundMapper.createDatapathType(anyString())).thenReturn(DatapathTypeSystem.VALUE);
OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
- when(ovsdbBridgeAugmentationBuilder.setDatapathType(any(Class.class)))
+ when(ovsdbBridgeAugmentationBuilder.setDatapathType(any()))
.thenReturn(ovsdbBridgeAugmentationBuilder);
Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setDataPathType", ovsdbBridgeAugmentationBuilder, bridge);
verify(bridge).getDatapathTypeColumn();
verify(column).getData();
- verify(ovsdbBridgeAugmentationBuilder).setDatapathType(any(Class.class));
+ verify(ovsdbBridgeAugmentationBuilder).setDatapathType(any());
}
@SuppressWarnings("unchecked")
set.add("standalone");
when(column.getData()).thenReturn(set);
OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
- when(ovsdbBridgeAugmentationBuilder.setFailMode(OvsdbFailModeStandalone.class))
+ when(ovsdbBridgeAugmentationBuilder.setFailMode(OvsdbFailModeStandalone.VALUE))
.thenReturn(ovsdbBridgeAugmentationBuilder);
Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setFailMode", ovsdbBridgeAugmentationBuilder, bridge);
verify(bridge, times(5)).getFailModeColumn();
- verify(ovsdbBridgeAugmentationBuilder).setFailMode(OvsdbFailModeStandalone.class);
+ verify(ovsdbBridgeAugmentationBuilder).setFailMode(OvsdbFailModeStandalone.VALUE);
}
@SuppressWarnings("unchecked")
// Call setProtocol()
when(SouthboundMapper.createMdsalProtocols(any(Bridge.class)))
- .thenReturn(List.of(new ProtocolEntryBuilder().setProtocol(OvsdbBridgeProtocolBase.class).build()));
+ .thenReturn(List.of(new ProtocolEntryBuilder().setProtocol(OvsdbBridgeProtocolBase.VALUE).build()));
OvsdbBridgeUpdateCommand.setProtocol(builder, bridge);
// Call setDataPath()
var protocols = result.nonnullProtocolEntry().values();
assertEquals(1, protocols.size());
var protocol = protocols.iterator().next();
- assertEquals(OvsdbBridgeProtocolBase.class, protocol.getProtocol());
+ assertEquals(OvsdbBridgeProtocolBase.VALUE, protocol.getProtocol());
// Assert setDataPath()
assertSame(dpid, result.getDatapathId());
}
@Test
- @SuppressWarnings("unchecked")
public void testUpdateInterface() throws Exception {
Interface interf = mock(Interface.class);
OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
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(anyString()))
- .thenAnswer(invocation -> InterfaceTypeInternal.class);
- when(ovsdbTerminationPointBuilder.setInterfaceType(any(Class.class))).thenReturn(ovsdbTerminationPointBuilder);
+ PowerMockito.when(SouthboundMapper.createInterfaceType(anyString())).thenReturn(InterfaceTypeInternal.VALUE);
+ when(ovsdbTerminationPointBuilder.setInterfaceType(any())).thenReturn(ovsdbTerminationPointBuilder);
suppress(method(OvsdbPortUpdateCommand.class, "updateOfPort", Interface.class,
OvsdbTerminationPointAugmentationBuilder.class));
suppress(method(OvsdbPortUpdateCommand.class, "updateOfPortRequest", Interface.class,
Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterface", interf, OVSDB_INTERFACE_TYPE,
ovsdbTerminationPointBuilder);
verify(ovsdbTerminationPointBuilder).setInterfaceUuid(any(Uuid.class));
- verify(ovsdbTerminationPointBuilder).setInterfaceType(any(Class.class));
+ verify(ovsdbTerminationPointBuilder).setInterfaceType(any());
verify(ovsdbPortUpdateCommand).updateOfPort(any(Interface.class),
any(OvsdbTerminationPointAugmentationBuilder.class));
verify(ovsdbPortUpdateCommand).updateOfPortRequest(any(Interface.class),
createdIids.add(identifier);
final DataObject obj = rootNode.getDataAfter();
- if (obj instanceof ManagedNodeEntry) {
- ManagedNodeEntry managedNodeEntry = (ManagedNodeEntry) obj;
+ if (obj instanceof ManagedNodeEntry managedNodeEntry) {
LOG.info("{} DataChanged: created managed {}",
managedNodeEntry.getBridgeRef().getValue());
createdIids.add(managedNodeEntry.getBridgeRef().getValue());
}
protected String usage() {
- return "Integration Test needs a valid connection configuration as follows :\n"
- + "active connection : mvn -Dovsdbserver.ipaddress=x.x.x.x -Dovsdbserver.port=yyyy verify\n"
- + "passive connection : mvn -Dovsdbserver.connection=passive verify\n";
+ return """
+ Integration Test needs a valid connection configuration as follows :
+ active connection : mvn -Dovsdbserver.ipaddress=x.x.x.x -Dovsdbserver.port=yyyy verify
+ passive connection : mvn -Dovsdbserver.connection=passive verify
+ """;
}
@Override
LOG.info("DPDK not supported on this node.");
} else {
for (DatapathTypeEntry dpTypeEntry : datapathTypeEntries.values()) {
- Class<? extends DatapathTypeBase> dpType = dpTypeEntry.getDatapathType();
+ DatapathTypeBase dpType = dpTypeEntry.getDatapathType();
String dpTypeStr = SouthboundMapper.DATAPATH_TYPE_MAP.get(dpType);
LOG.info("dp type is {}", dpTypeStr);
if (dpTypeStr.equals(NETDEV_DP_TYPE)) {
// Verify that each termination point has the specific DPDK ifType
for (String dpdkType : dpdkTypes) {
String testPortname = "test" + dpdkType + "port";
- Class<? extends InterfaceTypeBase> dpdkIfType =
- SouthboundMapper.OVSDB_INTERFACE_TYPE_MAP.get(dpdkType);
+ InterfaceTypeBase dpdkIfType = SouthboundMapper.OVSDB_INTERFACE_TYPE_MAP.get(dpdkType);
for (TerminationPoint terminationPoint
: terminationPointNode.nonnullTerminationPoint().values()) {
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation = terminationPoint
}
private static Map<ProtocolEntryKey, ProtocolEntry> createMdsalProtocols() {
- ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
- SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
+ ImmutableBiMap<String, OvsdbBridgeProtocolBase> mapper = SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
return BindingMap.of(new ProtocolEntryBuilder().setProtocol(mapper.get("OpenFlow13")).build());
}
}
private static OvsdbTerminationPointAugmentationBuilder createSpecificDpdkOvsdbTerminationPointAugmentationBuilder(
- final String testPortname, final Class<? extends InterfaceTypeBase> dpdkIfType) {
+ final String testPortname, final InterfaceTypeBase dpdkIfType) {
return createGenericOvsdbTerminationPointAugmentationBuilder()
.setName(testPortname)
.setInterfaceType(dpdkIfType);
*/
TestBridge(final ConnectionInfo connectionInfo, @Nullable InstanceIdentifier<Node> bridgeIid,
final String bridgeName, NodeId bridgeNodeId, final boolean setProtocolEntries,
- final Class<? extends OvsdbFailModeBase> failMode, final boolean setManagedBy,
- @Nullable final Class<? extends DatapathTypeBase> dpType,
+ final OvsdbFailModeBase failMode, final boolean setManagedBy,
+ @Nullable final DatapathTypeBase dpType,
@Nullable final Map<BridgeExternalIdsKey, BridgeExternalIds> externalIds,
@Nullable final Map<ControllerEntryKey, ControllerEntry> controllerEntries,
@Nullable final Map<BridgeOtherConfigsKey, BridgeOtherConfigs> otherConfigs) {
* @param externalIds The external identifiers if any.
* @param otherConfigs The other configuration items if any.
*/
- TestQos(final ConnectionInfo connectionInfo,
- final Uri qosId,
- final Class<? extends QosTypeBase> qosType,
- final @Nullable Map<QosExternalIdsKey, QosExternalIds> externalIds,
- final @Nullable Map<QosOtherConfigKey, QosOtherConfig> otherConfigs) {
+ TestQos(final ConnectionInfo connectionInfo, final Uri qosId, final QosTypeBase qosType,
+ final @Nullable Map<QosExternalIdsKey, QosExternalIds> externalIds,
+ final @Nullable Map<QosOtherConfigKey, QosOtherConfig> otherConfigs) {
this.connectionInfo = connectionInfo;
this.qosId = qosId;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>controller-artifacts</artifactId>
- <version>5.0.5</version>
+ <version>6.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-utils-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-utils" version="${project.version}">
- <feature version="[5,6)">odl-mdsal-broker</feature>
+ <feature version="[6,7)">odl-mdsal-broker</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>10.0.2</version>
+ <version>11.0.0</version>
<relativePath/>
</parent>
<groupId>org.osgi</groupId>
<artifactId>org.osgi.framework</artifactId>
</dependency>
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-api</artifactId>
- </dependency>
<dependency>
<groupId>org.springframework.osgi</groupId>
<artifactId>spring-osgi-mock</artifactId>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-simple</artifactId>
+ <version>1.2.1</version>
<scope>test</scope>
</dependency>
</dependencies>
+
<build>
<plugins>
<plugin>
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 static final InterfaceTypeEntryKey DPDK_IFACE_KEY = new InterfaceTypeEntryKey(InterfaceTypeDpdk.VALUE);
private final UtilsProvider provider;
provider = new MdsalUtilsProvider(mdsalUtils);
}
- public static final ImmutableBiMap<String, Class<? extends InterfaceTypeBase>> OVSDB_INTERFACE_TYPE_MAP =
- new ImmutableBiMap.Builder<String, Class<? extends InterfaceTypeBase>>()
- .put("internal", InterfaceTypeInternal.class)
- .put("vxlan", InterfaceTypeVxlan.class)
- .put("vxlan-gpe", InterfaceTypeVxlanGpe.class)
- .put("patch", InterfaceTypePatch.class)
- .put("system", InterfaceTypeSystem.class)
- .put("tap", InterfaceTypeTap.class)
- .put("geneve", InterfaceTypeGeneve.class)
- .put("gre", InterfaceTypeGre.class)
- .put("ipsec_gre", InterfaceTypeIpsecGre.class)
- .put("gre64", InterfaceTypeGre64.class)
- .put("ipsec_gre64", InterfaceTypeIpsecGre64.class)
- .put("lisp", InterfaceTypeLisp.class)
- .put("dpdk", InterfaceTypeDpdk.class)
- .put("dpdkr", InterfaceTypeDpdkr.class)
- .put("dpdkvhost", InterfaceTypeDpdkvhost.class)
- .put("dpdkvhostuser", InterfaceTypeDpdkvhostuser.class)
- .put("dpdkvhostuserclient", InterfaceTypeDpdkvhostuserclient.class)
+ public static final ImmutableBiMap<String, InterfaceTypeBase> OVSDB_INTERFACE_TYPE_MAP =
+ ImmutableBiMap.<String, InterfaceTypeBase>builder()
+ .put("internal", InterfaceTypeInternal.VALUE)
+ .put("vxlan", InterfaceTypeVxlan.VALUE)
+ .put("vxlan-gpe", InterfaceTypeVxlanGpe.VALUE)
+ .put("patch", InterfaceTypePatch.VALUE)
+ .put("system", InterfaceTypeSystem.VALUE)
+ .put("tap", InterfaceTypeTap.VALUE)
+ .put("geneve", InterfaceTypeGeneve.VALUE)
+ .put("gre", InterfaceTypeGre.VALUE)
+ .put("ipsec_gre", InterfaceTypeIpsecGre.VALUE)
+ .put("gre64", InterfaceTypeGre64.VALUE)
+ .put("ipsec_gre64", InterfaceTypeIpsecGre64.VALUE)
+ .put("lisp", InterfaceTypeLisp.VALUE)
+ .put("dpdk", InterfaceTypeDpdk.VALUE)
+ .put("dpdkr", InterfaceTypeDpdkr.VALUE)
+ .put("dpdkvhost", InterfaceTypeDpdkvhost.VALUE)
+ .put("dpdkvhostuser", InterfaceTypeDpdkvhostuser.VALUE)
+ .put("dpdkvhostuserclient", InterfaceTypeDpdkvhostuserclient.VALUE)
.build();
- public static final ImmutableBiMap<Class<? extends OvsdbBridgeProtocolBase>, String> OVSDB_PROTOCOL_MAP =
- new ImmutableBiMap.Builder<Class<? extends OvsdbBridgeProtocolBase>, String>()
- .put(OvsdbBridgeProtocolOpenflow10.class,"OpenFlow10")
- .put(OvsdbBridgeProtocolOpenflow11.class,"OpenFlow11")
- .put(OvsdbBridgeProtocolOpenflow12.class,"OpenFlow12")
- .put(OvsdbBridgeProtocolOpenflow13.class,"OpenFlow13")
- .put(OvsdbBridgeProtocolOpenflow14.class,"OpenFlow14")
- .put(OvsdbBridgeProtocolOpenflow15.class,"OpenFlow15")
+ public static final ImmutableBiMap<OvsdbBridgeProtocolBase, String> OVSDB_PROTOCOL_MAP =
+ ImmutableBiMap.<OvsdbBridgeProtocolBase, String>builder()
+ .put(OvsdbBridgeProtocolOpenflow10.VALUE, "OpenFlow10")
+ .put(OvsdbBridgeProtocolOpenflow11.VALUE, "OpenFlow11")
+ .put(OvsdbBridgeProtocolOpenflow12.VALUE, "OpenFlow12")
+ .put(OvsdbBridgeProtocolOpenflow13.VALUE, "OpenFlow13")
+ .put(OvsdbBridgeProtocolOpenflow14.VALUE, "OpenFlow14")
+ .put(OvsdbBridgeProtocolOpenflow15.VALUE, "OpenFlow15")
.build();
- private static final ImmutableBiMap<Class<? extends OvsdbFailModeBase>, String> OVSDB_FAIL_MODE_MAP =
- new ImmutableBiMap.Builder<Class<? extends OvsdbFailModeBase>, String>()
- .put(OvsdbFailModeStandalone.class,"standalone")
- .put(OvsdbFailModeSecure.class,"secure")
+ private static final ImmutableBiMap<OvsdbFailModeBase, String> OVSDB_FAIL_MODE_MAP =
+ ImmutableBiMap.<OvsdbFailModeBase, String>builder()
+ .put(OvsdbFailModeStandalone.VALUE, "standalone")
+ .put(OvsdbFailModeSecure.VALUE, "secure")
.build();
private static final BridgeOtherConfigs OTHER_CONFIG_DISABLE_INBAND = new BridgeOtherConfigsBuilder()
*/
public boolean addBridge(final ConnectionInfo connectionInfo, InstanceIdentifier<Node> bridgeIid,
final String bridgeName, NodeId bridgeNodeId, final boolean setProtocolEntries,
- final Class<? extends OvsdbFailModeBase> failMode, final boolean setManagedBy,
- final Class<? extends DatapathTypeBase> dpType,
+ final OvsdbFailModeBase failMode, final boolean setManagedBy,
+ final DatapathTypeBase dpType,
final Map<BridgeExternalIdsKey, BridgeExternalIds> externalIds,
final Map<ControllerEntryKey, ControllerEntry> controllerEntries,
final Map<BridgeOtherConfigsKey, BridgeOtherConfigs> otherConfigs,
return result;
}
- public boolean addBridge(Node ovsdbNode, String bridgeName, List<String> controllersStr,
- final Class<? extends DatapathTypeBase> dpType, String mac) {
+ public boolean addBridge(Node ovsdbNode, String bridgeName, List<String> controllersStr, DatapathTypeBase dpType,
+ String mac) {
return addBridge(ovsdbNode, bridgeName, controllersStr, dpType, mac, null, null);
}
- public boolean addBridge(Node ovsdbNode, String bridgeName, List<String> controllersStr,
- final Class<? extends DatapathTypeBase> dpType, String mac,
- Long maxBackoff, Long inactivityProbe) {
+ public boolean addBridge(Node ovsdbNode, String bridgeName, List<String> controllersStr, DatapathTypeBase dpType,
+ String mac, Long maxBackoff, Long inactivityProbe) {
List<BridgeOtherConfigs> otherConfigs = new ArrayList<>();
if (mac != null) {
otherConfigs.add(new BridgeOtherConfigsBuilder()
return addBridge(ovsdbNode, bridgeName, controllersStr, dpType, otherConfigs, null, null);
}
- public boolean addBridge(Node ovsdbNode, String bridgeName, List<String> controllersStr,
- final Class<? extends DatapathTypeBase> dpType, List<BridgeOtherConfigs> otherConfigs,
- Uint32 maxBackoff, Uint32 inactivityProbe) {
+ public boolean addBridge(Node ovsdbNode, String bridgeName, List<String> controllersStr, DatapathTypeBase dpType,
+ List<BridgeOtherConfigs> otherConfigs, Uint32 maxBackoff, Uint32 inactivityProbe) {
LOG.info("addBridge: node: {}, bridgeName: {}, controller(s): {}", ovsdbNode, bridgeName, controllersStr);
ConnectionInfo connectionInfo = getConnectionInfo(ovsdbNode);
if (connectionInfo == null) {
ovsdbBridgeAugmentationBuilder.setDatapathType(dpType);
}
if (isOvsdbNodeDpdk(ovsdbNode)) {
- ovsdbBridgeAugmentationBuilder.setDatapathType(DatapathTypeNetdev.class);
+ ovsdbBridgeAugmentationBuilder.setDatapathType(DatapathTypeNetdev.VALUE);
}
InstanceIdentifier<Node> bridgeIid = createInstanceIdentifier(ovsdbNode.key(), bridgeName);
try {
openFlowPort = Short.parseShort(portString);
} catch (NumberFormatException e) {
- LOG.warn("Invalid port:{}, use default({})", portString,
- openFlowPort, e);
+ LOG.warn("Invalid port:{}, use default({})", portString, openFlowPort, e);
}
}
return openFlowPort;
long dpid = 0L;
String datapathId = getDatapathId(node);
if (datapathId != null) {
- dpid = new BigInteger(datapathId.replaceAll(":", ""), 16).longValue();
+ dpid = new BigInteger(datapathId.replace(":", ""), 16).longValue();
}
return dpid;
}
private static boolean matchesBridgeName(ManagedNodeEntry managedNode, String bridgeName) {
InstanceIdentifier<?> bridgeIid = managedNode.getBridgeRef().getValue();
for (PathArgument bridgeIidPathArg : bridgeIid.getPathArguments()) {
- if (bridgeIidPathArg instanceof IdentifiableItem<?, ?>) {
- IdentifiableItem<?, ?> identifiableItem = (IdentifiableItem<?, ?>) bridgeIidPathArg;
+ if (bridgeIidPathArg instanceof IdentifiableItem<?, ?> identifiableItem) {
Identifier<?> key = identifiableItem.getKey();
- if (key instanceof NodeKey) {
- // Do not combine the above if with that below, we want to
- // avoid the toString() call in the else if this is a NodeKey
- NodeKey nodeKey = (NodeKey) key;
+ if (key instanceof NodeKey nodeKey) {
if (nodeKey.getNodeId().getValue().contains(bridgeName)) {
return true;
}
Code Review / ovsdb.git / commitdiff