<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>
<artifactId>testtool-util</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<artifactId>guava</artifactId>
</dependency>
<!--Test dependencies-->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
displayRibOperationalState(ribId, globalBgp.getGlobal(), stream);
} else {
if (neighbor != null) {
- globalBgp.getNeighbors().getNeighbor().stream()
+ globalBgp.getNeighbors().nonnullNeighbor().values().stream()
.filter(neig -> toString(neig.key().getNeighborAddress()).matches(neighbor))
.findFirst()
.ifPresent(neighbor1 -> displayNeighborOperationalState(neighbor, neighbor1, stream));
} else {
- displayPeerOperationalState(globalBgp.getPeerGroups().getPeerGroup(), stream);
+ displayPeerOperationalState(globalBgp.getPeerGroups().nonnullPeerGroup().values(), stream);
}
}
}
table.addRow().addContent("As", globalState.getAs());
table.addRow().addContent("Total Paths", globalState.getTotalPaths());
table.addRow().addContent("Total Prefixes", globalState.getTotalPrefixes());
- global.getAfiSafis().getAfiSafi().forEach(afiSafi -> displayAfiSafi(afiSafi, table));
+ global.getAfiSafis().nonnullAfiSafi().values().forEach(afiSafi -> displayAfiSafi(afiSafi, table));
table.print(stream);
}
package org.opendaylight.protocol.bgp.cli.utils;
import java.io.PrintStream;
+import java.util.Collection;
import java.util.List;
import org.apache.karaf.shell.support.table.ShellTable;
import org.eclipse.jdt.annotation.NonNull;
printTimerState(neighbor.getTimers(), table);
printTransportState(neighbor.getTransport(), table);
printMessagesState(neighborState, table);
- printAfiSafisState(neighbor.getAfiSafis().getAfiSafi(), table);
+ printAfiSafisState(neighbor.getAfiSafis().nonnullAfiSafi().values(), table);
table.print(stream);
}
table.addRow().addContent("======================", "");
}
- private static void printAfiSafisState(final
List<AfiSafi> afiSafis, final ShellTable table) {
+ private static void printAfiSafisState(final
Collection<AfiSafi> afiSafis, final ShellTable table) {
afiSafis.forEach(afiSafi -> printAfiSafiState(afiSafi, table));
}
import static org.opendaylight.protocol.bgp.cli.utils.NeighborStateCliUtils.addHeader;
import java.io.PrintStream;
-import java.util.List;
+import java.util.Collection;
import org.apache.karaf.shell.support.table.ShellTable;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbor.group.State;
// Hidden on purpose
}
- static void displayPeerOperationalState(@NonNull final
List<PeerGroup> peerGroupList,
+ static void displayPeerOperationalState(@NonNull final
Collection<PeerGroup> peerGroupList,
@NonNull final PrintStream stream) {
final ShellTable table = new ShellTable();
table.column("Attribute").alignLeft();
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
}
@Override
- public List<EvpnRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<EvpnRouteKey, EvpnRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.evpn.rev200120
.bgp.rib.rib.peer.adj.rib.in.tables.routes.EvpnRoutesCase, "Unrecognized routes %s", routes);
return ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.evpn.rev200120
@Override
public void setUp() throws Exception {
super.setUp();
- this.ribSupport = EvpnRibSupport.getInstance(this.mappingService);
+ this.ribSupport = EvpnRibSupport.getInstance(this.adapter.currentSerializer());
setUpTestCustomizer(this.ribSupport);
}
final RIBActivator ribAct = new RIBActivator();
final RIBExtensionProviderContext context = new SimpleRIBExtensionProviderContext();
assertNull(context.getRIBSupport(L2vpnAddressFamily.class, EvpnSubsequentAddressFamily.class));
- ribAct.startRIBExtensionProvider(context, this.mappingService);
+ ribAct.startRIBExtensionProvider(context, this.context.currentSerializer());
assertNotNull(context.getRIBSupport(L2vpnAddressFamily.class, EvpnSubsequentAddressFamily.class));
ribAct.close();
}
import static com.google.common.base.Verify.verify;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev200120.FlowspecSubsequentAddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev200120.bgp.rib.rib.loc.rib.tables.routes.FlowspecRoutesCase;
}
@Override
- public List<FlowspecRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<FlowspecRouteKey, FlowspecRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev200120
.bgp.rib.rib.peer.adj.rib.in.tables.routes.FlowspecRoutesCase, "Unrecognized routes %s", routes);
return ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev200120
import static com.google.common.base.Verify.verify;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev200120.FlowspecSubsequentAddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev200120.bgp.rib.rib.loc.rib.tables.routes.FlowspecIpv6RoutesCase;
}
@Override
- public List<FlowspecRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<FlowspecRouteKey, FlowspecRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev200120
.bgp.rib.rib.peer.adj.rib.in.tables.routes.FlowspecIpv6RoutesCase, "Unrecognized routes %s", routes);
return ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev200120
import static com.google.common.base.Verify.verify;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.protocol.bgp.flowspec.SimpleFlowspecExtensionProviderContext;
import org.opendaylight.protocol.bgp.flowspec.l3vpn.AbstractFlowspecL3vpnRIBSupport;
}
@Override
- public List<FlowspecL3vpnRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<FlowspecL3vpnRouteKey, FlowspecL3vpnRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev200120
.bgp.rib.rib.peer.adj.rib.in.tables.routes.FlowspecL3vpnIpv4RoutesCase, "Unrecognized routes %s", routes);
return ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev200120
import static com.google.common.base.Verify.verify;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.protocol.bgp.flowspec.SimpleFlowspecExtensionProviderContext;
import org.opendaylight.protocol.bgp.flowspec.l3vpn.AbstractFlowspecL3vpnRIBSupport;
}
@Override
- public List<FlowspecL3vpnRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<FlowspecL3vpnRouteKey, FlowspecL3vpnRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev200120
.bgp.rib.rib.peer.adj.rib.in.tables.routes.FlowspecL3vpnIpv6RoutesCase, "Unrecognized routes %s", routes);
return ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev200120
final BGPActivator act = new BGPActivator(activator);
final BGPExtensionProviderContext context = new SimpleBGPExtensionProviderContext();
act.start(context);
- this.ribSupport = FlowspecIpv4RIBSupport.getInstance(fsContext, this.mappingService);
+ this.ribSupport = FlowspecIpv4RIBSupport.getInstance(fsContext, this.adapter.currentSerializer());
final SimpleFlowspecIpv4NlriParser parser = new SimpleFlowspecIpv4NlriParser(
fsContext.getFlowspecTypeRegistry(SimpleFlowspecExtensionProviderContext.AFI.IPV4,
this.route = new FlowspecRouteBuilder().withKey(this.routeKey).setPathId(PATH_ID).setFlowspec(FLOW_LIST)
.setAttributes(new AttributesBuilder().build()).build();
this.routes = new FlowspecIpv6RoutesBuilder().setFlowspecRoute(Collections.singletonList(this.route)).build();
- this.ribSupport = FlowspecIpv6RIBSupport.getInstance(fsContext, this.mappingService);
+ this.ribSupport = FlowspecIpv6RIBSupport.getInstance(fsContext, this.adapter.currentSerializer());
setUpTestCustomizer(this.ribSupport);
}
public void setUp() throws Exception {
super.setUp();
this.ribSupport = FlowspecL3vpnIpv4RIBSupport
- .getInstance(new SimpleFlowspecExtensionProviderContext(), this.mappingService);
+ .getInstance(new SimpleFlowspecExtensionProviderContext(), this.adapter.currentSerializer());
setUpTestCustomizer(this.ribSupport);
}
public void setUp() throws Exception {
super.setUp();
this.ribSupport = FlowspecL3vpnIpv6RIBSupport
- .getInstance(new SimpleFlowspecExtensionProviderContext(), this.mappingService);
+ .getInstance(new SimpleFlowspecExtensionProviderContext(), this.adapter.currentSerializer());
setUpTestCustomizer(this.ribSupport);
}
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.protocol.bgp.parser.spi.PathIdUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
}
@Override
- public List<Ipv4Route> extractAdjRibInRoutes(final Routes routes) {
+ public Map<Ipv4RouteKey, Ipv4Route> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329
.bgp.rib.rib.peer.adj.rib.in.tables.routes.Ipv4RoutesCase, "Unrecognized routes %s", routes);
return ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.bgp.rib.rib.peer
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.protocol.bgp.parser.spi.PathIdUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
}
@Override
- public List<Ipv6Route> extractAdjRibInRoutes(final Routes routes) {
+ public Map<Ipv6RouteKey, Ipv6Route> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329
.bgp.rib.rib.peer.adj.rib.in.tables.routes.Ipv6RoutesCase, "Unrecognized routes %s", routes);
return ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.bgp.rib.rib.peer
import com.google.common.collect.Lists;
import java.util.Collection;
import java.util.Collections;
+import java.util.Map;
import org.junit.Assert;
import org.junit.Test;
import org.opendaylight.protocol.bgp.rib.spi.AbstractRIBSupportTest;
.setPathId(PATH_ID)
.setPrefix(PREFIX).build();
private static final Ipv4Routes ROUTES = new Ipv4RoutesBuilder()
- .setIpv4Route(Collections.singletonList(ROUTE)).build();
+ .setIpv4Route(Map.of(ROUTE.key(), ROUTE))
+ .build();
@Override
public void setUp() throws Exception {
super.setUp();
- this.ribSupport = IPv4RIBSupport.getInstance(this.mappingService);
+ this.ribSupport = IPv4RIBSupport.getInstance(this.adapter.currentSerializer());
setUpTestCustomizer(this.ribSupport);
}
@Override
public void setUp() throws Exception {
super.setUp();
- this.ribSupport = IPv6RIBSupport.getInstance(this.mappingService);
+ this.ribSupport = IPv6RIBSupport.getInstance(this.adapter.currentSerializer());
setUpTestCustomizer(this.ribSupport);
}
import io.netty.buffer.Unpooled;
import java.util.Collection;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import java.util.Optional;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.protocol.bgp.l3vpn.mcast.nlri.L3vpnMcastNlriSerializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.bgp.rib.rib.loc.rib.tables.routes.L3vpnMcastRoutesIpv4Case;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.l3vpn.mcast.destination.L3vpnMcastDestination;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.l3vpn.mcast.routes.L3vpnMcastRoute;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.l3vpn.mcast.routes.L3vpnMcastRouteKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.l3vpn.mcast.routes.ipv4.L3vpnMcastRoutesIpv4;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.l3vpn.mcast.routes.ipv4.L3vpnMcastRoutesIpv4Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.update.attributes.mp.reach.nlri.advertized.routes.destination.type.DestinationL3vpnMcastIpv4AdvertizedCase;
}
@Override
- public List<L3vpnMcastRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<L3vpnMcastRouteKey, L3vpnMcastRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast
.rev180417.bgp.rib.rib.peer.adj.rib.in.tables.routes.L3vpnMcastRoutesIpv4Case, "Unrecognized routes %s",
routes);
import io.netty.buffer.Unpooled;
import java.util.Collection;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import java.util.Optional;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.protocol.bgp.l3vpn.mcast.nlri.L3vpnMcastNlriSerializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.bgp.rib.rib.loc.rib.tables.routes.L3vpnMcastRoutesIpv6Case;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.l3vpn.mcast.destination.L3vpnMcastDestination;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.l3vpn.mcast.routes.L3vpnMcastRoute;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.l3vpn.mcast.routes.L3vpnMcastRouteKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.l3vpn.mcast.routes.ipv6.L3vpnMcastRoutesIpv6;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.l3vpn.mcast.routes.ipv6.L3vpnMcastRoutesIpv6Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast.rev180417.update.attributes.mp.reach.nlri.advertized.routes.destination.type.DestinationL3vpnMcastIpv6AdvertizedCase;
}
@Override
- public List<L3vpnMcastRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<L3vpnMcastRouteKey, L3vpnMcastRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.l3vpn.mcast
.rev180417.bgp.rib.rib.peer.adj.rib.in.tables.routes.L3vpnMcastRoutesIpv6Case, "Unrecognized routes %s",
routes);
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.protocol.bgp.l3vpn.unicast.AbstractVpnRIBSupport;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.ipv4.rev180329.l3vpn.ipv4.routes.VpnIpv4RoutesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.rev180329.l3vpn.ip.destination.type.VpnDestination;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.rev180329.l3vpn.ip.route.VpnRoute;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.rev180329.l3vpn.ip.route.VpnRouteKey;
public final class VpnIpv4RIBSupport extends AbstractVpnRIBSupport<VpnIpv4RoutesCase, VpnIpv4Routes> {
private static final VpnIpv4Routes EMPTY_CONTAINER
}
@Override
- public List<VpnRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<VpnRouteKey, VpnRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.ipv4.rev180329
.bgp.rib.rib.peer.adj.rib.in.tables.routes.VpnIpv4RoutesCase, "Unrecognized routes %s", routes);
return ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.ipv4.rev180329
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.protocol.bgp.l3vpn.unicast.AbstractVpnRIBSupport;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.ipv6.rev180329.l3vpn.ipv6.routes.VpnIpv6RoutesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.rev180329.l3vpn.ip.destination.type.VpnDestination;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.rev180329.l3vpn.ip.route.VpnRoute;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.rev180329.l3vpn.ip.route.VpnRouteKey;
public final class VpnIpv6RIBSupport extends AbstractVpnRIBSupport<VpnIpv6RoutesCase, VpnIpv6Routes> {
private static final VpnIpv6Routes EMPTY_CONTAINER
}
@Override
- public List<VpnRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<VpnRouteKey, VpnRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.ipv6.rev180329
.bgp.rib.rib.peer.adj.rib.in.tables.routes.VpnIpv6RoutesCase, "Unrecognized routes %s", routes);
return ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.ipv6.rev180329
* 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.protocol.bgp.l3vpn;
import static org.junit.Assert.assertNotNull;
final RIBExtensionProviderContext context = new SimpleRIBExtensionProviderContext();
assertNull(context.getRIBSupport(Ipv4AddressFamily.class, McastMplsLabeledVpnSubsequentAddressFamily.class));
assertNull(context.getRIBSupport(Ipv6AddressFamily.class, McastMplsLabeledVpnSubsequentAddressFamily.class));
- ribAct.startRIBExtensionProvider(context, this.mappingService);
+ ribAct.startRIBExtensionProvider(context, this.context.currentSerializer());
assertNotNull(context.getRIBSupport(Ipv4AddressFamily.class, McastMplsLabeledVpnSubsequentAddressFamily.class));
assertNotNull(context.getRIBSupport(Ipv6AddressFamily.class, McastMplsLabeledVpnSubsequentAddressFamily.class));
ribAct.close();
@Override
public void setUp() throws Exception {
super.setUp();
- ribSupport = L3VpnMcastIpv4RIBSupport.getInstance(this.mappingService);
+ ribSupport = L3VpnMcastIpv4RIBSupport.getInstance(this.adapter.currentSerializer());
setUpTestCustomizer(ribSupport);
}
@Override
public void setUp() throws Exception {
super.setUp();
- ribSupport = L3VpnMcastIpv6RIBSupport.getInstance(this.mappingService);
+ ribSupport = L3VpnMcastIpv6RIBSupport.getInstance(this.adapter.currentSerializer());
setUpTestCustomizer(ribSupport);
}
@Override
public void setUp() throws Exception {
super.setUp();
- this.ribSupport = VpnIpv4RIBSupport.getInstance(this.mappingService);
+ this.ribSupport = VpnIpv4RIBSupport.getInstance(this.adapter.currentSerializer());
setUpTestCustomizer(this.ribSupport);
}
* 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.protocol.bgp.l3vpn.unicast.ipv6;
import static org.junit.Assert.assertEquals;
@Override
public void setUp() throws Exception {
super.setUp();
- this.ribSupport = VpnIpv6RIBSupport.getInstance(this.mappingService);
+ this.ribSupport = VpnIpv6RIBSupport.getInstance(this.adapter.currentSerializer());
setUpTestCustomizer(this.ribSupport);
}
import java.util.Collection;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.labeled.unicast.routes.LabeledUnicastRoutes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.labeled.unicast.routes.LabeledUnicastRoutesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.labeled.unicast.routes.list.LabeledUnicastRoute;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.labeled.unicast.routes.list.LabeledUnicastRouteKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.update.attributes.mp.reach.nlri.advertized.routes.destination.type.DestinationLabeledUnicastCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.update.attributes.mp.reach.nlri.advertized.routes.destination.type.destination.labeled.unicast._case.DestinationLabeledUnicast;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.update.attributes.mp.reach.nlri.advertized.routes.destination.type.destination.labeled.unicast._case.DestinationLabeledUnicastBuilder;
}
@Override
- public List<LabeledUnicastRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<LabeledUnicastRouteKey, LabeledUnicastRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast
.rev180329.bgp.rib.rib.peer.adj.rib.in.tables.routes.LabeledUnicastRoutesCase, "Unrecognized routes %s",
routes);
import java.util.Collection;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.labeled.unicast.ipv6.routes.LabeledUnicastIpv6Routes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.labeled.unicast.ipv6.routes.LabeledUnicastIpv6RoutesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.labeled.unicast.routes.list.LabeledUnicastRoute;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.labeled.unicast.routes.list.LabeledUnicastRouteKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.update.attributes.mp.reach.nlri.advertized.routes.destination.type.DestinationIpv6LabeledUnicastCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.update.attributes.mp.reach.nlri.advertized.routes.destination.type.destination.ipv6.labeled.unicast._case.DestinationIpv6LabeledUnicast;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast.rev180329.update.attributes.mp.reach.nlri.advertized.routes.destination.type.destination.ipv6.labeled.unicast._case.DestinationIpv6LabeledUnicastBuilder;
}
@Override
- public List<LabeledUnicastRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<LabeledUnicastRouteKey, LabeledUnicastRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.labeled.unicast
.rev180329.bgp.rib.rib.peer.adj.rib.in.tables.routes.LabeledUnicastIpv6RoutesCase, "Unrecognized routes %s",
routes);
@Override
public void setUp() throws Exception {
super.setUp();
- this.ribSupport = LabeledUnicastIpv4RIBSupport.getInstance(this.mappingService);
+ this.ribSupport = LabeledUnicastIpv4RIBSupport.getInstance(this.adapter.currentSerializer());
setUpTestCustomizer(this.ribSupport);
}
@Override
public void setUp() throws Exception {
super.setUp();
- this.ribSupport = LabeledUnicastIpv6RIBSupport.getInstance(this.mappingService);
+ this.ribSupport = LabeledUnicastIpv6RIBSupport.getInstance(this.adapter.currentSerializer());
setUpTestCustomizer(this.ribSupport);
}
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
}
@Override
- public List<LinkstateRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<LinkstateRouteKey, LinkstateRoute> extractAdjRibInRoutes(final Routes routes) {
verify(
routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120
.bgp.rib.rib.peer.adj.rib.in.tables.routes.LinkstateRoutesCase, "Unrecognized routes %s", routes);
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import java.util.Map.Entry;
import org.opendaylight.protocol.bgp.linkstate.impl.attribute.sr.SrLinkAttributesParser;
import org.opendaylight.protocol.bgp.linkstate.spi.TlvUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.linkstate.attribute.SrLanAdjIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.linkstate.attribute.UnreservedBandwidth;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.linkstate.attribute.UnreservedBandwidthBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.linkstate.attribute.UnreservedBandwidthKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.linkstate.path.attribute.LinkStateAttribute;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.linkstate.path.attribute.link.state.attribute.LinkAttributesCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.linkstate.path.attribute.link.state.attribute.LinkAttributesCaseBuilder;
LOG.trace("Finished serializing Link Attributes");
}
- private static void serializeUnreservedBw(final List<UnreservedBandwidth> ubList, final ByteBuf byteAggregator) {
+ private static void serializeUnreservedBw(final Map<UnreservedBandwidthKey, UnreservedBandwidth> ubList,
+ final ByteBuf byteAggregator) {
// this sub-TLV contains eight 32-bit IEEE floating point numbers
if (ubList != null) {
final ByteBuf unreservedBandwithBuf = Unpooled.buffer();
- for (final UnreservedBandwidth unreservedBandwidth : ubList) {
+ for (final UnreservedBandwidth unreservedBandwidth : ubList.values()) {
unreservedBandwithBuf.writeBytes(unreservedBandwidth.getBandwidth().getValue());
}
TlvUtil.writeTLV(UNRESERVED_BANDWIDTH, unreservedBandwithBuf, byteAggregator);
private SimpleBindingSubTlvsRegistry() {
}
-
public static SimpleBindingSubTlvsRegistry getInstance() {
return SINGLETON;
}
}
public void serializeBindingSubTlvs(final List<BindingSubTlvs> bindingSubTlvs, final ByteBuf aggregator) {
- for (final BindingSubTlvs subTlv : bindingSubTlvs) {
- final BindingSubTlv bindingSubTlv = subTlv.getBindingSubTlv();
- final BindingSubTlvsSerializer serializer = this.handlers.getSerializer(
- bindingSubTlv.implementedInterface());
- if (serializer == null) {
- LOG.info("Unknown binding sub Tlv type {}", subTlv);
- return;
+ if (bindingSubTlvs != null) {
+ for (final BindingSubTlvs subTlv : bindingSubTlvs) {
+ final BindingSubTlv bindingSubTlv = subTlv.getBindingSubTlv();
+ final BindingSubTlvsSerializer serializer = this.handlers.getSerializer(
+ bindingSubTlv.implementedInterface());
+ if (serializer == null) {
+ LOG.info("Unknown binding sub Tlv type {}", subTlv);
+ return;
+ }
+ serializer.serializeSubTlv(bindingSubTlv, aggregator);
}
- serializer.serializeSubTlv(bindingSubTlv, aggregator);
}
}
assertNull(context.getRIBSupport(LinkstateAddressFamily.class, LinkstateSubsequentAddressFamily.class));
- ribAct.startRIBExtensionProvider(context, this.mappingService);
+ ribAct.startRIBExtensionProvider(context, this.context.currentSerializer());
assertNotNull(context.getRIBSupport(LinkstateAddressFamily.class, LinkstateSubsequentAddressFamily.class));
@Override
public void setUp() throws Exception {
super.setUp();
- this.ribSupport = LinkstateRIBSupport.getInstance(this.mappingService);
+ this.ribSupport = LinkstateRIBSupport.getInstance(this.adapter.currentSerializer());
setUpTestCustomizer(ribSupport);
}
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.ipv4.rev180417.update.attributes.mp.reach.nlri.advertized.routes.destination.type.destination.mvpn.ipv4.advertized._case.DestinationMvpnBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.ipv4.rev180417.update.attributes.mp.unreach.nlri.withdrawn.routes.destination.type.DestinationMvpnIpv4WithdrawnCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.rev200120.mvpn.routes.MvpnRoute;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.rev200120.mvpn.routes.MvpnRouteKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.Ipv4AddressFamily;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
}
@Override
- public List<MvpnRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<MvpnRouteKey, MvpnRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.ipv4
.rev180417.bgp.rib.rib.peer.adj.rib.in.tables.routes.MvpnRoutesIpv4Case, "Unrecognized routes %s", routes);
return ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.ipv4.rev180417
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.ipv6.rev180417.update.attributes.mp.reach.nlri.advertized.routes.destination.type.destination.mvpn.ipv6.advertized._case.DestinationMvpnBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.ipv6.rev180417.update.attributes.mp.unreach.nlri.withdrawn.routes.destination.type.DestinationMvpnIpv6WithdrawnCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.rev200120.mvpn.routes.MvpnRoute;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.rev200120.mvpn.routes.MvpnRouteKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.Ipv6AddressFamily;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
}
@Override
- public List<MvpnRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<MvpnRouteKey, MvpnRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.ipv6
.rev180417.bgp.rib.rib.peer.adj.rib.in.tables.routes.MvpnRoutesIpv6Case, "Unrecognized routes %s", routes);
return ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.ipv6.rev180417
@Override
public void setUp() throws Exception {
super.setUp();
- this.ribSupport = MvpnIpv4RIBSupport.getInstance(this.mappingService);
+ this.ribSupport = MvpnIpv4RIBSupport.getInstance(this.adapter.currentSerializer());
setUpTestCustomizer(this.ribSupport);
NlriActivator.registerNlriParsers(new ArrayList<>());
}
@Override
public void setUp() throws Exception {
super.setUp();
- this.ribSupport = MvpnIpv6RIBSupport.getInstance(this.mappingService);
+ this.ribSupport = MvpnIpv6RIBSupport.getInstance(this.adapter.currentSerializer());
setUpTestCustomizer(this.ribSupport);
NlriActivator.registerNlriParsers(new ArrayList<>());
}
final RIBExtensionProviderContext context = new SimpleRIBExtensionProviderContext();
assertNull(context.getRIBSupport(Ipv4AddressFamily.class, McastVpnSubsequentAddressFamily.class));
assertNull(context.getRIBSupport(Ipv6AddressFamily.class, McastVpnSubsequentAddressFamily.class));
- ribAct.startRIBExtensionProvider(context, this.mappingService);
+ ribAct.startRIBExtensionProvider(context, this.context.currentSerializer());
assertNotNull(context.getRIBSupport(Ipv4AddressFamily.class, McastVpnSubsequentAddressFamily.class));
assertNotNull(context.getRIBSupport(Ipv6AddressFamily.class, McastVpnSubsequentAddressFamily.class));
ribAct.close();
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-codec</artifactId>
+ <artifactId>mdsal-binding-dom-codec-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
<type>test-jar</type>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
}
@Override
- public List<RouteTargetConstrainRoute> extractAdjRibInRoutes(final Routes routes) {
+ public Map<RouteTargetConstrainRouteKey, RouteTargetConstrainRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.route.target
.constrain.rev180618.bgp.rib.rib.peer.adj.rib.in.tables.routes.RouteTargetConstrainRoutesCase,
"Unrecognized routes %s", routes);
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.Map;
import org.junit.Test;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.protocol.bgp.rib.spi.AbstractRIBSupportTest;
.setRouteTargetConstrainChoice(RT)
.setOriginAs(ORIGIN_AS)
.build();
- private static final RouteTargetConstrainRoutes RT_ROUTES
- = new RouteTargetConstrainRoutesBuilder()
- .setRouteTargetConstrainRoute(Collections.singletonList(ROUTE)).build();
+ private static final RouteTargetConstrainRoutes RT_ROUTES = new RouteTargetConstrainRoutesBuilder()
+ .setRouteTargetConstrainRoute(Map.of(ROUTE.key(), ROUTE))
+ .build();
private static final RouteTargetConstrainDestination RT_DESTINATION = new RouteTargetConstrainDestinationBuilder()
.setRouteTargetConstrainChoice(RT)
public void setUp() throws Exception {
super.setUp();
NlriActivator.registerNlriParsers(new ArrayList<>());
- this.ribSupport = RouteTargetConstrainRIBSupport.getInstance(this.mappingService);
+ this.ribSupport = RouteTargetConstrainRIBSupport.getInstance(this.adapter.currentSerializer());
setUpTestCustomizer(this.ribSupport);
}
@Test
public void testRouteAttributesIdentifier() {
- assertEquals(new NodeIdentifier(Attributes.QNAME.withModule(BindingReflections
+ assertEquals(new NodeIdentifier(Attributes.QNAME.bindTo(BindingReflections
.getQNameModule(RouteTargetConstrainRoutesCase.class))),
this.ribSupport.routeAttributesIdentifier());
}
final RIBActivator ribAct = new RIBActivator();
final RIBExtensionProviderContext context = new SimpleRIBExtensionProviderContext();
assertNull(context.getRIBSupport(Ipv4AddressFamily.class, RouteTargetConstrainSubsequentAddressFamily.class));
- ribAct.startRIBExtensionProvider(context, this.mappingService);
+ ribAct.startRIBExtensionProvider(context, this.context.currentSerializer());
assertNotNull(context.getRIBSupport(Ipv4AddressFamily.class,
RouteTargetConstrainSubsequentAddressFamily.class));
ribAct.close();
<type>test-jar</type>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
<type>test-jar</type>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
package org.opendaylight.protocol.bgp.openconfig.routing.policy.statement.actions;
+import com.google.common.collect.ImmutableMap;
import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
import java.util.stream.Collectors;
import org.opendaylight.protocol.bgp.openconfig.routing.policy.spi.RouteEntryBaseAttributes;
import org.opendaylight.protocol.bgp.openconfig.routing.policy.spi.policy.action.BgpActionAugPolicy;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.path.attributes.AttributesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.path.attributes.attributes.ExtendedCommunities;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.path.attributes.attributes.UnrecognizedAttributes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.path.attributes.attributes.UnrecognizedAttributesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.ExtendedCommunity;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.bgp._default.policy.rev200120.NonTransitiveAttributesFilter;
.setAsPath(attributes.getAsPath())
.setCommunities(attributes.getCommunities());
- final List<UnrecognizedAttributes> oldAtt = attributes.getUnrecognizedAttributes();
+ final Map<UnrecognizedAttributesKey, UnrecognizedAttributes> oldAtt = attributes.getUnrecognizedAttributes();
if (oldAtt != null) {
- builder.setUnrecognizedAttributes(attributes.getUnrecognizedAttributes().stream()
+ // TODO: consider using Maps.filterValues(attributes.getUnrecognizedAttributes(),
+ // UnrecognizedAttributes::isTransitive)) ?
+ builder.setUnrecognizedAttributes(attributes.getUnrecognizedAttributes().values().stream()
.filter(UnrecognizedAttributes::isTransitive)
- .collect(Collectors.toList()));
+ .collect(ImmutableMap.toImmutableMap(UnrecognizedAttributes::key, Function.identity())));
}
final List<ExtendedCommunities> oldExt = attributes.getExtendedCommunities();
if (oldExt != null) {
if (!result.isPresent()) {
return Collections.emptyList();
}
- return result.get().getNeighbor().stream()
+ return result.get().getNeighbor().values().stream()
.map(nei -> RouterIds.createPeerId(nei.getAddress()))
.collect(Collectors.toList());
}
<artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
readDataOperational(getDataBroker(), this.bgpInstanceIdentifier, bgpRib -> {
final Neighbors neighbors = bgpRib.getNeighbors();
Assert.assertNotNull(neighbors);
- assertEquals(peerGroupExpected, bgpRib.getPeerGroups().getPeerGroup().get(0));
- final Neighbor neighborResult = neighbors.getNeighbor().get(0);
+ assertEquals(peerGroupExpected, bgpRib.getPeerGroups().nonnullPeerGroup().values().iterator().next());
+ final Neighbor neighborResult = neighbors.nonnullNeighbor().values().iterator().next();
assertEquals(new IpAddress(neighborAddress.getIpv4AddressNoZone()), neighborResult.getNeighborAddress());
assertEquals(expectedAfiSafis, neighborResult.getAfiSafis());
assertEquals(expectedErrorHandling, neighborResult.getErrorHandling());
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.Open;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.BgpParameters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.OptionalCapabilities;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.optional.capabilities.CParameters;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.optional.capabilities.c.parameters.As4BytesCapability;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
final List<BgpParameters> params = open.getBgpParameters();
if (params != null) {
for (final BgpParameters p : params) {
- for (final OptionalCapabilities oc : p.getOptionalCapabilities()) {
- if (oc.getCParameters() != null && oc.getCParameters().getAs4BytesCapability() != null) {
- return oc.getCParameters().getAs4BytesCapability().getAsNumber();
+ for (final OptionalCapabilities oc : p.nonnullOptionalCapabilities()) {
+ final CParameters cparams = oc.getCParameters();
+ if (cparams != null) {
+ final As4BytesCapability as4 = cparams.getAs4BytesCapability();
+ if (as4 != null) {
+ return as4.getAsNumber();
+ }
}
}
}
final List<BgpParameters> params = open.getBgpParameters();
if (params != null) {
for (final BgpParameters p : params) {
- for (final OptionalCapabilities oc : p.getOptionalCapabilities()) {
- if (oc.getCParameters() != null && oc.getCParameters().getBgpExtendedMessageCapability() != null) {
+ for (final OptionalCapabilities oc : p.nonnullOptionalCapabilities()) {
+ final CParameters cparams = oc.getCParameters();
+ if (cparams != null && cparams.getBgpExtendedMessageCapability() != null) {
return true;
}
}
package org.opendaylight.protocol.bgp.parser;
import com.google.common.annotations.Beta;
-import com.google.common.collect.ImmutableList;
-import java.util.List;
+import java.util.Map;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.optional.capabilities.CParameters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.optional.capabilities.CParametersBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.CParameters1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.CParameters1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.GracefulRestartCapability;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.GracefulRestartCapability.RestartFlags;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.graceful.restart.capability.TablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.SubsequentAddressFamily;
+import org.opendaylight.yangtools.yang.common.Uint16;
/**
* Utility class for dealing with Graceful Restart.
* GR capability advertizing inactive GR.
*/
public static final @NonNull GracefulRestartCapability EMPTY_GR_CAPABILITY = new GracefulRestartCapabilityBuilder()
- .setTables(ImmutableList.of())
.setRestartFlags(new RestartFlags(Boolean.FALSE))
- .setRestartTime(0)
+ .setRestartTime(Uint16.ZERO)
.build();
/**
* LLGR capability advertizing no tables.
*/
public static final @NonNull LlGracefulRestartCapability EMPTY_LLGR_CAPABILITY =
- new LlGracefulRestartCapabilityBuilder().setTables(ImmutableList.of()).build();
+ new LlGracefulRestartCapabilityBuilder().build();
private GracefulRestartUtil() {
}
@Beta
- public static @NonNull CParameters gracefulRestartCapability(final List<Tables> tables, final int restartTime,
- final boolean localRestarting) {
- return new CParametersBuilder().addAugmentation(CParameters1.class, new CParameters1Builder()
+ public static @NonNull CParameters gracefulRestartCapability(final Map<TablesKey, Tables> tables,
+ final int restartTime, final boolean localRestarting) {
+ return new CParametersBuilder().addAugmentation(new CParameters1Builder()
.setGracefulRestartCapability(new GracefulRestartCapabilityBuilder()
.setRestartFlags(new RestartFlags(localRestarting))
- .setRestartTime(restartTime)
+ .setRestartTime(Uint16.valueOf(restartTime))
.setTables(tables)
.build())
.build()).build();
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.OptionalCapabilitiesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.optional.capabilities.CParametersBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.optional.capabilities.c.parameters.As4BytesCapabilityBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.CParameters1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.CParameters1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.MultiprotocolCapabilityBuilder;
import org.opendaylight.yangtools.yang.common.Uint16;
public void testAsNumberUtil() {
final List<BgpParameters> params = new ArrayList<>();
final List<OptionalCapabilities> capas = new ArrayList<>();
- capas.add(new OptionalCapabilitiesBuilder().setCParameters(new CParametersBuilder().addAugmentation(
- CParameters1.class, new CParameters1Builder().setMultiprotocolCapability(
- new MultiprotocolCapabilityBuilder().build()).build()).build()).build());
+ capas.add(new OptionalCapabilitiesBuilder()
+ .setCParameters(new CParametersBuilder()
+ .addAugmentation(new CParameters1Builder()
+ .setMultiprotocolCapability(new MultiprotocolCapabilityBuilder().build())
+ .build())
+ .build())
+ .build());
capas.add(new OptionalCapabilitiesBuilder().setCParameters(
new CParametersBuilder().setAs4BytesCapability(new As4BytesCapabilityBuilder().setAsNumber(
new AsNumber(Uint32.valueOf(35))).build()).build()).build());
public void testBgpExtendedMessageUtil() {
final List<BgpParameters> params = new ArrayList<>();
final List<OptionalCapabilities> capas = new ArrayList<>();
- capas.add(new OptionalCapabilitiesBuilder().setCParameters(new CParametersBuilder().addAugmentation(
- CParameters1.class, new CParameters1Builder()
- .setMultiprotocolCapability(new MultiprotocolCapabilityBuilder()
- .build()).build()).build()).build());
+ capas.add(new OptionalCapabilitiesBuilder()
+ .setCParameters(new CParametersBuilder()
+ .addAugmentation(new CParameters1Builder()
+ .setMultiprotocolCapability(new MultiprotocolCapabilityBuilder().build())
+ .build())
+ .build())
+ .build());
capas.add(new OptionalCapabilitiesBuilder().setCParameters(
BgpExtendedMessageUtil.EXTENDED_MESSAGE_CAPABILITY).build());
params.add(new BgpParametersBuilder().setOptionalCapabilities(capas).build());
import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.common.netty.ByteBufUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
BGPError.VERSION_NOT_SUPPORTED);
}
final AsNumber as = new AsNumber(Uint32.valueOf(body.readUnsignedShort()));
- final int holdTime = body.readUnsignedShort();
- if (holdTime == 1 || holdTime == 2) {
+ final Uint16 holdTime = ByteBufUtils.readUint16(body);
+ if (Uint16.ONE.equals(holdTime) || Uint16.TWO.equals(holdTime)) {
throw new BGPDocumentedException("Hold time value not acceptable.", BGPError.HOLD_TIME_NOT_ACC);
}
final Ipv4AddressNoZone bgpId;
import io.netty.buffer.Unpooled;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import org.opendaylight.protocol.bgp.parser.BGPDocumentedException;
import org.opendaylight.protocol.bgp.parser.BGPParsingException;
import org.opendaylight.protocol.bgp.parser.spi.AddressFamilyRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.graceful.restart.capability.Tables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.graceful.restart.capability.Tables.AfiFlags;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.graceful.restart.capability.TablesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.graceful.restart.capability.TablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.SubsequentAddressFamily;
import org.opendaylight.yangtools.yang.common.Uint16;
this.safiReg = requireNonNull(safiReg);
}
- private void serializeTables(final List<Tables> tables, final ByteBuf bytes) {
+ private void serializeTables(final Map<TablesKey, Tables> tables, final ByteBuf bytes) {
if (tables == null) {
return;
}
- for (final Tables t : tables) {
+ for (final Tables t : tables.values()) {
final Class<? extends AddressFamily> afi = t.getAfi();
final Integer afival = this.afiReg.numberForClass(afi);
Preconditions.checkArgument(afival != null, "Unhandled address family " + afi);
}
private ByteBuf serializeCapability(final GracefulRestartCapability grace) {
- final List<Tables> tables = grace.getTables();
+ final Map<TablesKey, Tables> tables = grace.getTables();
final int tablesSize = tables != null ? tables.size() : 0;
final ByteBuf bytes = Unpooled.buffer(HEADER_SIZE + PER_AFI_SAFI_SIZE * tablesSize);
Uint16 time = grace.getRestartTime();
cb.setRestartFlags(new RestartFlags((flagBits & Byte.SIZE) != 0));
final int timer = ((buffer.readUnsignedByte() & TIMER_TOPBITS_MASK) << Byte.SIZE) + buffer.readUnsignedByte();
- cb.setRestartTime(timer);
+ cb.setRestartTime(Uint16.valueOf(timer));
final List<Tables> tables = new ArrayList<>();
while (buffer.readableBytes() != 0) {
import io.netty.buffer.Unpooled;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import org.opendaylight.protocol.bgp.parser.spi.AddressFamilyRegistry;
import org.opendaylight.protocol.bgp.parser.spi.CapabilityParser;
import org.opendaylight.protocol.bgp.parser.spi.CapabilitySerializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.LlGracefulRestartCapabilityBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.ll.graceful.restart.capability.Tables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.ll.graceful.restart.capability.TablesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.ll.graceful.restart.capability.TablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.SubsequentAddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.uint24.rev200104.Uint24;
}
private ByteBuf serializeCapability(final LlGracefulRestartCapability cap) {
- final List<Tables> tables = cap.getTables();
+ final Map<TablesKey, Tables> tables = cap.getTables();
if (tables == null || tables.isEmpty()) {
return Unpooled.EMPTY_BUFFER;
}
final ByteBuf buffer = Unpooled.buffer(PER_TABLE_SIZE * tables.size());
- for (Tables table : tables) {
+ for (Tables table : tables.values()) {
final Class<? extends AddressFamily> afi = table.getAfi();
final Class<? extends SubsequentAddressFamily> safi = table.getSafi();
final Integer afival = this.afiReg.numberForClass(afi);
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.List;
+import java.util.Map;
import org.opendaylight.protocol.bgp.parser.spi.AttributeSerializer;
import org.opendaylight.protocol.bgp.parser.spi.AttributeUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.path.attributes.Attributes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.path.attributes.attributes.UnrecognizedAttributes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.path.attributes.attributes.UnrecognizedAttributesKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public void serializeAttribute(final Attributes attributes, final ByteBuf byteAggregator) {
- final List<UnrecognizedAttributes> unrecognizedAttrs = attributes.getUnrecognizedAttributes();
+ final Map<UnrecognizedAttributesKey, UnrecognizedAttributes> unrecognizedAttrs =
+ attributes.getUnrecognizedAttributes();
if (unrecognizedAttrs == null) {
return;
}
- for (final UnrecognizedAttributes unrecognizedAttr : unrecognizedAttrs) {
+ for (final UnrecognizedAttributes unrecognizedAttr : unrecognizedAttrs.values()) {
LOG.trace("Serializing unrecognized attribute of type {}", unrecognizedAttr.getType());
int flags = AttributeUtil.OPTIONAL;
if (unrecognizedAttr.isPartial()) {
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotSame;
+import com.google.common.collect.Maps;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
assertNotSame(tlv2.toString(), tlv3.toString());
- assertEquals(tlv3.getTables(), tt);
+ assertEquals(Maps.uniqueIndex(tt, Tables::key), tlv3.getTables());
assertEquals(cap.getSafi(), cap1.getSafi());
assertEquals(100, mo.getMyAsNumber().intValue());
assertEquals(180, mo.getHoldTimer().intValue());
assertEquals(new Ipv4Address("20.20.20.20"), mo.getBgpIdentifier());
- assertTrue(mo.getBgpParameters().isEmpty());
+ assertNull(mo.getBgpParameters());
}
@Test
import static org.junit.Assert.assertTrue;
import io.netty.buffer.Unpooled;
-import java.util.List;
+import java.util.Map;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
@Test
public void testUnrecognizedAttributes() throws BGPDocumentedException, BGPParsingException {
final byte[] attributeBytes = { (byte)0xe0, 0x00, 0x05, 0x01, 0x02, 0x03, 0x04, 0x05 };
- final List<UnrecognizedAttributes> unrecogAttribs = SIMPLE_ATTR_REG.parseAttributes(
+ final Map<UnrecognizedAttributesKey, UnrecognizedAttributes> unrecogAttribs = SIMPLE_ATTR_REG.parseAttributes(
Unpooled.wrappedBuffer(attributeBytes), null).getAttributes().getUnrecognizedAttributes();
assertEquals(UNRECOGNIZED_ATTRIBUTE_COUNT, unrecogAttribs.size());
- final UnrecognizedAttributes unrecogAttrib = unrecogAttribs.get(FIRST_ATTRIBUTE);
+ final UnrecognizedAttributes unrecogAttrib = unrecogAttribs.values().iterator().next();
final UnrecognizedAttributesKey expectedAttribKey =
new UnrecognizedAttributesKey(unrecogAttrib.getType());
<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.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-model-api</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-common</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-generator-impl</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<artifactId>odl-uint24</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-spec-util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-codec</artifactId>
+ <artifactId>mdsal-binding-dom-codec-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>netty-transport-native-epoll</artifactId>
<classifier>linux-x86_64</classifier>
</dependency>
-
- <!-- OSGi, FIXME: remove this -->
<dependency>
- <groupId>org.osgi</groupId>
- <artifactId>org.osgi.core</artifactId>
+ <groupId>javax.inject</groupId>
+ <artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
+ <optional>true</optional>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
<artifactId>osgi.cmpn</artifactId>
</dependency>
+ <!-- OSGi, FIXME: remove this -->
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.core</artifactId>
+ </dependency>
+
<!-- Testing dependencies -->
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>mdsal-dom-broker</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
}
final GracefulRestartCapability advertisedGracefulRestartCapability =
session.getAdvertisedGracefulRestartCapability();
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp
- .capabilities.graceful.restart.capability.Tables> advertisedTables =
- advertisedGracefulRestartCapability.getTables();
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp
- .capabilities.ll.graceful.restart.capability.Tables> advertisedLLTables =
- session.getAdvertisedLlGracefulRestartCapability().getTables();
+ final var advertisedTables = advertisedGracefulRestartCapability.getTables();
+ final var advertisedLLTables = session.getAdvertisedLlGracefulRestartCapability().getTables();
final List<AddressFamilies> addPathTablesType = session.getAdvertisedAddPathTableTypes();
final Set<BgpTableType> advertizedTableTypes = session.getAdvertisedTableTypes();
if (advertisedTables == null) {
forwardingTables = Collections.emptySet();
} else {
- forwardingTables = advertisedTables.stream()
+ forwardingTables = advertisedTables.values().stream()
.filter(table -> table.getAfiFlags() != null)
.filter(table -> table.getAfiFlags().isForwardingState())
.map(table -> new TablesKey(table.getAfi(), table.getSafi()))
if (advertisedTables == null || advertisedTables.isEmpty()) {
setAdvertizedGracefulRestartTableTypes(Collections.emptyList());
} else {
- setAdvertizedGracefulRestartTableTypes(advertisedTables.stream()
+ setAdvertizedGracefulRestartTableTypes(advertisedTables.values().stream()
.map(t -> new TablesKey(t.getAfi(), t.getSafi())).collect(Collectors.toList()));
}
setAfiSafiGracefulRestartState(advertisedGracefulRestartCapability.getRestartTime().toJava(), false,
final Map<TablesKey, Integer> llTablesReceived;
if (advertisedLLTables != null) {
llTablesReceived = new HashMap<>();
- for (org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp
- .capabilities.ll.graceful.restart.capability.Tables table : advertisedLLTables) {
+ for (var table : advertisedLLTables.values()) {
llTablesReceived.put(new TablesKey(table.getAfi(), table.getSafi()),
table.getLongLivedStaleTime().getValue().intValue());
}
final List<BgpParameters> bgpParameters = remoteOpen.getBgpParameters();
if (bgpParameters != null) {
for (final BgpParameters param : bgpParameters) {
- for (final OptionalCapabilities optCapa : param.getOptionalCapabilities()) {
+ for (final OptionalCapabilities optCapa : param.nonnullOptionalCapabilities()) {
final CParameters cParam = optCapa.getCParameters();
final CParameters1 cParam1 = cParam.augmentation(CParameters1.class);
if (cParam1 != null) {
*/
public static Update createEndOfRib(final TablesKey key) {
return key.getAfi() == Ipv4AddressFamily.class && key.getSafi() == UnicastSubsequentAddressFamily.class
- ? new UpdateBuilder().build() :
- new UpdateBuilder()
+ ? new UpdateBuilder().build() : new UpdateBuilder()
.setAttributes(new AttributesBuilder()
- .addAugmentation(Attributes2.class, new Attributes2Builder()
- .setMpUnreachNlri(new MpUnreachNlriBuilder()
- .setAfi(key.getAfi())
- .setSafi(key.getSafi())
- .build()).build()).build()).build();
+ .addAugmentation(new Attributes2Builder()
+ .setMpUnreachNlri(new MpUnreachNlriBuilder()
+ .setAfi(key.getAfi())
+ .setSafi(key.getSafi())
+ .build())
+ .build())
+ .build())
+ .build();
}
/**
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.protocol.bgp.rib.impl;
-
-import static java.util.Objects.requireNonNull;
-
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory;
-import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
-import org.opendaylight.protocol.bgp.rib.impl.spi.Codecs;
-import org.opendaylight.protocol.bgp.rib.impl.spi.CodecsRegistry;
-import org.opendaylight.protocol.bgp.rib.spi.RIBSupport;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public final class CodecsRegistryImpl implements CodecsRegistry {
-
- private static final Logger LOG = LoggerFactory.getLogger(CodecsRegistryImpl.class);
-
- private final LoadingCache<RIBSupport<?, ?, ?, ?>, Codecs> contexts = CacheBuilder.newBuilder()
- .build(new CacheLoader<RIBSupport<?, ?, ?, ?>, Codecs>() {
- @Override
- public Codecs load(final RIBSupport<?, ?, ?, ?> key) {
- return createContext(key);
- }
- });
- private final BindingCodecTreeFactory codecFactory;
- private final GeneratedClassLoadingStrategy classContext;
- private volatile BindingCodecTree latestCodecTree;
-
- private CodecsRegistryImpl(final BindingCodecTreeFactory codecFactory,
- final GeneratedClassLoadingStrategy strategy) {
- this.codecFactory = requireNonNull(codecFactory);
- this.classContext = requireNonNull(strategy);
- }
-
- public static CodecsRegistryImpl create(final BindingCodecTreeFactory codecFactory,
- final GeneratedClassLoadingStrategy classStrategy) {
- return new CodecsRegistryImpl(codecFactory, classStrategy);
- }
-
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
- private Codecs createContext(final RIBSupport<?, ?, ?, ?> ribSupport) {
- final Codecs codecs = new CodecsImpl(ribSupport);
- if (this.latestCodecTree != null) {
- // FIXME: Do we need to recalculate latestCodecTree? E.g. new rib support was added
- // after bgp was started.
- codecs.onCodecTreeUpdated(this.latestCodecTree);
- }
- return codecs;
- }
-
- @SuppressWarnings("checkstyle:illegalCatch")
- void onSchemaContextUpdated(final SchemaContext context) {
- final BindingRuntimeContext runtimeContext = BindingRuntimeContext.create(this.classContext, context);
- this.latestCodecTree = this.codecFactory.create(runtimeContext);
- for (final Codecs codecs : this.contexts.asMap().values()) {
- try {
- codecs.onCodecTreeUpdated(this.latestCodecTree);
- } catch (final Exception e) {
- LOG.error("Failed to propagate SchemaContext to codec {}", codecs, e);
- }
- }
- }
-
- @Override
- public Codecs getCodecs(final RIBSupport<?, ?, ?, ?> ribSupport) {
- return this.contexts.getUnchecked(ribSupport);
- }
-}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.protocol.bgp.rib.impl;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
+import org.opendaylight.protocol.bgp.rib.impl.spi.Codecs;
+import org.opendaylight.protocol.bgp.rib.impl.spi.CodecsRegistry;
+import org.opendaylight.protocol.bgp.rib.spi.RIBSupport;
+
+@Singleton
+public final class ConstantCodecsRegistry implements CodecsRegistry {
+ private final ConcurrentMap<RIBSupport<?, ?, ?, ?>, Codecs> contexts = new ConcurrentHashMap<>();
+ private final BindingCodecTree codecTree;
+
+ @Inject
+ public ConstantCodecsRegistry(final BindingCodecTree codecTree) {
+ this.codecTree = requireNonNull(codecTree);
+ }
+
+ @Override
+ public Codecs getCodecs(final RIBSupport<?, ?, ?, ?> ribSupport) {
+ return contexts.computeIfAbsent(ribSupport, this::createCodecs);
+ }
+
+ private Codecs createCodecs(final RIBSupport<?, ?, ?, ?> key) {
+ final Codecs codecs = new CodecsImpl(key);
+ codecs.onCodecTreeUpdated(codecTree);
+ return codecs;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.protocol.bgp.rib.impl;
+
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.annotations.Beta;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
+import org.opendaylight.protocol.bgp.rib.impl.spi.Codecs;
+import org.opendaylight.protocol.bgp.rib.impl.spi.CodecsRegistry;
+import org.opendaylight.protocol.bgp.rib.spi.RIBSupport;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ReferencePolicy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Beta
+@Component(immediate = true)
+public final class OSGiCodecsRegistry implements CodecsRegistry {
+ private static final Logger LOG = LoggerFactory.getLogger(OSGiCodecsRegistry.class);
+
+ private final ConcurrentMap<RIBSupport<?, ?, ?, ?>, Codecs> contexts = new ConcurrentHashMap<>();
+ private volatile BindingCodecTree codecTree;
+
+ @Override
+ public Codecs getCodecs(final RIBSupport<?, ?, ?, ?> ribSupport) {
+ return contexts.computeIfAbsent(ribSupport, this::createCodecs);
+ }
+
+ @Reference(policy = ReferencePolicy.DYNAMIC)
+ void bindCodecTree(final BindingCodecTree newCodecTree) {
+ this.codecTree = requireNonNull(newCodecTree);
+ }
+
+ void unbindCodecTree(final BindingCodecTree unused) {
+ this.codecTree = null;
+ }
+
+ void updatedCodecTree(final BindingCodecTree newCodecTree) {
+ this.codecTree = requireNonNull(newCodecTree);
+ contexts.values().forEach(codecs -> codecs.onCodecTreeUpdated(newCodecTree));
+ }
+
+ @Activate
+ @SuppressWarnings("static-method")
+ void activate() {
+ LOG.info("BGP codec registry started");
+ }
+
+ @Deactivate
+ void deactivate() {
+ contexts.clear();
+ LOG.info("BGP codec registry stopped");
+ }
+
+ private Codecs createCodecs(final RIBSupport<?, ?, ?, ?> key) {
+ final Codecs codecs = new CodecsImpl(key);
+ codecs.onCodecTreeUpdated(codecTree);
+ return codecs;
+ }
+}
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// This class is thread-safe
public final class RIBImpl extends BGPRibStateImpl implements RIB, TransactionChainListener,
- DOMTransactionChainListener, SchemaContextListener, AutoCloseable {
+ DOMTransactionChainListener, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(RIBImpl.class);
private static final QName RIB_ID_QNAME = QName.create(Rib.QNAME, "id").intern();
private final RIBExtensionConsumerContext extensions;
private final YangInstanceIdentifier yangRibId;
private final RIBSupportContextRegistryImpl ribContextRegistry;
- private final CodecsRegistryImpl codecsRegistry;
+ private final CodecsRegistry codecsRegistry;
private final BGPTableTypeRegistryConsumer tableTypeRegistry;
private final DOMDataBrokerExtension domService;
private final Map<TransactionChain, LocRibWriter> txChainToLocRibWriter = new HashMap<>();
final BgpId localBgpId,
final RIBExtensionConsumerContext extensions,
final BGPDispatcher dispatcher,
- final CodecsRegistryImpl codecsRegistry,
+ final CodecsRegistry codecsRegistry,
final DOMDataBroker domDataBroker,
final DataBroker dataBroker,
final BGPRibRoutingPolicy ribPolicies,
return this.ribContextRegistry;
}
- @Override
- public void onGlobalContextUpdated(final SchemaContext context) {
- this.codecsRegistry.onSchemaContextUpdated(context);
- }
-
@Override
public CodecsRegistry getCodecsRegistry() {
return this.codecsRegistry;
if (extPeerGroups == null) {
return;
}
- for (final PeerGroup peerGroup : extPeerGroups.getPeerGroup()) {
+ for (final PeerGroup peerGroup : extPeerGroups.nonnullPeerGroup().values()) {
this.bgpCss.values().forEach(css -> css.restartNeighbors(peerGroup.getPeerGroupName()));
}
}
import io.netty.util.concurrent.Future;
import java.net.InetSocketAddress;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
caps.add(new OptionalCapabilitiesBuilder()
.setCParameters(MultiprotocolCapabilitiesUtil.RR_CAPABILITY).build());
- final List<AfiSafi> afiSafi = OpenConfigMappingUtil.getAfiSafiWithDefault(afiSafis, false);
- final List<AddressFamilies> addPathCapability = OpenConfigMappingUtil
- .toAddPathCapability(afiSafi, tableTypeRegistry);
+ final Collection<AfiSafi> afiSafi = OpenConfigMappingUtil.getAfiSafiWithDefault(afiSafis, false).values();
+ final List<AddressFamilies> addPathCapability = OpenConfigMappingUtil.toAddPathCapability(afiSafi,
+ tableTypeRegistry);
if (!addPathCapability.isEmpty()) {
caps.add(new OptionalCapabilitiesBuilder()
.setCParameters(new CParametersBuilder().addAugmentation(CParameters1.class,
}
final AfiSafis actAfiSafi = this.currentConfiguration.getAfiSafis();
final AfiSafis extAfiSafi = neighbor.getAfiSafis();
- final List<AfiSafi> actualSafi = actAfiSafi != null ? actAfiSafi.getAfiSafi() : Collections.emptyList();
- final List<AfiSafi> extSafi = extAfiSafi != null ? extAfiSafi.getAfiSafi() : Collections.emptyList();
+ final Collection<AfiSafi> actualSafi = actAfiSafi != null ? actAfiSafi.nonnullAfiSafi().values()
+ : Collections.emptyList();
+ final Collection<AfiSafi> extSafi = extAfiSafi != null ? extAfiSafi.nonnullAfiSafi().values()
+ : Collections.emptyList();
return actualSafi.containsAll(extSafi) && extSafi.containsAll(actualSafi)
&& Objects.equals(this.currentConfiguration.getConfig(), neighbor.getConfig())
&& Objects.equals(this.currentConfiguration.getNeighborAddress(), neighbor.getNeighborAddress())
afisSafis = requireNonNull(neighbor.getAfiSafis(), "Missing mandatory AFIs/SAFIs");
}
- final Set<TablesKey> afiSafisAdvertized = OpenConfigMappingUtil
- .toTableKey(afisSafis.getAfiSafi(), tableTypeRegistry);
+ final Set<TablesKey> afiSafisAdvertized = OpenConfigMappingUtil.toTableKey(afisSafis.getAfiSafi(),
+ tableTypeRegistry);
final PeerRole role = OpenConfigMappingUtil.toPeerRole(neighbor, peerGroup);
final ClusterIdentifier clusterId = OpenConfigMappingUtil
final int hold = OpenConfigMappingUtil.getHoldTimer(neighbor, peerGroup);
this.gracefulRestartTimer = OpenConfigMappingUtil.getGracefulRestartTimer(neighbor,
peerGroup, hold);
- final Set<TablesKey> gracefulTables = GracefulRestartUtil.getGracefulTables(afisSafis.getAfiSafi(),
- tableTypeRegistry);
- final Map<TablesKey, Integer> llGracefulTimers = GracefulRestartUtil
- .getLlGracefulTimers(afisSafis.getAfiSafi(), tableTypeRegistry);
+ final Set<TablesKey> gracefulTables = GracefulRestartUtil.getGracefulTables(
+ afisSafis.nonnullAfiSafi().values(), tableTypeRegistry);
+ final Map<TablesKey, Integer> llGracefulTimers = GracefulRestartUtil.getLlGracefulTimers(
+ afisSafis.nonnullAfiSafi().values(), tableTypeRegistry);
this.finalCapabilities = getBgpCapabilities(afisSafis, rib, tableTypeRegistry);
final List<BgpParameters> bgpParameters = getInitialBgpParameters(gracefulTables, llGracefulTimers);
final KeyMapping keyMapping = OpenConfigMappingUtil.getNeighborKey(neighbor);
import com.google.common.collect.Maps;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
+import java.util.function.Function;
import java.util.stream.Collectors;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.rib.impl.BgpPeerUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.ll.graceful.restart.capability.TablesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.uint24.rev200104.Uint24;
+import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final TablesKey key = entry.getKey();
return gracefulRestartTable(key.getAfi(), key.getSafi(), entry.getValue());
})
- .collect(Collectors.toList()), restartTime, localRestarting);
+ .collect(Collectors.toMap(Identifiable::key, Function.identity())), restartTime, localRestarting);
}
public static CParameters getLlGracefulCapability(final Set<BgpPeerUtil.LlGracefulRestartDTO> llGracefulRestarts) {
.build()).build()).build();
}
- static Set<TablesKey> getGracefulTables(final List<AfiSafi> afiSafis,
+ static Set<TablesKey> getGracefulTables(final Collection<? extends AfiSafi> afiSafis,
final BGPTableTypeRegistryConsumer tableTypeRegistry) {
Set<TablesKey> gracefulTables = new HashSet<>();
for (final AfiSafi afiSafi : afiSafis) {
- if (afiSafi.getGracefulRestart() != null
- && afiSafi.getGracefulRestart().getConfig() != null
- && afiSafi.getGracefulRestart().getConfig().isEnabled()) {
- final Class<? extends AfiSafiType> afiSafiName = afiSafi.getAfiSafiName();
- if (afiSafiName != null) {
- final Optional<TablesKey> tableKey = tableTypeRegistry.getTableKey(afiSafiName);
- if (tableKey.isPresent()) {
- final TablesKey tablesKey = tableKey.get();
- gracefulTables.add(tablesKey);
+ final GracefulRestart gr = afiSafi.getGracefulRestart();
+ if (gr != null) {
+ final Config config = gr.getConfig();
+ if (config != null && Boolean.TRUE.equals(config.isEnabled())) {
+ final Class<? extends AfiSafiType> afiSafiName = afiSafi.getAfiSafiName();
+ if (afiSafiName != null) {
+ final Optional<TablesKey> tableKey = tableTypeRegistry.getTableKey(afiSafiName);
+ if (tableKey.isPresent()) {
+ final TablesKey tablesKey = tableKey.get();
+ gracefulTables.add(tablesKey);
+ }
}
}
}
return gracefulTables;
}
- static Map<TablesKey, Integer> getLlGracefulTimers(final List<AfiSafi> afiSafis,
+ static Map<TablesKey, Integer> getLlGracefulTimers(final Collection<? extends AfiSafi> afiSafis,
final BGPTableTypeRegistryConsumer tableTypeRegistry) {
final Map<TablesKey, Integer> timers = new HashMap<>();
afiSafis.forEach(afiSafi -> {
import static com.google.common.base.Preconditions.checkState;
import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil.INSTANCE;
-import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
+import java.util.function.Function;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.multiprotocol.rev151009.BgpCommonAfiSafiList;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.multiprotocol.rev151009.bgp.common.afi.safi.list.AfiSafi;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.multiprotocol.rev151009.bgp.common.afi.safi.list.AfiSafiBuilder;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.multiprotocol.rev151009.bgp.common.afi.safi.list.AfiSafiKey;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.BgpNeighborAddPathsConfig;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.BgpNeighborGroup;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.BgpNeighborTransportConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.PeerRole;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.ClusterIdentifier;
-import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint16;
static final Optional<String> APPLICATION_PEER_GROUP_NAME_OPT = Optional.of(APPLICATION_PEER_GROUP_NAME);
static final int HOLDTIMER = 90;
private static final AfiSafi IPV4_AFISAFI = new AfiSafiBuilder().setAfiSafiName(IPV4UNICAST.class).build();
- private static final List<AfiSafi> DEFAULT_AFISAFI = ImmutableList.of(IPV4_AFISAFI);
+ private static final Map<AfiSafiKey, AfiSafi> DEFAULT_AFISAFI = ImmutableMap.of(IPV4_AFISAFI.key(), IPV4_AFISAFI);
private static final int CONNECT_RETRY = 30;
private static final PortNumber PORT = new PortNumber(Uint16.valueOf(179).intern());
}
//make sure IPv4 Unicast (RFC 4271) when required
- static List<AfiSafi> getAfiSafiWithDefault(
+ static Map<AfiSafiKey, AfiSafi> getAfiSafiWithDefault(
final BgpCommonAfiSafiList afiSAfis, final boolean setDeafultIPv4) {
if (afiSAfis == null || afiSAfis.getAfiSafi() == null) {
- return setDeafultIPv4 ? DEFAULT_AFISAFI : Collections.emptyList();
- }
- final List<AfiSafi> afiSafi = afiSAfis.getAfiSafi();
- if (setDeafultIPv4) {
- final boolean anyMatch = afiSafi.stream()
- .anyMatch(input -> input.getAfiSafiName().equals(IPV4UNICAST.class));
- if (!anyMatch) {
- final List<AfiSafi> newAfiSafi = new ArrayList<>(afiSafi.size() + 1);
- newAfiSafi.addAll(afiSafi);
- newAfiSafi.add(IPV4_AFISAFI);
- return newAfiSafi;
- }
+ return setDeafultIPv4 ? DEFAULT_AFISAFI : Collections.emptyMap();
+ }
+ final Map<AfiSafiKey, AfiSafi> afiSafi = afiSAfis.nonnullAfiSafi();
+ if (setDeafultIPv4 && !afiSafi.containsKey(IPV4_AFISAFI.key())) {
+ final Map<AfiSafiKey, AfiSafi> newAfiSafi = Maps.newHashMapWithExpectedSize(afiSafi.size() + 1);
+ newAfiSafi.putAll(afiSafi);
+ newAfiSafi.put(IPV4_AFISAFI.key(), IPV4_AFISAFI);
+ return newAfiSafi;
}
return afiSafi;
}
return null;
}
- static Map<BgpTableType, PathSelectionMode> toPathSelectionMode(final
List<AfiSafi> afiSafis,
+ static Map<BgpTableType, PathSelectionMode> toPathSelectionMode(final
Collection<AfiSafi> afiSafis,
final BGPTableTypeRegistryConsumer tableTypeRegistry) {
final Map<BgpTableType, PathSelectionMode> pathSelectionModes = new HashMap<>();
for (final AfiSafi afiSafi : afiSafis) {
return false;
}
- static List<AddressFamilies> toAddPathCapability(final
List<AfiSafi> afiSafis,
+ static List<AddressFamilies> toAddPathCapability(final
Collection<AfiSafi> afiSafis,
final BGPTableTypeRegistryConsumer tableTypeRegistry) {
final List<AddressFamilies> addPathCapability = new ArrayList<>();
for (final AfiSafi afiSafi : afiSafis) {
return false;
}
- static List<BgpTableType> toTableTypes(final
List<AfiSafi> afiSafis,
+ static List<BgpTableType> toTableTypes(final
Collection<AfiSafi> afiSafis,
final BGPTableTypeRegistryConsumer tableTypeRegistry) {
return afiSafis.stream()
.map(afiSafi -> tableTypeRegistry.getTableType(afiSafi.getAfiSafiName()))
.collect(Collectors.toList());
}
- static Set<TablesKey> toTableKey(final List<AfiSafi> afiSafis, final BGPTableTypeRegistryConsumer
+ static Set<TablesKey> toTableKey(final Map<AfiSafiKey, AfiSafi> afiSafis, final BGPTableTypeRegistryConsumer
tableTypeRegistry) {
- return afiSafis.stream()
+ return afiSafis.values().stream()
.map(afiSafi -> tableTypeRegistry.getTableKey(afiSafi.getAfiSafiName()))
.filter(Optional::isPresent)
.map(Optional::get)
static @NonNull PortNumber getPort(final Neighbor neighbor, final PeerGroup peerGroup) {
PortNumber port = null;
if (peerGroup != null) {
- port = getPort(peerGroup.getTransport(), PeerGroupTransportConfig.class);
+ port = getPort(peerGroup.getTransport(), config -> config.augmentation(PeerGroupTransportConfig.class));
}
if (port == null) {
- port = getPort(neighbor.getTransport(), NeighborTransportConfig.class);
+ port = getPort(neighbor.getTransport(), config -> config.augmentation(NeighborTransportConfig.class));
}
if (port == null) {
return port;
}
- private static <T extends TransportConfig & Augmentation<Config>> @Nullable PortNumber getPort(
- final @Nullable Transport transport, final Class<T> augment) {
+ private static @Nullable PortNumber getPort(final @Nullable Transport transport,
+ final Function<Config, TransportConfig> extractConfig) {
if (transport != null) {
final Config config = transport.getConfig();
if (config != null) {
- final T peerTc = config.augmentation(augment);
+ final TransportConfig peerTc = extractConfig.apply(config);
if (peerTc != null) {
return peerTc.getRemotePort();
}
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FluentFuture;
-import java.util.List;
+import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.TransactionChain;
import org.opendaylight.mdsal.binding.api.TransactionChainListener;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
-import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode;
import org.opendaylight.protocol.bgp.openconfig.routing.policy.spi.BGPRibRoutingPolicyFactory;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
-import org.opendaylight.protocol.bgp.rib.impl.CodecsRegistryImpl;
import org.opendaylight.protocol.bgp.rib.impl.RIBImpl;
import org.opendaylight.protocol.bgp.rib.impl.spi.BGPDispatcher;
import org.opendaylight.protocol.bgp.rib.impl.spi.CodecsRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.BgpId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.ClusterIdentifier;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
import org.osgi.framework.ServiceRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final RIBExtensionConsumerContext extensions;
private final BGPDispatcher dispatcher;
- private final BindingCodecTreeFactory codecTreeFactory;
+ private final CodecsRegistry codecsRegistry;
private final DOMDataBroker domBroker;
- private final DOMSchemaService domSchemaService;
private final BGPRibRoutingPolicyFactory policyProvider;
private RIBImpl ribImpl;
private ServiceRegistration<?> serviceRegistration;
- private ListenerRegistration<SchemaContextListener> schemaContextRegistration;
- private List<AfiSafi> afiSafi;
+ private Collection<AfiSafi> afiSafi;
private AsNumber asNumber;
private Ipv4AddressNoZone routerId;
final RIBExtensionConsumerContext contextProvider,
final BGPDispatcher dispatcher,
final BGPRibRoutingPolicyFactory policyProvider,
- final BindingCodecTreeFactory codecTreeFactory,
+ final CodecsRegistry codecsRegistry,
final DOMDataBroker domBroker,
- final DataBroker dataBroker,
- final DOMSchemaService domSchemaService
+ final DataBroker dataBroker
) {
this.extensions = contextProvider;
this.dispatcher = dispatcher;
- this.codecTreeFactory = codecTreeFactory;
+ this.codecsRegistry = codecsRegistry;
this.domBroker = domBroker;
this.dataBroker = dataBroker;
- this.domSchemaService = domSchemaService;
this.policyProvider = policyProvider;
}
Preconditions.checkState(this.ribImpl == null,
"Previous instance %s was not closed.", this);
this.ribImpl = createRib(global, instanceName, tableTypeRegistry);
- this.schemaContextRegistration = this.domSchemaService.registerSchemaContextListener(this.ribImpl);
}
Boolean isGlobalEqual(final Global global) {
- final List<AfiSafi> globalAfiSafi = getAfiSafiWithDefault(global.getAfiSafis(), true);
+ final Collection<AfiSafi> globalAfiSafi = getAfiSafiWithDefault(global.getAfiSafis(), true).values();
final Config globalConfig = global.getConfig();
final AsNumber globalAs = globalConfig.getAs();
final Ipv4Address globalRouterId = global.getConfig().getRouterId();
this.ribImpl.close();
this.ribImpl = null;
}
- if (this.schemaContextRegistration != null) {
- this.schemaContextRegistration.close();
- this.schemaContextRegistration = null;
- }
if (this.serviceRegistration != null) {
try {
this.serviceRegistration.unregister();
final Global global,
final String bgpInstanceName,
final BGPTableTypeRegistryConsumer tableTypeRegistry) {
- this.afiSafi = getAfiSafiWithDefault(global.getAfiSafis(), true);
+ this.afiSafi = getAfiSafiWithDefault(global.getAfiSafis(), true).values();
final Config globalConfig = global.getConfig();
this.asNumber = globalConfig.getAs();
this.routerId = IetfInetUtil.INSTANCE.ipv4AddressNoZoneFor(globalConfig.getRouterId());
final BGPRibRoutingPolicy ribPolicy = this.policyProvider.buildBGPRibPolicy(this.asNumber.getValue().toJava(),
this.routerId, this.clusterId, RoutingPolicyUtil.getApplyPolicy(global.getApplyPolicy()));
- final CodecsRegistryImpl codecsRegistry = CodecsRegistryImpl.create(codecTreeFactory,
- this.extensions.getClassLoadingStrategy());
return new RIBImpl(
tableTypeRegistry,
@Override
public synchronized void advertizeCapabilities(final int newHoldTimerValue, final SocketAddress newRemoteAddress,
final SocketAddress localAddress, final Set<BgpTableType> tableTypes, final List<BgpParameters> bgpParameters) {
- if (bgpParameters != null && !bgpParameters.isEmpty()) {
+ if (bgpParameters != null) {
for (final BgpParameters parameters : bgpParameters) {
- for (final OptionalCapabilities optionalCapabilities : parameters.getOptionalCapabilities()) {
+ for (final OptionalCapabilities optionalCapabilities : parameters.nonnullOptionalCapabilities()) {
final CParameters cParam = optionalCapabilities.getCParameters();
final CParameters1 capabilities = cParam.augmentation(CParameters1.class);
if (capabilities != null) {
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.ipv4.prefixes.destination.ipv4.Ipv4PrefixesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.ipv4.routes.Ipv4Routes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.ipv4.routes.ipv4.routes.Ipv4Route;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.ipv4.routes.ipv4.routes.Ipv4RouteKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.update.attributes.mp.reach.nlri.advertized.routes.destination.type.DestinationIpv4CaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.NotifyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.Open;
private NioEventLoopGroup boss;
private org.opendaylight.protocol.bgp.inet.BGPActivator inetActivator;
protected StrictBGPPeerRegistry serverRegistry;
- protected CodecsRegistryImpl codecsRegistry;
+ protected ConstantCodecsRegistry codecsRegistry;
private List<BGPDispatcherImpl> clientDispatchers;
this.ribActivator = new RIBActivator();
this.ribExtension = new SimpleRIBExtensionProviderContext();
- this.ribActivator.startRIBExtensionProvider(this.ribExtension, this.mappingService);
+ this.ribActivator.startRIBExtensionProvider(this.ribExtension, this.mappingService.currentSerializer());
this.bgpActivator = new BGPActivator();
this.inetActivator = new org.opendaylight.protocol.bgp.inet.BGPActivator();
doReturn(Mockito.mock(ClusterSingletonServiceRegistration.class)).when(this.clusterSingletonServiceProvider)
.registerClusterSingletonService(any(ClusterSingletonService.class));
- this.codecsRegistry = CodecsRegistryImpl.create(this.mappingService.getCodecFactory(),
- this.ribExtension.getClassLoadingStrategy());
+ this.codecsRegistry = new ConstantCodecsRegistry(mappingService.currentSerializer());
this.clientDispatchers = new ArrayList<>();
}
this.worker.shutdownGracefully(0, 0, TimeUnit.SECONDS);
this.boss.shutdownGracefully(0, 0, TimeUnit.SECONDS);
}
- this.mappingService.close();
this.ribActivator.close();
this.inetActivator.close();
this.bgpActivator.close();
// FIXME: remove this sleep
Thread.sleep(100);
readDataOperational(getDataBroker(), BGP_IID, bgpRib -> {
- final Ipv4RoutesCase routes = (Ipv4RoutesCase) bgpRib.getRib().get(0).getLocRib().getTables().get(0)
- .getRoutes();
+ final Ipv4RoutesCase routes = (Ipv4RoutesCase) bgpRib.getRib().values().iterator().next().getLocRib()
+ .getTables().values().iterator().next().getRoutes();
final int size;
if (routes != null) {
final Ipv4Routes routesCase = routes.getIpv4Routes();
if (routesCase != null) {
- final List<Ipv4Route> routeList = routesCase.getIpv4Route();
+ final Map<Ipv4RouteKey, Ipv4Route> routeList = routesCase.getIpv4Route();
size = routeList == null ? 0 : routeList.size();
} else {
size = 0;
void checkPeersPresentOnDataStore(final int numberOfPeers) throws Exception {
readDataOperational(getDataBroker(), BGP_IID, bgpRib -> {
- Assert.assertEquals(numberOfPeers, bgpRib.getRib().get(0).getPeer().size());
+ Assert.assertEquals(numberOfPeers, bgpRib.getRib().values().iterator().next().getPeer().size());
return bgpRib;
});
}
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.api.TransactionChain;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
-import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
-import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
+import org.opendaylight.mdsal.binding.dom.adapter.CurrentAdapterSerializer;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener;
import org.opendaylight.protocol.bgp.parser.BgpTableTypeImpl;
import org.opendaylight.protocol.bgp.rib.impl.spi.BGPDispatcher;
import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionProviderContext;
-import org.opendaylight.protocol.bgp.rib.spi.RIBSupport;
import org.opendaylight.protocol.bgp.rib.spi.SimpleRIBExtensionProviderContext;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public class AbstractRIBTestSetup extends DefaultRibPoliciesMockTest {
static final QName PREFIX_QNAME = QName.create(Ipv4Route.QNAME, "prefix").intern();
private static final BgpId RIB_ID = new BgpId("127.0.0.1");
private RIBImpl rib;
- private BindingCodecTreeFactory codecFactory;
private RIBActivator a1;
- private RIBSupport<?, ?, ?, ?> ribSupport;
@Mock
private BGPDispatcher dispatcher;
@Mock
private ClusterSingletonServiceProvider clusterSingletonServiceProvider;
- private static ModuleInfoBackedContext createClassLoadingStrategy() throws Exception {
- final ModuleInfoBackedContext ctx = ModuleInfoBackedContext.create();
- ctx.registerModuleInfo(BindingReflections.getModuleInfo(Ipv4Route.class));
- return ctx;
- }
-
@Override
@Before
public void setUp() throws Exception {
public void mockRib() throws Exception {
final RIBExtensionProviderContext context = new SimpleRIBExtensionProviderContext();
- final ModuleInfoBackedContext strategy = createClassLoadingStrategy();
- final SchemaContext schemaContext = strategy.tryToCreateSchemaContext().get();
- this.codecFactory = new BindingNormalizedNodeCodecRegistry(
- BindingRuntimeContext.create(strategy, schemaContext));
final List<BgpTableType> localTables = new ArrayList<>();
localTables.add(new BgpTableTypeImpl(IPV4_AFI, SAFI));
localTables.add(new BgpTableTypeImpl(IPV6_AFI, SAFI));
+ final CurrentAdapterSerializer serializer = mappingService.currentSerializer();
this.a1 = new RIBActivator();
- this.a1.startRIBExtensionProvider(context, this.mappingService);
-
- final CodecsRegistryImpl codecsRegistry = CodecsRegistryImpl.create(this.codecFactory,
- GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy());
+ this.a1.startRIBExtensionProvider(context, serializer);
mockedMethods();
doReturn(mock(ClusterSingletonServiceRegistration.class)).when(this.clusterSingletonServiceProvider)
.registerClusterSingletonService(any(ClusterSingletonService.class));
this.rib = new RIBImpl(this.tableRegistry, new RibId("test"), new AsNumber(Uint32.valueOf(5)), RIB_ID, context,
- this.dispatcher, codecsRegistry, this.dom, getDataBroker(), this.policies,
+ this.dispatcher, new ConstantCodecsRegistry(serializer), this.dom, getDataBroker(), this.policies,
localTables, Collections.singletonMap(KEY,
BasePathSelectionModeFactory.createBestPathSelectionStrategy()));
- this.rib.onGlobalContextUpdated(schemaContext);
- this.ribSupport = getRib().getRibSupportContext().getRIBSupport(KEY);
}
@SuppressWarnings("unchecked")
doReturn(Optional.empty()).when(this.future).get();
doReturn(this.future).when(this.domTransWrite).commit();
doNothing().when(this.future).addListener(any(Runnable.class), any(Executor.class));
- doNothing().when(this.transWrite).put(eq(LogicalDatastoreType.OPERATIONAL),
- any(InstanceIdentifier.class), any(DataObject.class), eq(true));
+ doNothing().when(this.transWrite).mergeParentStructurePut(eq(LogicalDatastoreType.OPERATIONAL),
+ any(InstanceIdentifier.class), any(DataObject.class));
doNothing().when(this.transWrite).put(eq(LogicalDatastoreType.OPERATIONAL),
any(InstanceIdentifier.class), any(DataObject.class));
doReturn(this.future).when(this.transWrite).commit();
getDomBroker(), getDataBroker(), this.policies, TABLES_TYPE, pathTables);
this.ribImpl.instantiateServiceInstance();
- this.ribImpl.onGlobalContextUpdated(this.schemaService.getGlobalContext());
final ChannelFuture channelFuture = this.serverDispatcher.createServer(
new InetSocketAddress(RIB_ID, PORT.toJava()));
waitFutureSuccess(channelFuture);
this.serverDispatcher, this.codecsRegistry, getDomBroker(), getDataBroker(), this.policies,
TABLES_TYPE, pathTables);
this.ribImpl.instantiateServiceInstance();
- this.ribImpl.onGlobalContextUpdated(this.schemaService.getGlobalContext());
final ChannelFuture channelFuture = this.serverDispatcher.createServer(
new InetSocketAddress(RIB_ID, PORT.toJava()));
waitFutureSuccess(channelFuture);
* 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.protocol.bgp.rib.impl;
import static org.junit.Assert.assertEquals;
TABLES_TYPE, pathTables);
this.ribImpl.instantiateServiceInstance();
- this.ribImpl.onGlobalContextUpdated(this.schemaService.getGlobalContext());
final ChannelFuture channelFuture = this.serverDispatcher.createServer(
new InetSocketAddress(RIB_ID, PORT.toJava()));
waitFutureSuccess(channelFuture);
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoop;
-import io.netty.channel.embedded.EmbeddedChannel;
import io.netty.util.concurrent.GlobalEventExecutor;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.ProtocolVersion;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.Update;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.UpdateBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.BgpParameters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.BgpParametersBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.OptionalCapabilities;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.OptionalCapabilitiesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.optional.capabilities.CParametersBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.optional.capabilities.c.parameters.As4BytesCapabilityBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.BgpTableType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.CParameters1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.CParameters1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.GracefulRestartCapabilityBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.MultiprotocolCapabilityBuilder;
@Before
public void setUp() throws UnknownHostException {
- new EmbeddedChannel();
MockitoAnnotations.initMocks(this);
- final List<BgpParameters> tlvs = new ArrayList<>();
- this.classicOpen = new OpenBuilder()
- .setMyAsNumber(Uint16.valueOf(AS_NUMBER.getValue()))
- .setHoldTimer(HOLD_TIMER)
- .setVersion(new ProtocolVersion(Uint8.valueOf(4)))
- .setBgpParameters(tlvs)
- .setBgpIdentifier(BGP_ID)
- .build();
final List<OptionalCapabilities> capa = new ArrayList<>();
capa.add(new OptionalCapabilitiesBuilder().setCParameters(new CParametersBuilder()
- .addAugmentation(CParameters1.class, new CParameters1Builder()
+ .addAugmentation(new CParameters1Builder()
.setMultiprotocolCapability(new MultiprotocolCapabilityBuilder()
.setAfi(this.ipv4tt.getAfi()).setSafi(this.ipv4tt.getSafi()).build())
.setGracefulRestartCapability(new GracefulRestartCapabilityBuilder().build()).build())
.setAs4BytesCapability(new As4BytesCapabilityBuilder().setAsNumber(AS_NUMBER).build()).build()).build());
capa.add(new OptionalCapabilitiesBuilder().setCParameters(BgpExtendedMessageUtil.EXTENDED_MESSAGE_CAPABILITY)
.build());
- tlvs.add(new BgpParametersBuilder().setOptionalCapabilities(capa).build());
+
+ this.classicOpen = new OpenBuilder()
+ .setMyAsNumber(Uint16.valueOf(AS_NUMBER.getValue()))
+ .setHoldTimer(HOLD_TIMER)
+ .setVersion(new ProtocolVersion(Uint8.valueOf(4)))
+ .setBgpParameters(List.of(new BgpParametersBuilder().setOptionalCapabilities(capa).build()))
+ .setBgpIdentifier(BGP_ID)
+ .build();
final ChannelFuture f = mock(ChannelFuture.class);
doReturn(null).when(f).addListener(any());
import java.util.Collections;
import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.Update;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.UpdateBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.path.attributes.Attributes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.path.attributes.AttributesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.update.message.NlriBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.Attributes2;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.Attributes2Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.update.attributes.MpUnreachNlri;
.build();
final Update ipv6EOT = new UpdateBuilder()
.setAttributes(new AttributesBuilder()
- .addAugmentation(Attributes2.class, new Attributes2Builder()
- .setMpUnreachNlri(ipv6EOTnlri)
- .build())
- .build())
+ .addAugmentation(new Attributes2Builder().setMpUnreachNlri(ipv6EOTnlri).build())
+ .build())
.build();
assertTrue(BgpPeerUtil.isEndOfRib(ipv4EOT));
assertTrue(BgpPeerUtil.isEndOfRib(ipv6EOT));
final Update ipv4NonEOT = new UpdateBuilder()
- .setNlri(Collections.emptyList())
+ .setNlri(Collections.singletonList(new NlriBuilder().setPrefix(new Ipv4Prefix("0.0.0.0/32")).build()))
.build();
final MpUnreachNlri ipv6NonEOTnlri = new MpUnreachNlriBuilder(ipv6EOTnlri)
.setWithdrawnRoutes(new WithdrawnRoutesBuilder().build())
.build();
final Update ipv6NonEOT = new UpdateBuilder()
.setAttributes(new AttributesBuilder()
- .addAugmentation(Attributes2.class, new Attributes2Builder()
- .setMpUnreachNlri(ipv6NonEOTnlri)
- .build())
- .build())
+ .addAugmentation(new Attributes2Builder().setMpUnreachNlri(ipv6NonEOTnlri).build())
+ .build())
.build();
assertFalse(BgpPeerUtil.isEndOfRib(ipv4NonEOT));
getDomBroker(), getDataBroker(), this.policies, tableTypes, pathTables);
this.ribImpl.instantiateServiceInstance();
- this.ribImpl.onGlobalContextUpdated(this.schemaService.getGlobalContext());
final ChannelFuture channelFuture = this.serverDispatcher.createServer(
new InetSocketAddress(RIB_ID, PORT.toJava()));
waitFutureSuccess(channelFuture);
package org.opendaylight.protocol.bgp.rib.impl;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
+import org.opendaylight.mdsal.binding.dom.adapter.CurrentAdapterSerializer;
import org.opendaylight.protocol.bgp.inet.RIBActivator;
import org.opendaylight.protocol.bgp.mode.impl.base.BasePathSelectionModeFactory;
import org.opendaylight.protocol.bgp.parser.BgpTableTypeImpl;
private RIBExtensionProviderContext ext2;
@Mock
private BGPDispatcher dispatcher;
- private CodecsRegistryImpl codecsRegistry;
+ private ConstantCodecsRegistry codecsRegistry;
@Override
@Before
this.baseact = new RIBActivator();
this.lsact = new org.opendaylight.protocol.bgp.linkstate.impl.RIBActivator();
- this.baseact.startRIBExtensionProvider(this.ext1, this.mappingService);
- this.lsact.startRIBExtensionProvider(this.ext2, this.mappingService);
- this.codecsRegistry = CodecsRegistryImpl.create(this.bindingCodecTreeFactory,
- GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy());
+ final CurrentAdapterSerializer serializer = mappingService.currentSerializer();
+ this.baseact.startRIBExtensionProvider(this.ext1, serializer);
+ this.lsact.startRIBExtensionProvider(this.ext2, serializer);
+ this.codecsRegistry = new ConstantCodecsRegistry(serializer);
}
@Override
.createBestPathSelectionStrategy()));
rib.instantiateServiceInstance();
assertTablesExists(tables);
- rib.onGlobalContextUpdated(this.schemaService.getGlobalContext());
final BGPPeer peer = AbstractAddPathTest.configurePeer(this.tableRegistry,
this.localAddress.getIpv4AddressNoZone(), rib, null, PeerRole.Ibgp, new StrictBGPPeerRegistry());
peer.instantiateServiceInstance();
tables, Collections.singletonMap(TABLE_KEY,
BasePathSelectionModeFactory.createBestPathSelectionStrategy()));
rib.instantiateServiceInstance();
- rib.onGlobalContextUpdated(this.schemaService.getGlobalContext());
assertTablesExists(tables);
final BGPPeer peer = AbstractAddPathTest.configurePeer(this.tableRegistry,
this.localAddress.getIpv4AddressNoZone(), rib, null, PeerRole.Ibgp, new StrictBGPPeerRegistry());
private void assertTablesExists(final List<BgpTableType> expectedTables) throws InterruptedException,
ExecutionException {
readDataOperational(getDataBroker(), BGP_IID, bgpRib -> {
- final List<Tables> tables = bgpRib.getRib().get(0).getLocRib().getTables();
- assertFalse(tables.isEmpty());
+ final var tables = bgpRib.getRib().values().iterator().next().getLocRib().getTables();
+ assertNotNull(tables);
for (final BgpTableType tableType : expectedTables) {
boolean found = false;
- for (final Tables table : tables) {
+ for (final Tables table : tables.values()) {
if (table.getAfi().equals(tableType.getAfi()) && table.getSafi().equals(tableType.getSafi())) {
found = true;
assertEquals(Boolean.TRUE, table.getAttributes().isUptodate());
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoop;
-import io.netty.channel.embedded.EmbeddedChannel;
import io.netty.util.concurrent.GlobalEventExecutor;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.OpenBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.ProtocolVersion;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.UpdateBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.BgpParameters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.BgpParametersBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.OptionalCapabilities;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.open.message.bgp.parameters.OptionalCapabilitiesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.update.message.Nlri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.update.message.NlriBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.BgpTableType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.CParameters1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.CParameters1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.GracefulRestartCapabilityBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.MultiprotocolCapabilityBuilder;
@Before
public void setUp() throws Exception {
super.setUp();
- new EmbeddedChannel();
- final List<BgpParameters> tlvs = new ArrayList<>();
- this.classicOpen = new OpenBuilder()
- .setMyAsNumber(Uint16.valueOf(AS_NUMBER.getValue()))
- .setHoldTimer(Uint16.valueOf(HOLD_TIMER))
- .setVersion(new ProtocolVersion(Uint8.valueOf(4)))
- .setBgpParameters(tlvs)
- .setBgpIdentifier(BGP_ID)
- .build();
final List<OptionalCapabilities> capa = new ArrayList<>();
capa.add(new OptionalCapabilitiesBuilder().setCParameters(new CParametersBuilder()
- .addAugmentation(CParameters1.class, new CParameters1Builder()
+ .addAugmentation(new CParameters1Builder()
.setMultiprotocolCapability(new MultiprotocolCapabilityBuilder()
.setAfi(this.ipv4tt.getAfi()).setSafi(this.ipv4tt.getSafi()).build())
.setGracefulRestartCapability(new GracefulRestartCapabilityBuilder().setRestartTime(Uint16.ZERO)
.build());
capa.add(new OptionalCapabilitiesBuilder()
.setCParameters(BgpExtendedMessageUtil.EXTENDED_MESSAGE_CAPABILITY).build());
- tlvs.add(new BgpParametersBuilder().setOptionalCapabilities(capa).build());
+
+ this.classicOpen = new OpenBuilder()
+ .setMyAsNumber(Uint16.valueOf(AS_NUMBER.getValue()))
+ .setHoldTimer(Uint16.valueOf(HOLD_TIMER))
+ .setVersion(new ProtocolVersion(Uint8.valueOf(4)))
+ .setBgpParameters(List.of(new BgpParametersBuilder()
+ .setOptionalCapabilities(capa)
+ .build()))
+ .setBgpIdentifier(BGP_ID)
+ .build();
doReturn(null).when(mock(ChannelFuture.class)).addListener(any());
doReturn(this.eventLoop).when(this.speakerListener).eventLoop();
this.serverDispatcher, this.codecsRegistry, this.domBroker, getDataBroker(), this.policies,
ImmutableList.of(this.ipv4tt), pathTables);
ribImpl.instantiateServiceInstance();
- ribImpl.onGlobalContextUpdated(this.schemaService.getGlobalContext());
final BGPPeer bgpPeer = AbstractAddPathTest.configurePeer(this.tableRegistry, neighbor.getIpv4AddressNoZone(),
ribImpl, null, PeerRole.Ibgp, this.serverRegistry, AFI_SAFIS_ADVERTIZED, Collections.emptySet());
this.serverDispatcher, this.codecsRegistry, this.domBroker, getDataBroker(), this.policies,
ImmutableList.of(this.ipv4tt), pathTables);
ribImpl.instantiateServiceInstance();
- ribImpl.onGlobalContextUpdated(this.schemaService.getGlobalContext());
final BGPPeer bgpPeer = AbstractAddPathTest.configurePeer(this.tableRegistry, neighbor.getIpv4AddressNoZone(),
ribImpl, null, PeerRole.Ibgp, this.serverRegistry, AFI_SAFIS_ADVERTIZED, Collections.emptySet());
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory;
-import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.parser.BgpTableTypeImpl;
import org.opendaylight.protocol.bgp.rib.impl.DefaultRibPoliciesMockTest;
import org.opendaylight.protocol.bgp.rib.impl.spi.BGPDispatcher;
+import org.opendaylight.protocol.bgp.rib.impl.spi.CodecsRegistry;
import org.opendaylight.protocol.bgp.rib.impl.spi.InstanceType;
import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.Bgp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.NetworkInstanceProtocol;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.Ipv4AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.UnicastSubsequentAddressFamily;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.osgi.framework.BundleContext;
@Mock
private DataTreeModification<Bgp> modification;
@Mock
- private ListenerRegistration<?> dataTreeRegistration;
- @Mock
private ServiceRegistration<?> registration;
@Mock
private ClusterSingletonServiceProvider singletonServiceProvider;
doReturn(this.registration).when(this.bundleContext).registerService(eq(InstanceType.PEER.getServices()),
any(), any(Dictionary.class));
- doNothing().when(this.dataTreeRegistration).close();
doReturn("bgpPeer").when(this.modification).toString();
final RIBExtensionConsumerContext extension = mock(RIBExtensionConsumerContext.class);
- doReturn(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy()).when(extension).getClassLoadingStrategy();
final ClusterSingletonServiceRegistration serviceRegistration = mock(ClusterSingletonServiceRegistration.class);
doReturn(serviceRegistration).when(this.singletonServiceProvider).registerClusterSingletonService(any());
doNothing().when(serviceRegistration).close();
- schemaService = mock(DOMSchemaService.class);
- doNothing().when(this.dataTreeRegistration).close();
-
- doReturn(this.dataTreeRegistration).when(schemaService).registerSchemaContextListener(any());
-
final RibImpl ribImpl = new RibImpl(extension, mock(BGPDispatcher.class), this.policyProvider,
- mock(BindingCodecTreeFactory.class), getDomBroker(), getDataBroker(), schemaService);
+ mock(CodecsRegistry.class), getDomBroker(), getDataBroker());
doReturn(ribImpl).when(this.blueprintContainer).getComponentInstance(eq("ribImpl"));
doReturn(new BgpPeer(mock(RpcProviderService.class))).when(this.blueprintContainer)
verify(this.blueprintContainer).getComponentInstance(eq("ribImpl"));
verify(this.bundleContext, timeout(VERIFY_TIMEOUT_MILIS).times(2)).registerService(
eq(InstanceType.RIB.getServices()), any(), any(Dictionary.class));
- verify(this.dataTreeRegistration).close();
verify(this.registration).unregister();
//Delete for existing rib
verify(this.blueprintContainer).getComponentInstance(eq("ribImpl"));
verify(this.bundleContext, timeout(VERIFY_TIMEOUT_MILIS).times(2))
.registerService(eq(InstanceType.RIB.getServices()), any(), any(Dictionary.class));
- verify(this.dataTreeRegistration, timeout(VERIFY_TIMEOUT_MILIS).times(2)).close();
verify(this.registration, timeout(VERIFY_TIMEOUT_MILIS).times(2)).unregister();
deployer.close();
private void createRib(final Global global) throws ExecutionException, InterruptedException {
final WriteTransaction wr = getDataBroker().newWriteOnlyTransaction();
- wr.put(LogicalDatastoreType.CONFIGURATION, GLOBAL_II, global, true);
+ wr.mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, GLOBAL_II, global);
wr.commit().get();
}
private void createNeighbor(final Neighbors neighbors) throws ExecutionException, InterruptedException {
final WriteTransaction wr = getDataBroker().newWriteOnlyTransaction();
- wr.put(LogicalDatastoreType.CONFIGURATION, NEIGHBORS_II, neighbors, true);
+ wr.mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, NEIGHBORS_II, neighbors);
wr.commit().get();
}
import java.math.BigDecimal;
import java.net.InetSocketAddress;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.protocol.concepts.KeyMapping;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.multiprotocol.rev151009.bgp.common.afi.safi.list.AfiSafi;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.multiprotocol.rev151009.bgp.common.afi.safi.list.AfiSafiBuilder;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.multiprotocol.rev151009.bgp.common.afi.safi.list.AfiSafiKey;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbor.group.AddPaths;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbor.group.AddPathsBuilder;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbor.group.AfiSafis;
static final AfiSafi AFI_SAFI_IPV4 = new AfiSafiBuilder().setAfiSafiName(IPV4UNICAST.class)
.addAugmentation(NeighborAddPathsConfig.class, new NeighborAddPathsConfigBuilder()
.setReceive(true).setSendMax(Uint8.ZERO).build()).build();
- static final List<AfiSafi> AFI_SAFI = Collections.singletonList(AFI_SAFI_IPV4);
+ static final Map<AfiSafiKey, AfiSafi> AFI_SAFI = Collections.singletonMap(AFI_SAFI_IPV4.key(), AFI_SAFI_IPV4);
private static final BigDecimal DEFAULT_TIMERS = BigDecimal.valueOf(30);
private BgpPeer bgpPeer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.CParameters1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.GracefulRestartCapability;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.LlGracefulRestartCapability;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.graceful.restart.capability.Tables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.Ipv4AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.Ipv6AddressFamily;
assertNotNull(gracefulCapability);
assertTrue(gracefulCapability.getRestartFlags().isRestartState());
assertEquals(RESTART_TIME, gracefulCapability.getRestartTime().intValue());
- final List<Tables> tables = gracefulCapability.getTables();
+ final var tables = gracefulCapability.getTables();
assertNotNull(tables);
assertEquals(2, tables.size());
- tables.forEach(table -> {
+ tables.values().forEach(table -> {
assertTrue(isSameKey(IPV4_KEY, table.key()) && table.getAfiFlags().isForwardingState()
|| isSameKey(IPV6_KEY, table.key()) && !table.getAfiFlags().isForwardingState());
});
assertNotNull(params);
final LlGracefulRestartCapability llGracefulCapability = params.getLlGracefulRestartCapability();
assertNotNull(llGracefulCapability);
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp
- .capabilities.ll.graceful.restart.capability.Tables> tables = llGracefulCapability.getTables();
+ final var tables = llGracefulCapability.getTables();
assertNotNull(tables);
assertEquals(2, tables.size());
- assertEquals(STALE_TIME, tables.get(0).getLongLivedStaleTime().getValue().intValue());
- tables.forEach(table -> {
+ assertEquals(STALE_TIME, tables.values().iterator().next().getLongLivedStaleTime().getValue().intValue());
+ tables.values().forEach(table -> {
assertTrue(isSameKey(IPV4_KEY, table.key()) && table.getAfiFlags().isForwardingState()
|| isSameKey(IPV6_KEY, table.key()) && !table.getAfiFlags().isForwardingState());
});
import static org.opendaylight.protocol.bgp.rib.impl.config.OpenConfigMappingUtil.HOLDTIMER;
import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil.INSTANCE;
-import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.multiprotocol.rev151009.bgp.common.afi.safi.list.AfiSafi;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.multiprotocol.rev151009.bgp.common.afi.safi.list.AfiSafiBuilder;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.multiprotocol.rev151009.bgp.common.afi.safi.list.AfiSafiKey;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.BgpNeighborTransportConfig;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.graceful.restart.GracefulRestartBuilder;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbor.group.AfiSafis;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.SendReceive;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.add.path.capability.AddressFamilies;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.add.path.capability.AddressFamiliesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.GlobalAddPathsConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.GlobalAddPathsConfigBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.GlobalConfigAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.GlobalConfigAugmentationBuilder;
TABLE_TYPES.add(new BgpTableTypeImpl(Ipv4AddressFamily.class, UnicastSubsequentAddressFamily.class));
TABLE_TYPES.add(new BgpTableTypeImpl(Ipv6AddressFamily.class, UnicastSubsequentAddressFamily.class));
AFISAFIS.add(new AfiSafiBuilder().setAfiSafiName(IPV4UNICAST.class)
- .addAugmentation(GlobalAddPathsConfig.class, new GlobalAddPathsConfigBuilder().setReceive(Boolean.TRUE)
+ .addAugmentation(new GlobalAddPathsConfigBuilder().setReceive(Boolean.TRUE)
.setSendMax(N_PATHS).build()).build());
AFISAFIS.add(new AfiSafiBuilder().setAfiSafiName(IPV6UNICAST.class)
- .addAugmentation(GlobalAddPathsConfig.class, new GlobalAddPathsConfigBuilder().setReceive(Boolean.TRUE)
+ .addAugmentation(new GlobalAddPathsConfigBuilder().setReceive(Boolean.TRUE)
.setSendMax(ALL_PATHS).build()).build());
}
@Test
public void testGetAfiSafiWithDefault() {
- final ImmutableList<AfiSafi> defaultValue
- = ImmutableList.of(new AfiSafiBuilder().setAfiSafiName(IPV4UNICAST.class).build());
+ final AfiSafi v4afi = new AfiSafiBuilder().setAfiSafiName(IPV4UNICAST.class).build();
+ final ImmutableMap<AfiSafiKey, AfiSafi> defaultValue = ImmutableMap.of(v4afi.key(), v4afi);
assertEquals(defaultValue, OpenConfigMappingUtil.getAfiSafiWithDefault(null, true));
final AfiSafis afiSafi = new AfiSafisBuilder().build();
assertEquals(defaultValue, OpenConfigMappingUtil.getAfiSafiWithDefault(afiSafi, true));
final List<AfiSafi> expected = new ArrayList<>(afiSafiIpv6List);
expected.add(AFI_SAFI_IPV4);
- assertEquals(afiSafiIpv6, OpenConfigMappingUtil.getAfiSafiWithDefault(new AfiSafisBuilder()
- .setAfiSafi(afiSafiIpv6List).build(), true).get(0));
- assertEquals(new AfiSafiBuilder().setAfiSafiName(IPV4UNICAST.class).build(),
- OpenConfigMappingUtil.getAfiSafiWithDefault(new AfiSafisBuilder().setAfiSafi(afiSafiIpv6List).build(),
- true).get(1));
+
+ final Map<AfiSafiKey, AfiSafi> v6 = OpenConfigMappingUtil.getAfiSafiWithDefault(new AfiSafisBuilder()
+ .setAfiSafi(afiSafiIpv6List).build(), true);
+ assertEquals(2, v6.size());
+ assertTrue(v6.containsValue(afiSafiIpv6));
+ assertTrue(v6.containsValue(new AfiSafiBuilder().setAfiSafiName(IPV4UNICAST.class).build()));
assertEquals(AFI_SAFI, OpenConfigMappingUtil.getAfiSafiWithDefault(createAfiSafi(), true));
assertTrue(OpenConfigMappingUtil.getAfiSafiWithDefault(null, false).isEmpty());
assertTrue(OpenConfigMappingUtil.getAfiSafiWithDefault(afiSafi, false).isEmpty());
assertEquals(afiSafiIpv6, OpenConfigMappingUtil.getAfiSafiWithDefault(new AfiSafisBuilder()
- .setAfiSafi(afiSafiIpv6List).build(), false).get(0));
+ .setAfiSafi(afiSafiIpv6List).build(), false).values().iterator().next());
assertEquals(AFI_SAFI, OpenConfigMappingUtil.getAfiSafiWithDefault(createAfiSafi(), false));
}
public void toPathSelectionMode() {
final List<AfiSafi> families = new ArrayList<>();
families.add(new AfiSafiBuilder().setAfiSafiName(IPV4UNICAST.class)
- .addAugmentation(GlobalAddPathsConfig.class, new GlobalAddPathsConfigBuilder()
- .setSendMax(N_PATHS).build()).build());
+ .addAugmentation(new GlobalAddPathsConfigBuilder().setSendMax(N_PATHS).build()).build());
families.add(new AfiSafiBuilder().setAfiSafiName(IPV6UNICAST.class)
- .addAugmentation(GlobalAddPathsConfig.class, new GlobalAddPathsConfigBuilder()
- .setSendMax(ALL_PATHS).build()).build());
+ .addAugmentation(new GlobalAddPathsConfigBuilder().setSendMax(ALL_PATHS).build()).build());
final Map<BgpTableType, PathSelectionMode> result = OpenConfigMappingUtil
.toPathSelectionMode(families, this.tableTypeRegistry);
final Map<BgpTableType, PathSelectionMode> expected = new HashMap<>();
ADD_PATH_BEST_N_PATH_SELECTION);
expected.put(new BgpTableTypeImpl(Ipv6AddressFamily.class, UnicastSubsequentAddressFamily.class),
ADD_PATH_BEST_ALL_PATH_SELECTION);
+ // FIXME: these assertions are wrong, as they perform lookup on non-existing keys
assertEquals(expected.get(0), result.get(0));
assertEquals(expected.get(1), result.get(1));
}
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory;
-import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
-import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.protocol.bgp.parser.BgpTableTypeImpl;
-import org.opendaylight.protocol.bgp.rib.impl.RIBImpl;
+import org.opendaylight.protocol.bgp.rib.impl.spi.CodecsRegistry;
import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
import org.opendaylight.protocol.bgp.rib.spi.RIBSupport;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.multiprotocol.rev151009.bgp.common.afi.safi.list.AfiSafi;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.types.rev151009.IPV4UNICAST;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.BgpTableType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.GlobalAddPathsConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.GlobalAddPathsConfigBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.Rib;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey;
static {
AFISAFIS.add(new AfiSafiBuilder().setAfiSafiName(IPV4UNICAST.class)
- .addAugmentation(GlobalAddPathsConfig.class, new GlobalAddPathsConfigBuilder().setReceive(true)
- .setSendMax(Uint8.ZERO).build()).build());
+ .addAugmentation(new GlobalAddPathsConfigBuilder().setReceive(true).setSendMax(Uint8.ZERO).build())
+ .build());
}
@Mock
private RIBExtensionConsumerContext extension;
@Mock
- private BindingCodecTreeFactory bindingCodecTreeFactory;
+ private CodecsRegistry codecsRegistry;
@Mock
private DOMDataBroker domDataBroker;
@Mock
- private DOMSchemaService domSchemaService;
- @Mock
- private ListenerRegistration<?> dataTreeRegistration;
- @Mock
private RIBSupport<?, ?, ?, ?> ribSupport;
@Mock
private ServiceRegistration<?> serviceRegistration;
public void setUp() throws Exception {
super.setUp();
- doReturn(mock(GeneratedClassLoadingStrategy.class)).when(this.extension).getClassLoadingStrategy();
doReturn(this.ribSupport).when(this.extension).getRIBSupport(any(TablesKey.class));
final NodeIdentifier nii = new NodeIdentifier(QName.create("", "test").intern());
doReturn(nii).when(this.ribSupport).routeAttributesIdentifier();
final DOMDataTreeChangeService dOMDataTreeChangeService = mock(DOMDataTreeChangeService.class);
doReturn(ImmutableClassToInstanceMap.of(DOMDataTreeChangeService.class, dOMDataTreeChangeService))
.when(this.domDataBroker).getExtensions();
- doReturn(this.dataTreeRegistration).when(this.domSchemaService).registerSchemaContextListener(any());
- doNothing().when(this.dataTreeRegistration).close();
doReturn(mock(ListenerRegistration.class)).when(dOMDataTreeChangeService)
.registerDataTreeChangeListener(any(), any());
doNothing().when(this.serviceRegistration).unregister();
this.extension,
this.dispatcher,
this.policyProvider,
- this.bindingCodecTreeFactory,
+ this.codecsRegistry,
this.domDataBroker,
- getDataBroker(),
- this.domSchemaService);
+ getDataBroker());
ribImpl.setServiceRegistration(this.serviceRegistration);
ribImpl.start(createGlobal(), "rib-test", this.tableTypeRegistry);
- verify(this.extension).getClassLoadingStrategy();
verify(this.domDataBroker).getExtensions();
- verify(this.domSchemaService).registerSchemaContextListener(any(RIBImpl.class));
assertEquals("RIBImpl{bgpId=Ipv4Address{_value=127.0.0.1}, localTables=[BgpTableTypeImpl ["
+ "getAfi()=interface org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types."
+ "rev200120.Ipv4AddressFamily, "
assertNotNull(ribImpl.getCodecsRegistry());
ribImpl.close();
- verify(this.dataTreeRegistration).close();
- verify(this.dataTreeRegistration).close();
verify(this.serviceRegistration).unregister();
}
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-generator-impl</artifactId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-codec</artifactId>
+ <artifactId>mdsal-binding-dom-codec-api</artifactId>
</dependency>
<dependency>
<groupId>org.checkerframework</groupId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <artifactId>mdsal-binding-runtime-spi</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
<scope>test</scope>
</dependency>
<dependency>
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.UpdateBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.path.attributes.Attributes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.path.attributes.AttributesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.Attributes1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.Attributes1Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.Attributes2;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.Attributes2Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.destination.DestinationType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.update.attributes.MpReachNlri;
final QName destContainerQname) {
final QNameModule module = BindingReflections.getQNameModule(cazeClass);
this.routesContainerIdentifier = NodeIdentifier.create(
- BindingReflections.findQName(containerClass).withModule(module));
- this.routeAttributesIdentifier = NodeIdentifier.create(Attributes.QNAME.withModule(module));
+ BindingReflections.findQName(containerClass).bindTo(module));
+ this.routeAttributesIdentifier = NodeIdentifier.create(Attributes.QNAME.bindTo(module));
this.cazeClass = requireNonNull(cazeClass);
this.mappingService = requireNonNull(mappingService);
this.containerClass = requireNonNull(containerClass);
this.listClass = requireNonNull(listClass);
- this.routeQname = BindingReflections.findQName(listClass).withModule(module);
+ this.routeQname = BindingReflections.findQName(listClass).bindTo(module);
this.routesListIdentifier = NodeIdentifier.create(this.routeQname);
this.tk = new TablesKey(afiClass, safiClass);
this.emptyTable = (MapEntryNode) this.mappingService
if (!advertised.isEmpty()) {
final MpReachNlri mb = buildReach(advertised, hop);
- ab.addAugmentation(Attributes1.class, new Attributes1Builder().setMpReachNlri(mb).build());
+ ab.addAugmentation(new Attributes1Builder().setMpReachNlri(mb).build());
LOG.debug("mpreach nexthop={}", mb);
}
if (!withdrawn.isEmpty()) {
final MpUnreachNlri mb = buildUnreach(withdrawn);
- ab.addAugmentation(Attributes2.class, new Attributes2Builder().setMpUnreachNlri(mb).build());
+ ab.addAugmentation(new Attributes2Builder().setMpUnreachNlri(mb).build());
LOG.debug("mpunrach mb={}", mb);
}
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.Route;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.Tables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey;
<C extends Routes & DataObject & ChoiceIn<Tables>, S extends ChildOf<C>,
R extends Route & ChildOf<S> & Identifiable<I>, I extends Identifier<R>> @Nullable RIBSupport<C, S, R, I>
getRIBSupport(@NonNull NodeIdentifierWithPredicates key);
-
-
- /**
- * Returns class loading strategy for loading YANG modeled classes
- * associated with registered RIB supports.
- *
- * @return Class loading strategy for loading YANG modeled classes.
- */
- @NonNull GeneratedClassLoadingStrategy getClassLoadingStrategy();
}
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.List;
+import java.util.Map;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
* @param routes Table route choice
* @return A potentially empty list of routes
*/
- @NonNull List<R> extractAdjRibInRoutes(Routes routes);
+ @NonNull Map<I, R> extractAdjRibInRoutes(Routes routes);
}
import static java.util.Objects.requireNonNull;
import com.google.common.base.Preconditions;
-import java.util.HashSet;
-import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
-import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
-import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.Route;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.Tables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey;
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.YangModuleInfo;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SimpleRIBExtensionProviderContext implements RIBExtensionProviderContext {
-
private static final Logger LOG = LoggerFactory.getLogger(SimpleRIBExtensionProviderContext.class);
private final ConcurrentMap<TablesKey, RIBSupport<?, ?, ?, ?>> supports = new ConcurrentHashMap<>();
private final ConcurrentMap<NodeIdentifierWithPredicates, RIBSupport<?, ?, ?, ?>> domSupports =
new ConcurrentHashMap<>();
- private final ModuleInfoBackedContext classLoadingStrategy = ModuleInfoBackedContext.create();
-
@Override
public <T extends RIBSupport<?, ?, ?, ?>> RIBSupportRegistration<T> registerRIBSupport(
final Class<? extends AddressFamily> afi, final Class<? extends SubsequentAddressFamily> safi,
Preconditions.checkArgument(prev == null, "AFI %s SAFI %s is already registered with %s",
afi, safi, prev);
this.domSupports.put(RibSupportUtils.toYangTablesKey(afi, safi), support);
- addClassLoadingSupport(afi, safi, support);
- return new AbstractRIBSupportRegistration<T>(support) {
+ return new AbstractRIBSupportRegistration<>(support) {
@Override
protected void removeRegistration() {
+ // FIXME: clean up registrations, too
SimpleRIBExtensionProviderContext.this.supports.remove(key);
}
};
}
- private void addClassLoadingSupport(final Class<?> afi, final Class<?> safi, final RIBSupport<?, ?, ?, ?> support) {
- final Set<YangModuleInfo> moduleInfos = getModuleInfos(afi, safi, support.routesListClass(),
- support.routesContainerClass(), support.routesCaseClass());
- if (!moduleInfos.isEmpty()) {
- this.classLoadingStrategy.addModuleInfos(moduleInfos);
- }
- }
-
- @SuppressWarnings("checkstyle:IllegalCatch")
- private static Set<YangModuleInfo> getModuleInfos(final Class<?>... clazzes) {
- final Set<YangModuleInfo> moduleInfos = new HashSet<>();
- for (final Class<?> clz : clazzes) {
- try {
- moduleInfos.add(BindingReflections.getModuleInfo(clz));
- } catch (final Exception e) {
- LOG.debug("Could not find module info for class {}", clz, e);
- }
- }
- return moduleInfos;
- }
-
@Override
public <C extends Routes & DataObject & ChoiceIn<Tables>, S extends ChildOf<C>,
R extends Route & ChildOf<S> & Identifiable<I>, I extends Identifier<R>> RIBSupport<C, S, R, I> getRIBSupport(
final NodeIdentifierWithPredicates key) {
return (RIBSupport<C, S, R, I>) this.domSupports.get(key);
}
-
- @Override
- public GeneratedClassLoadingStrategy getClassLoadingStrategy() {
- return this.classLoadingStrategy;
- }
}
META-INF/services/org.opendaylight.protocol.bgp.rib.spi.RIBExtensionProviderActivator resources.
-->
<odl:specific-reference-list id="extensionActivators" interface="org.opendaylight.protocol.bgp.rib.spi.RIBExtensionProviderActivator"/>
- <odl:static-reference id="mappingCodec"
- interface="org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer"/>
+ <odl:static-reference id="mappingCodec" interface="org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer"/>
+
<bean id="extensionProviderContext" class="org.opendaylight.protocol.bgp.rib.spi.SimpleRIBExtensionProviderContext"/>
<bean id="extensionProviderContextActivator" class="org.opendaylight.protocol.bgp.rib.spi.SimpleRIBExtensionProviderContextActivator"
<value>org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext</value>
</interfaces>
</service>
-</blueprint>
\ No newline at end of file
+</blueprint>
*/
package org.opendaylight.protocol.bgp.rib.spi;
+import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
public abstract class AbstractRIBActivatorTest extends AbstractConcurrentDataBrokerTest {
- protected BindingNormalizedNodeSerializer mappingService;
+ protected AdapterContext context;
@Override
protected final AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
final AbstractDataBrokerTestCustomizer customizer = super.createDataBrokerTestCustomizer();
- this.mappingService = customizer.getBindingToNormalized();
+ this.context = customizer.getAdapterContext();
return customizer;
}
}
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.junit.Before;
import org.mockito.Mock;
+import org.opendaylight.binding.runtime.spi.ModuleInfoBackedContext;
+import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
-import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
protected List<InstanceIdentifier<R>> deletedRoutes;
protected List<Map.Entry<InstanceIdentifier<?>, DataObject>> insertedRoutes;
- protected BindingNormalizedNodeSerializer mappingService;
+ protected AdapterContext adapter;
private AbstractRIBSupport<C, S, R, I> abstractRIBSupport;
private ModuleInfoBackedContext moduleInfoBackedContext;
protected final void setUpTestCustomizer(final AbstractRIBSupport<C, S, R, I> ribSupport) throws Exception {
this.abstractRIBSupport = ribSupport;
- this.moduleInfoBackedContext
- .registerModuleInfo(BindingReflections.getModuleInfo(this.abstractRIBSupport.routesContainerClass()));
- this.moduleInfoBackedContext
- .registerModuleInfo(BindingReflections.getModuleInfo(this.abstractRIBSupport.routesCaseClass()));
- this.moduleInfoBackedContext
- .registerModuleInfo(BindingReflections.getModuleInfo(this.abstractRIBSupport.routesListClass()));
+ this.moduleInfoBackedContext.registerModuleInfos(Arrays.asList(
+ BindingReflections.getModuleInfo(this.abstractRIBSupport.routesContainerClass()),
+ BindingReflections.getModuleInfo(this.abstractRIBSupport.routesCaseClass()),
+ BindingReflections.getModuleInfo(this.abstractRIBSupport.routesListClass())));
}
@Before
initMocks(this);
doAnswer(invocation -> {
final Object[] args = invocation.getArguments();
- AbstractRIBSupportTest.this.insertedRoutes.add(AbstractRIBSupportTest.this.mappingService
+ AbstractRIBSupportTest.this.insertedRoutes.add(adapter.currentSerializer()
.fromNormalizedNode((YangInstanceIdentifier) args[1], (NormalizedNode<?, ?>) args[2]));
return args[1];
}).when(this.tx).put(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class),
doAnswer(invocation -> {
final Object[] args = invocation.getArguments();
AbstractRIBSupportTest.this.deletedRoutes.add((InstanceIdentifier)
- this.mappingService.fromYangInstanceIdentifier((YangInstanceIdentifier) args[1]));
+ adapter.currentSerializer().fromYangInstanceIdentifier((YangInstanceIdentifier) args[1]));
return args[1];
}).when(this.tx).delete(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class));
this.deletedRoutes = new ArrayList<>();
@Override
protected final AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
final AbstractDataBrokerTestCustomizer customizer = super.createDataBrokerTestCustomizer();
- this.mappingService = customizer.getBindingToNormalized();
+ this.adapter = customizer.getAdapterContext();
return customizer;
}
protected final ContainerNode createNlriWithDrawnRoute(final DestinationType destUnreach) {
final MpUnreachNlri mpReach = new MpUnreachNlriBuilder().setWithdrawnRoutes(new WithdrawnRoutesBuilder()
.setDestinationType(destUnreach).build()).build();
- final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> result = this.mappingService
+ final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> result = this.adapter.currentSerializer()
.toNormalizedNode(MP_UNREACH_IID, mpReach);
return (ContainerNode) result.getValue();
}
protected final ContainerNode createNlriAdvertiseRoute(final DestinationType destReach) {
final MpReachNlri mpReach = new MpReachNlriBuilder().setAdvertizedRoutes(new AdvertizedRoutesBuilder()
.setDestinationType(destReach).build()).build();
- final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> result = this.mappingService
+ final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> result = this.adapter.currentSerializer()
.toNormalizedNode(MP_REACH_IID, mpReach);
return (ContainerNode) result.getValue();
}
protected final ContainerNode createAttributes() {
- return (ContainerNode) this.mappingService.toNormalizedNode(ATTRIBUTES_IID, ATTRIBUTES).getValue();
+ return (ContainerNode) this.adapter.currentSerializer().toNormalizedNode(ATTRIBUTES_IID, ATTRIBUTES).getValue();
}
protected final MapEntryNode createEmptyTable() {
final Tables tables = new TablesBuilder().withKey(getTablesKey())
.setAttributes(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329
.rib.tables.AttributesBuilder().build()).build();
- return (MapEntryNode) this.mappingService.toNormalizedNode(tablesIId(), tables).getValue();
+ return (MapEntryNode) this.adapter.currentSerializer().toNormalizedNode(tablesIId(), tables).getValue();
}
protected final ChoiceNode createRoutes(final Routes routes) {
final Tables tables = new TablesBuilder().withKey(getTablesKey()).setRoutes(routes).build();
- return (ChoiceNode) ((MapEntryNode) this.mappingService.toNormalizedNode(tablesIId(), tables).getValue())
- .getChild(new NodeIdentifier(BindingReflections.findQName(Routes.class))).get();
+ return (ChoiceNode) ((MapEntryNode) this.adapter.currentSerializer().toNormalizedNode(tablesIId(), tables)
+ .getValue()).getChild(new NodeIdentifier(BindingReflections.findQName(Routes.class))).get();
}
protected final Collection<MapEntryNode> createRoutes(final S routes) {
Preconditions.checkArgument(routes.implementedInterface()
.equals(this.abstractRIBSupport.routesContainerClass()));
final InstanceIdentifier<S> routesIId = routesIId();
- final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedNode = this.mappingService
+ final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedNode = this.adapter.currentSerializer()
.toNormalizedNode(routesIId, routes);
final ContainerNode container = (ContainerNode) normalizedNode.getValue();
final NodeIdentifier routeNid = new NodeIdentifier(getRouteListQname());
protected final YangInstanceIdentifier getTablePath() {
final InstanceIdentifier<Tables> tables = tablesIId();
- return this.mappingService.toYangInstanceIdentifier(tables);
+ return this.adapter.currentSerializer().toYangInstanceIdentifier(tables);
}
protected final YangInstanceIdentifier getRoutePath() {
final InstanceIdentifier<S> routesIId = routesIId();
- return this.mappingService.toYangInstanceIdentifier(routesIId).node(getRouteListQname());
+ return this.adapter.currentSerializer().toYangInstanceIdentifier(routesIId).node(getRouteListQname());
}
private QName getRouteListQname() {
import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
private final Map<YangInstanceIdentifier, NormalizedNode<?, ?>> routesMap = new HashMap<>();
private ContainerNode attributes;
private MapEntryNode mapEntryNode;
- private BindingToNormalizedNodeCodec mappingService;
+ private AdapterContext context;
@Before
public void setUp() throws Exception {
super.setup();
MockitoAnnotations.initMocks(this);
- this.ribSupportTestImp = new RIBSupportTestImp(this.mappingService);
+ this.ribSupportTestImp = new RIBSupportTestImp(context.currentSerializer());
this.emptyTree = Mockito.mock(DataTreeCandidateNode.class);
this.emptySubTree = Mockito.mock(DataTreeCandidateNode.class);
this.subTree = Mockito.mock(DataTreeCandidateNode.class);
@Override
protected final AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
final AbstractDataBrokerTestCustomizer customizer = super.createDataBrokerTestCustomizer();
- this.mappingService = customizer.getBindingToNormalized();
+ this.context = customizer.getAdapterContext();
return customizer;
}
import java.util.Collection;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.PathId;
}
@Override
- public List<Ipv4Route> extractAdjRibInRoutes(final Routes routes) {
+ public Map<Ipv4RouteKey, Ipv4Route> extractAdjRibInRoutes(final Routes routes) {
return ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.test.rev180515.bgp.rib.rib.peer
.adj.rib.in.tables.routes.Ipv4RoutesCase) routes).getIpv4Routes().nonnullIpv4Route();
}
final List<RIBExtensionProviderActivator> extensionActivators = Collections.singletonList(new RibActivator());
final SimpleRIBExtensionProviderContextActivator activator =
new SimpleRIBExtensionProviderContextActivator(new SimpleRIBExtensionProviderContext(),
- extensionActivators, this.mappingService);
+ extensionActivators, context.currentSerializer());
activator.start();
assertTrue(RIBACTIVATED);
activator.close();
import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yangtools.yang.binding.DataObject;
public class SimpleRIBExtensionTest extends AbstractConcurrentDataBrokerTest {
- private BindingToNormalizedNodeCodec codec;
+ private AdapterContext adapter;
@Override
protected final AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
final AbstractDataBrokerTestCustomizer customizer = super.createDataBrokerTestCustomizer();
- this.codec = customizer.getBindingToNormalized();
+ this.adapter = customizer.getAdapterContext();
return customizer;
}
@Test
public void testExtensionProvider() {
+ final BindingNormalizedNodeSerializer codec = adapter.currentSerializer();
final ServiceLoaderRIBExtensionConsumerContext ctx =
- ServiceLoaderRIBExtensionConsumerContext.createConsumerContext(this.codec);
+ ServiceLoaderRIBExtensionConsumerContext.createConsumerContext(codec);
Assert.assertNull(ctx.getRIBSupport(Ipv4AddressFamily.class, UnicastSubsequentAddressFamily.class));
final TestActivator act = new TestActivator();
- act.startRIBExtensionProvider(ctx, this.codec);
+ act.startRIBExtensionProvider(ctx, codec);
Assert.assertNotNull(ctx.getRIBSupport(Ipv4AddressFamily.class, UnicastSubsequentAddressFamily.class));
act.close();
Assert.assertNull(ctx.getRIBSupport(Ipv4AddressFamily.class, UnicastSubsequentAddressFamily.class));
<scope>test</scope>
<type>test-jar</type>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<!-- junit/mockito default -->
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
import com.google.common.base.Preconditions;
import java.util.Collections;
import java.util.HashMap;
-import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
.child(IgpNodeAttributes.class).build();
trans.merge(LogicalDatastoreType.OPERATIONAL, nii, new NodeBuilder().withKey(nii.getKey()).setNodeId(ni)
- .addAugmentation(Node1.class, new Node1Builder().setIgpNodeAttributes(
+ .addAugmentation(new Node1Builder().setIgpNodeAttributes(
new IgpNodeAttributesBuilder().setPrefix(Collections.emptyList()).build()).build()).build());
this.nodes.put(ni, new NodeUsage(ret));
if (present.useCount == 0) {
final IgpNodeAttributes attrs = read(trans, present.attrId);
if (attrs != null) {
- final List<Prefix> prefix = attrs.getPrefix();
- present.useCount = prefix == null ? 0 : prefix.size();
+ present.useCount = attrs.nonnullPrefix().size();
} else {
present.useCount = 0;
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.Tables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.Ipv4AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.UnicastSubsequentAddressFamily;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.bgp.topology.types.rev160524.TopologyTypes1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.bgp.topology.types.rev160524.TopologyTypes1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.bgp.topology.types.rev160524.bgp.ipv4.reachability.topology.type.BgpIpv4ReachabilityTopologyBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
public final class Ipv4ReachabilityTopologyBuilder extends AbstractReachabilityTopologyBuilder<Ipv4Route> {
public static final TopologyTypes IPV4_TOPOLOGY_TYPE = new TopologyTypesBuilder()
- .addAugmentation(TopologyTypes1.class, new TopologyTypes1Builder()
+ .addAugmentation(new TopologyTypes1Builder()
.setBgpIpv4ReachabilityTopology(new BgpIpv4ReachabilityTopologyBuilder().build()).build()).build();
public Ipv4ReachabilityTopologyBuilder(final DataBroker dataProvider, final RibReference locRibReference,
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.Tables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.Ipv6AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.UnicastSubsequentAddressFamily;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.bgp.topology.types.rev160524.TopologyTypes1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.bgp.topology.types.rev160524.TopologyTypes1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.bgp.topology.types.rev160524.bgp.ipv6.reachability.topology.type.BgpIpv6ReachabilityTopologyBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
public final class Ipv6ReachabilityTopologyBuilder extends AbstractReachabilityTopologyBuilder<Ipv6Route> {
public static final TopologyTypes IPV6_TOPOLOGY_TYPE = new TopologyTypesBuilder()
- .addAugmentation(TopologyTypes1.class, new TopologyTypes1Builder()
+ .addAugmentation(new TopologyTypes1Builder()
.setBgpIpv6ReachabilityTopology(new BgpIpv6ReachabilityTopologyBuilder().build()).build()).build();
public Ipv6ReachabilityTopologyBuilder(final DataBroker dataProvider, final RibReference locRibReference,
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev191125.graph.topology.graph.VertexKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev191125.vertex.SrgbBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.concepts.rev131125.Bandwidth;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.bgp.topology.types.rev160524.TopologyTypes1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.bgp.topology.types.rev160524.TopologyTypes1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.bgp.topology.types.rev160524.bgp.linkstate.topology.type.BgpLinkstateTopologyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.SrlgId;
public class LinkstateGraphBuilder extends AbstractTopologyBuilder<LinkstateRoute> {
private static final TopologyTypes LINKSTATE_TOPOLOGY_TYPE = new TopologyTypesBuilder().addAugmentation(
- TopologyTypes1.class,
new TopologyTypes1Builder().setBgpLinkstateTopology(new BgpLinkstateTopologyBuilder().build()).build())
.build();
private static final Logger LOG = LoggerFactory.getLogger(LinkstateGraphBuilder.class);
- private ConnectedGraphProvider graphProvider;
- private ConnectedGraph cgraph;
+ private final ConnectedGraphProvider graphProvider;
+ private final ConnectedGraph cgraph;
public LinkstateGraphBuilder(final DataBroker dataProvider, final RibReference locRibReference,
- final TopologyId topologyId, ConnectedGraphProvider provider) {
+ final TopologyId topologyId, final ConnectedGraphProvider provider) {
super(dataProvider, locRibReference, topologyId, LINKSTATE_TOPOLOGY_TYPE, LinkstateAddressFamily.class,
LinkstateSubsequentAddressFamily.class);
this.graphProvider = requireNonNull(provider);
@VisibleForTesting
LinkstateGraphBuilder(final DataBroker dataProvider, final RibReference locRibReference,
- final TopologyId topologyId, ConnectedGraphProvider provider, final long listenerResetLimitInMillsec,
+ final TopologyId topologyId, final ConnectedGraphProvider provider, final long listenerResetLimitInMillsec,
final int listenerResetEnforceCounter) {
super(dataProvider, locRibReference, topologyId, LINKSTATE_TOPOLOGY_TYPE, LinkstateAddressFamily.class,
LinkstateSubsequentAddressFamily.class, listenerResetLimitInMillsec, listenerResetEnforceCounter);
*
* @return True if all information are present, false otherwise
*/
- private boolean checkLinkState(final LinkCase linkCase) {
+ private static boolean checkLinkState(final LinkCase linkCase) {
if (linkCase.getLocalNodeDescriptors() == null || linkCase.getRemoteNodeDescriptors() == null) {
LOG.warn("Missing Local or Remote Node descriptor in link {}, skipping it", linkCase);
return false;
*
* @return Link Attributes
*/
- private LinkAttributes getLinkAttributes(final Attributes attributes) {
+ private static LinkAttributes getLinkAttributes(final Attributes attributes) {
final LinkAttributes la;
final Attributes1 attr = attributes.augmentation(Attributes1.class);
if (attr != null) {
*
* @return Unique key
*/
- private Uint64 getEdgeId(LinkCase linkCase) {
+ private static Uint64 getEdgeId(final LinkCase linkCase) {
long key = 0;
if (linkCase.getLinkDescriptors().getIpv4InterfaceAddress() != null) {
key = ipv4ToKey(linkCase.getLinkDescriptors().getIpv4InterfaceAddress().getValue());
cgraph.addPrefix(prefix);
}
+ private static final int MAX_PRIORITY = 8;
+
/**
* Create Edge Attributes from Link attributes.
*
*
* @return EdgeAttributes
*/
- private static final int MAX_PRIORITY = 8;
-
- private EdgeAttributes createEdgeAttributes(LinkAttributes la, final LinkDescriptors linkDesc) {
+ private static EdgeAttributes createEdgeAttributes(final LinkAttributes la, final LinkDescriptors linkDesc) {
EdgeAttributesBuilder builder = new EdgeAttributesBuilder();
if (linkDesc.getIpv4InterfaceAddress() != null) {
final List<UnreservedBandwidth> unRsvBw = new ArrayList<>(upperBound);
for (final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120
- .UnreservedBandwidth bandwidth : la.getUnreservedBandwidth()) {
+ .UnreservedBandwidth bandwidth : la.nonnullUnreservedBandwidth().values()) {
unRsvBw.add(new UnreservedBandwidthBuilder()
.setBandwidth(bandwithToDecimalBandwidth(bandwidth.getBandwidth()))
.withKey(new UnreservedBandwidthKey(bandwidth.getPriority())).build());
builder.setUtilizedBandwidth(bandwithToDecimalBandwidth(la.getUtilizedBandwidth()));
}
if (la.getSharedRiskLinkGroups() != null) {
- List<Uint32> srlgs = new ArrayList<Uint32>();
+ List<Uint32> srlgs = new ArrayList<>();
for (SrlgId srlg : la.getSharedRiskLinkGroups()) {
srlgs.add(srlg.getValue());
}
*
* @return Node Attributes
*/
- private NodeAttributes getNodeAttributes(final Attributes attributes) {
+ private static NodeAttributes getNodeAttributes(final Attributes attributes) {
final NodeAttributes na;
final Attributes1 attr = attributes.augmentation(Attributes1.class);
if (attr != null) {
*
* @return New Vertex
*/
- private Vertex getVertex(NodeAttributes na, Uint64 id, int as) {
+ private static Vertex getVertex(final NodeAttributes na, final Uint64 id, final int as) {
VertexBuilder builder = new VertexBuilder().setVertexId(id).setAsn(Uint32.valueOf(as));
if (na.getIpv4RouterId() != null) {
builder.setRouterId(new IpAddress(new Ipv4Address(na.getIpv4RouterId().getValue())));
} else {
int key = id.intValue();
builder.setName(
- ((key << 24) & 0xFF) + "." + ((key << 16) & 0xFF) + "." + ((key << 8) & 0xFF) + "." + (key & 0xFF));
+ (key << 24 & 0xFF) + "." + (key << 16 & 0xFF) + "." + (key << 8 & 0xFF) + "." + (key & 0xFF));
}
if (na.getSrCapabilities() != null) {
builder.setSrgb(new SrgbBuilder()
}
}
- private void removeEdge(LinkCase linkCase) {
+ private void removeEdge(final LinkCase linkCase) {
/* Get Source and Destination Connected Vertex */
if (linkCase.getLinkDescriptors() == null) {
LOG.warn("Missing Link descriptor in link {}, skipping it", linkCase);
return;
}
EdgeKey edgeKey = new EdgeKey(getEdgeId(linkCase));
- if ((edgeKey == null) || (edgeKey.getEdgeId() == Uint64.ZERO)) {
+ if (edgeKey == null || edgeKey.getEdgeId() == Uint64.ZERO) {
LOG.warn("Unable to get the Edge Key from link {}, skipping it", linkCase);
return;
}
cgraph.deleteEdge(edgeKey);
}
- private void removeVertex(NodeCase nodeCase) {
+ private void removeVertex(final NodeCase nodeCase) {
VertexKey vertexKey = new VertexKey(getVertexId(nodeCase.getNodeDescriptors().getCRouterIdentifier()));
- if ((vertexKey == null) || (vertexKey.getVertexId() == Uint64.ZERO)) {
+ if (vertexKey == null || vertexKey.getVertexId() == Uint64.ZERO) {
LOG.warn("Unable to get Vertex Key from descriptor {}, skipping it", nodeCase.getNodeDescriptors());
return;
}
cgraph.deleteVertex(vertexKey);
}
- private void removePrefix(PrefixCase prefixCase) {
+ private void removePrefix(final PrefixCase prefixCase) {
final IpPrefix ippfx = prefixCase.getPrefixDescriptors().getIpReachabilityInformation();
if (ippfx == null) {
LOG.warn("IP reachability not present in prefix {}, skipping it", prefixCase);
*
* @return Vertex in the Connected Graph that corresponds to this Router ID. Vertex is created if not found.
*/
- private Uint64 getVertexId(CRouterIdentifier routerID) {
+ private static Uint64 getVertexId(final CRouterIdentifier routerID) {
Long rid = 0L;
if (routerID instanceof IsisNodeCase) {
return Uint64.valueOf(rid);
}
- private DecimalBandwidth bandwithToDecimalBandwidth(Bandwidth bw) {
+ private static DecimalBandwidth bandwithToDecimalBandwidth(final Bandwidth bw) {
return new DecimalBandwidth(BigDecimal.valueOf(ByteBuffer.wrap(bw.getValue()).getFloat()));
}
- private long ipv4ToKey(String str) {
+ private static long ipv4ToKey(final String str) {
byte[] ip;
try {
ip = ((Inet4Address) Inet4Address.getByName(str)).getAddress();
} catch (UnknownHostException e) {
return 0;
}
- return (((0xFF & ip[0]) << 24) | ((0xFF & ip[1]) << 16) | ((0xFF & ip[2]) << 8) | (0xFF & ip[3]));
+ return (0xFF & ip[0]) << 24 | (0xFF & ip[1]) << 16 | (0xFF & ip[2]) << 8 | 0xFF & ip[3];
}
- private Long ipv6ToKey(String str) {
+ private static Long ipv6ToKey(final String str) {
byte[] ip;
try {
ip = ((Inet6Address) Inet6Address.getByName(str)).getAddress();
protected void clearTopology() {
cgraph.clear();
}
-
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.sid.label.index.SidLabelIndex;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.sid.label.index.sid.label.index.LocalLabelCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.sid.label.index.sid.label.index.SidCase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.bgp.topology.types.rev160524.TopologyTypes1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.bgp.topology.types.rev160524.TopologyTypes1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.bgp.topology.types.rev160524.bgp.linkstate.topology.type.BgpLinkstateTopologyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819.SegmentId;
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.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.Link1;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.Link1Builder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.Node1;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.Node1Builder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.TerminationPoint1;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.TerminationPoint1Builder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.igp.link.attributes.IgpLinkAttributesBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.igp.node.attributes.IgpNodeAttributes;
public class LinkstateTopologyBuilder extends AbstractTopologyBuilder<LinkstateRoute> {
@VisibleForTesting
static final TopologyTypes LINKSTATE_TOPOLOGY_TYPE = new TopologyTypesBuilder()
- .addAugmentation(TopologyTypes1.class, new TopologyTypes1Builder()
+ .addAugmentation(new TopologyTypes1Builder()
.setBgpLinkstateTopology(new BgpLinkstateTopologyBuilder().build()).build()).build();
@VisibleForTesting
static final TopologyTypes SR_AWARE_LINKSTATE_TOPOLOGY_TYPE = new TopologyTypesBuilder(LINKSTATE_TOPOLOGY_TYPE)
- .addAugmentation(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819
- .TopologyTypes1.class,
- new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819
+ .addAugmentation(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819
.TopologyTypes1Builder().setTopologySr(new TopologySrBuilder().build()).build())
.build();
// Write the node out
if (this.sr != null && this.sr.getSegmentCount() > 0) {
- this.nb.addAugmentation(
- org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819.Node1.class,
- new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819
- .Node1Builder().setSegments(this.sr.getSegments()).build());
+ this.nb.addAugmentation(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr
+ .rev130819.Node1Builder().setSegments(this.sr.getSegments()).build());
}
final Node n = this.nb
- .addAugmentation(Node1.class, new Node1Builder().setIgpNodeAttributes(this.inab.build()).build())
+ .addAugmentation(new Node1Builder().setIgpNodeAttributes(this.inab.build()).build())
.build();
trans.put(LogicalDatastoreType.OPERATIONAL, nid, n);
LOG.trace("Created node {} at {}", n, nid);
}
private final class NodeSrHolder {
- private NodeId nodeId;
+ private final NodeId nodeId;
private Long srgbFirstValue = null;
private Integer srgbRangeSize = null;
- private List<Segments> segments = new ArrayList<>();
- private Map<IpPrefix, SrPrefix> srPrefixes = new HashMap<>();
- private Map<IpPrefix, Segments> prefixSegments = new HashMap<>();
- private Map<LinkId, Segments> adjSegments = new HashMap<>();
+ private final List<Segments> segments = new ArrayList<>();
+ private final Map<IpPrefix, SrPrefix> srPrefixes = new HashMap<>();
+ private final Map<IpPrefix, Segments> prefixSegments = new HashMap<>();
+ private final Map<LinkId, Segments> adjSegments = new HashMap<>();
NodeSrHolder(final NodeId nodeId) {
this.nodeId = nodeId;
stpb.setTpId(id);
if (type != null) {
- stpb.addAugmentation(TerminationPoint1.class, new TerminationPoint1Builder()
- .setIgpTerminationPointAttributes(
- new IgpTerminationPointAttributesBuilder().setTerminationPointType(type).build()).build());
+ stpb.addAugmentation(new TerminationPoint1Builder()
+ .setIgpTerminationPointAttributes(new IgpTerminationPointAttributesBuilder()
+ .setTerminationPointType(type)
+ .build())
+ .build());
}
return stpb.build();
}
ProtocolUtil.augmentProtocolId(value, ilab, la, linkCase.getLinkDescriptors());
- final LinkBuilder lb = new LinkBuilder();
- lb.setLinkId(buildLinkId(base, linkCase));
- lb.addAugmentation(Link1.class, new Link1Builder().setIgpLinkAttributes(ilab.build()).build());
+ final LinkBuilder lb = new LinkBuilder()
+ .setLinkId(buildLinkId(base, linkCase))
+ .addAugmentation(new Link1Builder().setIgpLinkAttributes(ilab.build()).build());
final NodeId srcNode = buildNodeId(base, linkCase.getLocalNodeDescriptors());
LOG.trace("Link {} implies source node {}", linkCase, srcNode);
trans.put(LogicalDatastoreType.OPERATIONAL, nid.child(TerminationPoint.class, srcTp.key()), srcTp);
}
if (adjSid != null) {
- lb.addAugmentation(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819
- .Link1.class,
- new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819
- .Link1Builder().setSegment(new SegmentId(Uint32.valueOf(adjSid))).build());
+ lb.addAugmentation(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr
+ .rev130819.Link1Builder().setSegment(new SegmentId(Uint32.valueOf(adjSid))).build());
}
LOG.debug("Created TP {} as link destination", dstTp);
import java.math.BigDecimal;
import java.nio.ByteBuffer;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.IsisAreaIdentifier;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.igp.link.attributes.IgpLinkAttributesBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.igp.node.attributes.IgpNodeAttributesBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.igp.node.attributes.igp.node.attributes.PrefixBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.ospf.topology.rev131021.Prefix1;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.ospf.topology.rev131021.Prefix1Builder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.ospf.topology.rev131021.ospf.link.attributes.OspfLinkAttributesBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.ospf.topology.rev131021.ospf.node.attributes.OspfNodeAttributesBuilder;
case Static:
case Ospf:
if (pa != null && pa.getOspfForwardingAddress() != null) {
- pb.addAugmentation(Prefix1.class, new Prefix1Builder().setOspfPrefixAttributes(
+ pb.addAugmentation(new Prefix1Builder().setOspfPrefixAttributes(
new OspfPrefixAttributesBuilder().setForwardingAddress(pa.getOspfForwardingAddress()
.getIpv4AddressNoZone()).build()).build());
}
case Static:
case IsisLevel1:
case IsisLevel2:
- inab.addAugmentation(
- org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.isis.topology.rev131021
- .IgpNodeAttributes1.class, isisNodeAttributes(nd, na));
+ inab.addAugmentation(isisNodeAttributes(nd, na));
break;
case Ospf:
- inab.addAugmentation(org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.ospf.topology.rev131021
- .IgpNodeAttributes1.class, ospfNodeAttributes(nd, na));
+ inab.addAugmentation(ospfNodeAttributes(nd, na));
break;
default:
break;
case Static:
case IsisLevel1:
case IsisLevel2:
- ilab.addAugmentation(
- org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.isis.topology.rev131021
- .IgpLinkAttributes1.class, isisLinkAttributes(ld.getMultiTopologyId(), la));
+ ilab.addAugmentation(isisLinkAttributes(ld.getMultiTopologyId(), la));
break;
case OspfV3:
case Ospf:
- ilab.addAugmentation(org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.ospf.topology.rev131021
- .IgpLinkAttributes1.class, ospfLinkAttributes(ld.getMultiTopologyId(), la));
+ ilab.addAugmentation(ospfLinkAttributes(ld.getMultiTopologyId(), la));
break;
default:
break;
tb.setTeDefaultMetric(la.getTeMetric().getValue());
}
if (la.getUnreservedBandwidth() != null) {
- tb.setUnreservedBandwidth(unreservedBandwidthList(la.getUnreservedBandwidth()));
+ tb.setUnreservedBandwidth(unreservedBandwidthList(la.nonnullUnreservedBandwidth().values()));
}
if (la.getMaxLinkBandwidth() != null) {
tb.setMaxLinkBandwidth(bandwidthToBigDecimal(la.getMaxLinkBandwidth()));
tb.setTeDefaultMetric(la.getTeMetric().getValue());
}
if (la.getUnreservedBandwidth() != null) {
- tb.setUnreservedBandwidth(unreservedBandwidthList(la.getUnreservedBandwidth()));
+ tb.setUnreservedBandwidth(unreservedBandwidthList(la.nonnullUnreservedBandwidth().values()));
}
if (la.getMaxLinkBandwidth() != null) {
tb.setMaxLinkBandwidth(bandwidthToBigDecimal(la.getMaxLinkBandwidth()));
}
private static List<UnreservedBandwidth> unreservedBandwidthList(
- final List<? extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang
+ final Collection<? extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang
.bgp.linkstate.rev200120.UnreservedBandwidth> input) {
final List<UnreservedBandwidth> ret = new ArrayList<>(input.size());
final TopologyTypes1 topologyTypes = topology.getTopologyTypes().augmentation(TopologyTypes1.class);
assertNotNull(topologyTypes);
assertNotNull(topologyTypes.getBgpIpv4ReachabilityTopology());
- assertEquals(1, topology.getNode().size());
- final Node node = topology.getNode().get(0);
+ assertEquals(1, topology.nonnullNode().size());
+ final Node node = topology.nonnullNode().values().iterator().next();
assertEquals(NEXT_HOP, node.getNodeId().getValue());
- assertEquals(ROUTE_IP4PREFIX, node.augmentation(Node1.class).getIgpNodeAttributes().getPrefix().get(0)
- .getPrefix().getIpv4Prefix().getValue());
+ assertEquals(ROUTE_IP4PREFIX, node.augmentation(Node1.class).getIgpNodeAttributes().nonnullPrefix().values()
+ .iterator().next().getPrefix().getIpv4Prefix().getValue());
return topology;
});
// update route
updateIpv4Route(createIpv4Route(NEW_NEXT_HOP));
readDataOperational(getDataBroker(), this.ipv4TopoBuilder.getInstanceIdentifier(), topology -> {
- assertEquals(1, topology.getNode().size());
- final Node nodeUpdated = topology.getNode().get(0);
+ assertEquals(1, topology.nonnullNode().size());
+ final Node nodeUpdated = topology.nonnullNode().values().iterator().next();
assertEquals(NEW_NEXT_HOP, nodeUpdated.getNodeId().getValue());
assertEquals(ROUTE_IP4PREFIX, nodeUpdated.augmentation(Node1.class).getIgpNodeAttributes()
- .getPrefix().get(0).getPrefix().getIpv4Prefix().getValue());
+ .nonnullPrefix().values().iterator().next().getPrefix().getIpv4Prefix().getValue());
return topology;
});
final TopologyTypes1 topologyType = topology.getTopologyTypes().augmentation(TopologyTypes1.class);
assertNotNull(topologyType);
assertNotNull(topologyType.getBgpIpv6ReachabilityTopology());
- assertEquals(1, topology.getNode().size());
- final Node node = topology.getNode().get(0);
+ assertEquals(1, topology.nonnullNode().size());
+ final Node node = topology.nonnullNode().values().iterator().next();
assertEquals(NEXT_HOP, node.getNodeId().getValue());
- assertEquals(ROUTE_IP6PREFIX, node.augmentation(Node1.class).getIgpNodeAttributes().getPrefix()
- .get(0).getPrefix().getIpv6Prefix().getValue());
+ assertEquals(ROUTE_IP6PREFIX, node.augmentation(Node1.class).getIgpNodeAttributes().nonnullPrefix()
+ .values().iterator().next().getPrefix().getIpv6Prefix().getValue());
return topology;
});
updateIpv6Route(createIpv6Route(NEW_NEXT_HOP));
readDataOperational(getDataBroker(), this.ipv6TopoBuilder.getInstanceIdentifier(), topology -> {
- assertEquals(1, topology.getNode().size());
- final Node nodeUpdated = topology.getNode().get(0);
+ assertEquals(1, topology.nonnullNode().size());
+ final Node nodeUpdated = topology.nonnullNode().values().iterator().next();
assertEquals(NEW_NEXT_HOP, nodeUpdated.getNodeId().getValue());
- assertEquals(ROUTE_IP6PREFIX, nodeUpdated.augmentation(Node1.class).getIgpNodeAttributes().getPrefix()
- .get(0).getPrefix().getIpv6Prefix().getValue());
+ assertEquals(ROUTE_IP6PREFIX, nodeUpdated.augmentation(Node1.class).getIgpNodeAttributes().nonnullPrefix()
+ .values().iterator().next().getPrefix().getIpv6Prefix().getValue());
return topology;
});
import static org.opendaylight.protocol.util.CheckUtil.checkNotPresentOperational;
import static org.opendaylight.protocol.util.CheckUtil.readDataOperational;
+import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import io.netty.buffer.Unpooled;
import java.nio.charset.StandardCharsets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.linkstate.routes.linkstate.routes.LinkstateRoute;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.linkstate.routes.linkstate.routes.LinkstateRouteBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.linkstate.routes.linkstate.routes.LinkstateRouteKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.linkstate.routes.linkstate.routes.linkstate.route.Attributes1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.linkstate.routes.linkstate.routes.linkstate.route.Attributes1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.node.identifier.c.router.identifier.IsisNodeCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.node.identifier.c.router.identifier.isis.node._case.IsisNodeBuilder;
}
@Test
- @SuppressWarnings("checkstyle:LineLength")
public void testIsisLinkstateTopologyBuilder() throws InterruptedException, ExecutionException {
// create node
updateLinkstateRoute(this.linkstateNodeRouteIID,
createLinkstateNodeRoute(ProtocolId.IsisLevel2, "node1", NODE_1_AS, ROUTER_1_ID));
readDataOperational(getDataBroker(), this.linkstateTopoBuilder.getInstanceIdentifier(), topology -> {
- assertEquals(1, topology.getNode().size());
- final Node node1 = topology.getNode().get(0);
+ assertEquals(1, topology.nonnullNode().size());
+ final Node node1 = topology.nonnullNode().values().iterator().next();
assertEquals(NODE_1_ISIS_ID, node1.getNodeId().getValue());
final IgpNodeAttributes igpNode1 = node1.augmentation(Node1.class).getIgpNodeAttributes();
assertEquals(ROUTER_1_ID, igpNode1.getRouterId().get(0).getIpv4Address().getValue());
.topology.rev131021.IgpNodeAttributes1.class));
assertEquals(LinkstateTopologyBuilder.LINKSTATE_TOPOLOGY_TYPE, topology.getTopologyTypes());
assertNull(node1.augmentation(
- org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819.Node1.class));
+ org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819.Node1.class));
return topology;
});
updateLinkstateRoute(this.linkstateLinkRouteIID,
createLinkstateLinkRoute(ProtocolId.IsisLevel2, NODE_1_AS, NODE_2_AS, "link1"));
readDataOperational(getDataBroker(), this.linkstateTopoBuilder.getInstanceIdentifier(), topology -> {
- assertEquals(1, topology.getLink().size());
- final Link link1 = topology.getLink().get(0);
- assertEquals(2, topology.getNode().size());
- assertEquals(1, topology.getNode().get(0).getTerminationPoint().size());
- assertEquals(1, topology.getNode().get(1).getTerminationPoint().size());
+ assertEquals(1, topology.nonnullLink().size());
+ final Link link1 = topology.nonnullLink().values().iterator().next();
+ assertEquals(2, topology.nonnullNode().size());
+ assertEquals(1, Iterables.get(topology.getNode().values(), 0).getTerminationPoint().size());
+ assertEquals(1, Iterables.get(topology.getNode().values(), 1).getTerminationPoint().size());
assertEquals("bgpls://IsisLevel2:1/type=link&local-as=1&local-router=0000.0102.0304&remote-as"
+ "=2&mt=1", link1.getLinkId().getValue());
assertEquals(NODE_1_ISIS_ID, link1.getSource().getSourceNode().getValue());
assertEquals(LinkstateTopologyBuilder.SR_AWARE_LINKSTATE_TOPOLOGY_TYPE, topology.getTopologyTypes());
assertEquals(2, topology.getNode().size());
final Node srcNode;
- if (topology.getNode().get(0).getNodeId().getValue().contains("0000.0102.0304")) {
- srcNode = topology.getNode().get(0);
+ if (topology.getNode().values().iterator().next().getNodeId().getValue().contains("0000.0102.0304")) {
+ srcNode = topology.getNode().values().iterator().next();
} else {
- srcNode = topology.getNode().get(1);
+ srcNode = Iterables.get(topology.getNode().values(), 1);
}
assertEquals(1, srcNode.augmentation(
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819.Node1.class)
createLinkstateNodeRoute(ProtocolId.IsisLevel2, "updated-node", NODE_1_AS, ROUTER_2_ID));
readDataOperational(getDataBroker(), this.linkstateTopoBuilder.getInstanceIdentifier(), topology -> {
assertEquals(1, topology.getNode().size());
- final IgpNodeAttributes igpNode2 = topology.getNode().get(0).augmentation(Node1.class)
+ final IgpNodeAttributes igpNode2 = topology.getNode().values().iterator().next().augmentation(Node1.class)
.getIgpNodeAttributes();
assertEquals(ROUTER_2_ID, igpNode2.getRouterId().get(0).getIpv4Address().getValue());
assertEquals("updated-node", igpNode2.getName().getValue());
}
@Test
- @SuppressWarnings("checkstyle:LineLength")
public void testOspfLinkstateTopologyBuilder() throws InterruptedException, ExecutionException {
// create node
updateLinkstateRoute(this.linkstateNodeRouteIID,
createLinkstateNodeRoute(ProtocolId.Ospf, "node1", NODE_1_AS, ROUTER_1_ID));
readDataOperational(getDataBroker(), this.linkstateTopoBuilder.getInstanceIdentifier(), topology -> {
- assertEquals(1, topology.getNode().size());
- final Node node1 = topology.getNode().get(0);
+ assertEquals(1, topology.nonnullNode().size());
+ final Node node1 = topology.nonnullNode().values().iterator().next();
assertEquals(NODE_1_OSPF_ID, node1.getNodeId().getValue());
final IgpNodeAttributes igpNode1 = node1.augmentation(Node1.class).getIgpNodeAttributes();
assertEquals(ROUTER_1_ID, igpNode1.getRouterId().get(0).getIpv4Address().getValue());
.getTeRouterIdIpv4().getValue());
assertEquals(LinkstateTopologyBuilder.LINKSTATE_TOPOLOGY_TYPE, topology.getTopologyTypes());
assertNull(node1.augmentation(
- org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819.Node1.class));
+ org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819.Node1.class));
return topology;
});
updateLinkstateRoute(this.linkstatePrefixRouteIID,
createLinkstatePrefixRoute(ProtocolId.Ospf, NODE_1_AS, NODE_1_PREFIX, 500L, ROUTER_1_ID));
readDataOperational(getDataBroker(), this.linkstateTopoBuilder.getInstanceIdentifier(), topology -> {
- final Node node1 = topology.getNode().get(0);
+ final Node node1 = topology.nonnullNode().values().iterator().next();
final IgpNodeAttributes igpNode1 = node1.augmentation(Node1.class).getIgpNodeAttributes();
- assertEquals(1, igpNode1.getPrefix().size());
- final Prefix prefix = igpNode1.getPrefix().get(0);
+ assertEquals(1, igpNode1.nonnullPrefix().size());
+ final Prefix prefix = igpNode1.nonnullPrefix().values().iterator().next();
assertEquals(NODE_1_PREFIX, prefix.getPrefix().getIpv4Prefix().getValue());
assertEquals(500L, prefix.getMetric().longValue());
assertEquals(LinkstateTopologyBuilder.SR_AWARE_LINKSTATE_TOPOLOGY_TYPE, topology.getTopologyTypes());
assertEquals(1, node1.augmentation(
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819.Node1.class)
- .getSegments().size());
+ .nonnullSegments().size());
assertEquals(SRGB_START + NODE_SID_INDEX, node1.augmentation(
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819.Node1.class)
- .getSegments().get(0).getSegmentId().getValue().intValue());
+ .nonnullSegments().values().iterator().next().getSegmentId().getValue().intValue());
return topology;
});
updateLinkstateRoute(this.linkstateLinkRouteIID,
createLinkstateLinkRoute(ProtocolId.Ospf, NODE_1_AS, NODE_2_AS, "link1"));
readDataOperational(getDataBroker(), this.linkstateTopoBuilder.getInstanceIdentifier(), topology -> {
- assertEquals(1, topology.getLink().size());
- final Link link1 = topology.getLink().get(0);
+ assertEquals(1, topology.nonnullLink().size());
+ final Link link1 = topology.nonnullLink().values().iterator().next();
assertEquals(2, topology.getNode().size());
- assertEquals(1, topology.getNode().get(0).getTerminationPoint().size());
- assertEquals(1, topology.getNode().get(1).getTerminationPoint().size());
+ assertEquals(1, Iterables.get(topology.getNode().values(), 0).getTerminationPoint().size());
+ assertEquals(1, Iterables.get(topology.getNode().values(), 1).getTerminationPoint().size());
assertEquals("bgpls://Ospf:1/type=link&local-as=1&local-router=0000.0102.0304&remote-as=2&mt=1",
link1.getLinkId().getValue());
assertEquals(NODE_1_OSPF_ID, link1.getSource().getSourceNode().getValue());
assertEquals(LinkstateTopologyBuilder.SR_AWARE_LINKSTATE_TOPOLOGY_TYPE, topology.getTopologyTypes());
assertEquals(2, topology.getNode().size());
final Node srcNode;
- if (topology.getNode().get(0).getNodeId().getValue().contains("0000.0102.0304")) {
- srcNode = topology.getNode().get(0);
+ if (topology.getNode().values().iterator().next().getNodeId().getValue().contains("0000.0102.0304")) {
+ srcNode = topology.getNode().values().iterator().next();
} else {
- srcNode = topology.getNode().get(1);
+ srcNode = Iterables.get(topology.getNode().values(), 1);
}
assertEquals(2, srcNode.augmentation(
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.sr.rev130819.Node1.class)
.setAsNumber(asNumber).build()).build())
.setAttributes(new AttributesBuilder()
.setOrigin(new OriginBuilder().setValue(BgpOrigin.Igp).build())
- .addAugmentation(Attributes1.class, new Attributes1Builder()
+ .addAugmentation(new Attributes1Builder()
.setLinkStateAttribute(new NodeAttributesCaseBuilder()
.setNodeAttributes(new NodeAttributesBuilder()
.setDynamicHostname(nodeName)
.setIpReachabilityInformation(new IpPrefix(new Ipv4Prefix(ipv4Prefix))).build()).build())
.setAttributes(new AttributesBuilder()
.setOrigin(new OriginBuilder().setValue(BgpOrigin.Igp).build())
- .addAugmentation(Attributes1.class, new Attributes1Builder()
+ .addAugmentation(new Attributes1Builder()
.setLinkStateAttribute(new PrefixAttributesCaseBuilder()
.setPrefixAttributes(new PrefixAttributesBuilder()
.setOspfForwardingAddress(new IpAddressNoZone(new Ipv4AddressNoZone(ospfFwdAddress)))
.setMultiTopologyId(new TopologyIdentifier(Uint16.ONE)).build()).build())
.setAttributes(new AttributesBuilder()
.setOrigin(new OriginBuilder().setValue(BgpOrigin.Igp).build())
- .addAugmentation(Attributes1.class, new Attributes1Builder()
+ .addAugmentation(new Attributes1Builder()
.setLinkStateAttribute(new LinkAttributesCaseBuilder()
.setLinkAttributes(new LinkAttributesBuilder()
.setSharedRiskLinkGroups(Lists.newArrayList(
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>5.0.9</version>
+ <version>6.0.0</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</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-codec</artifactId>
+ <artifactId>mdsal-binding-dom-codec-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
<artifactId>rfc6991-ietf-inet-types</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-model-api</artifactId>
- </dependency>
<dependency>
<groupId>org.checkerframework</groupId>
<artifactId>checker-qual</artifactId>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>mockito-configuration</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
import io.netty.channel.ChannelFutureListener;
import java.net.InetAddress;
import java.net.InetSocketAddress;
-import java.util.List;
+import java.util.Collection;
import java.util.concurrent.ExecutionException;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
private final DOMDataBroker domDataBroker;
private final InetSocketAddress address;
private final MonitorId monitorId;
- private final List<MonitoredRouter> monitoredRouters;
+ private final Collection<MonitoredRouter> monitoredRouters;
private final BmpDispatcher dispatcher;
private final RouterSessionManager sessionManager;
private final YangInstanceIdentifier yangMonitorId;
public BmpMonitoringStationImpl(final BmpDeployerDependencies bmpDeployerDependencies,
final BmpDispatcher dispatcher, final MonitorId monitorId, final InetSocketAddress address,
- final List<MonitoredRouter> mrs) {
+ final Collection<MonitoredRouter> mrs) {
this.domDataBroker = requireNonNull(bmpDeployerDependencies.getDomDataBroker());
this.dispatcher = requireNonNull(dispatcher);
this.monitorId = monitorId;
package org.opendaylight.protocol.bmp.impl.app;
import java.nio.charset.StandardCharsets;
-import java.util.List;
+import java.util.Collection;
import java.util.Objects;
import org.opendaylight.protocol.concepts.KeyMapping;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil;
// Hidden on purpose
}
- public static KeyMapping constructKeys(final List<MonitoredRouter> mrs) {
+ public static KeyMapping constructKeys(final Collection<MonitoredRouter> mrs) {
final KeyMapping ret = KeyMapping.getKeyMapping();
if (mrs != null) {
mrs.stream().filter(Objects::nonNull).filter(KeyConstructorUtil::isNotNullorEmpty)
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public final class BmpDeployerDependencies {
private final DataBroker dataBroker;
private final ClusterSingletonServiceProvider singletonProvider;
public BmpDeployerDependencies(final DataBroker dataBroker, final DOMDataBroker domDataBroker,
- final RIBExtensionConsumerContext extensions, final BindingCodecTreeFactory codecTreeFactory,
- final SchemaContext schemaContext, final ClusterSingletonServiceProvider singletonProvider) {
+ final RIBExtensionConsumerContext extensions, final BindingCodecTree codecTree,
+ final ClusterSingletonServiceProvider singletonProvider) {
this.dataBroker = requireNonNull(dataBroker);
this.domDataBroker = requireNonNull(domDataBroker);
this.extensions = requireNonNull(extensions);
- this.tree = requireNonNull(codecTreeFactory).create(schemaContext);
+ this.tree = requireNonNull(codecTree);
this.singletonProvider = requireNonNull(singletonProvider);
}
final InetSocketAddress inetAddress =
Ipv4Util.toInetSocketAddress(server.getBindingAddress(), server.getBindingPort());
final BmpMonitoringStationImpl monitor = new BmpMonitoringStationImpl(this.bmpDeployerDependencies,
- this.dispatcher, monitorId, inetAddress, bmpConfig.getMonitoredRouter());
+ this.dispatcher, monitorId, inetAddress, bmpConfig.nonnullMonitoredRouter().values());
this.bmpMonitorServices.put(monitorId, monitor);
} catch (final Exception e) {
LOG.error("Failed to create Bmp Monitor {}.", monitorId, e);
<reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker" odl:type="default"/>
<reference id="domDataBroker" interface="org.opendaylight.mdsal.dom.api.DOMDataBroker" odl:type="default"/>
<reference id="globalBgpExtensions" interface="org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext"/>
- <reference id="codecTreeFactory" interface="org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory"/>
- <odl:static-reference id="domSchemaService" interface="org.opendaylight.mdsal.dom.api.DOMSchemaService"/>
+ <reference id="codecTree" interface="org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree"/>
<reference id="clusterSingletonServiceProvider" interface="org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider"/>
<bean id="bmpDeployerDependecies" class="org.opendaylight.protocol.bmp.impl.config.BmpDeployerDependencies">
<argument ref="dataBroker"/>
<argument ref="domDataBroker"/>
<argument ref="globalBgpExtensions"/>
- <argument ref="codecTreeFactory"/>
- <argument>
- <bean factory-ref="domSchemaService" factory-method="getGlobalContext"/>
- </argument>
+ <argument ref="codecTree"/>
<argument ref="clusterSingletonServiceProvider"/>
</bean>
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import java.net.InetSocketAddress;
-import java.util.List;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
-import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
.create(BmpMonitor.class).child(Monitor.class, new MonitorKey(MONITOR_ID));
private static final PeerId PEER_ID = new PeerId(PEER1.getValue());
private static final InstanceIdentifier<BmpMonitor> BMP_II = InstanceIdentifier.create(BmpMonitor.class);
- private BindingToNormalizedNodeCodec mappingService;
+ private AdapterContext mappingService;
private RIBActivator ribActivator;
private BGPActivator bgpActivator;
private BmpActivator bmpActivator;
private ClusterSingletonServiceProvider clusterSSProv;
@Mock
private ClusterSingletonServiceProvider clusterSSProv2;
- private DOMSchemaService schemaService;
@Before
public void setUp() throws Exception {
doAnswer(invocationOnMock -> BmpMonitorImplTest.this.singletonService2.closeServiceInstance())
.when(this.singletonServiceRegistration2).close();
- this.mappingService.onGlobalContextUpdated(this.schemaService.getGlobalContext());
this.ribActivator = new RIBActivator();
this.ribExtension = new SimpleRIBExtensionProviderContext();
- this.ribActivator.startRIBExtensionProvider(this.ribExtension, this.mappingService);
+ this.ribActivator.startRIBExtensionProvider(this.ribExtension, this.mappingService.currentSerializer());
this.bgpActivator = new BGPActivator();
final BGPExtensionProviderContext context = new SimpleBGPExtensionProviderContext();
wTx.commit().get();
final BmpDeployerDependencies bmpDependecies = new BmpDeployerDependencies(getDataBroker(), getDomBroker(),
- this.ribExtension, this.mappingService.getCodecFactory(), this.schemaService.getGlobalContext(),
- this.clusterSSProv);
+ this.ribExtension, this.mappingService.currentSerializer(), this.clusterSSProv);
this.bmpApp = new BmpMonitoringStationImpl(bmpDependecies, this.dispatcher, MONITOR_ID, inetAddress, null);
readDataOperational(getDataBroker(), BMP_II, monitor -> {
- assertEquals(1, monitor.getMonitor().size());
- final Monitor bmpMonitor = monitor.getMonitor().get(0);
+ assertEquals(1, monitor.nonnullMonitor().size());
+ final Monitor bmpMonitor = monitor.getMonitor().values().iterator().next();
assertEquals(MONITOR_ID, bmpMonitor.getMonitorId());
- assertEquals(0, bmpMonitor.getRouter().size());
+ assertEquals(0, bmpMonitor.nonnullRouter().size());
assertEquals(MONITOR_ID, bmpMonitor.getMonitorId());
- assertEquals(0, bmpMonitor.getRouter().size());
+ assertEquals(0, bmpMonitor.nonnullRouter().size());
return monitor;
});
}
@Override
protected final AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
final AbstractDataBrokerTestCustomizer customizer = super.createDataBrokerTestCustomizer();
- this.mappingService = customizer.getBindingToNormalized();
- this.schemaService = customizer.getSchemaService();
+ this.mappingService = customizer.getAdapterContext();
return customizer;
}
this.bmpActivator.close();
this.dispatcher.close();
this.bmpApp.close();
- this.mappingService.close();
checkNotPresentOperational(getDataBroker(), BMP_II);
}
assertNotNull(monitor.getRouter());
// now find the current router instance
Router router = null;
- for (final Router r : monitor.getRouter()) {
+ for (final Router r : monitor.getRouter().values()) {
if (routerId.equals(r.getRouterId())) {
router = r;
break;
}
assertNotNull(router);
assertEquals(Status.Down, router.getStatus());
- assertTrue(router.getPeer().isEmpty());
+ assertNull(router.getPeer());
return router;
});
readDataOperational(getDataBroker(), MONITOR_IID, monitor -> {
assertNotNull(monitor.getRouter());
Router retRouter = null;
- for (final Router r : monitor.getRouter()) {
+ for (final Router r : monitor.getRouter().values()) {
if (routerId.equals(r.getRouterId())) {
retRouter = r;
break;
assertEquals("name", retRouter.getName());
assertEquals("description", retRouter.getDescription());
assertEquals(routerId, retRouter.getRouterId());
- assertTrue(retRouter.getPeer().isEmpty());
+ assertNull(retRouter.getPeer());
assertEquals(Status.Up, retRouter.getStatus());
return retRouter;
});
MONITOR_IID.child(Router.class, new RouterKey(routerId));
readDataOperational(getDataBroker(), routerIId, router -> {
- final List<Peer> peers = router.getPeer();
- assertNotNull(peers.size());
+ final Map<PeerKey, Peer> peers = router.getPeer();
+ assertNotNull(peers);
assertEquals(1, peers.size());
- final Peer peer = peers.get(0);
+ final Peer peer = peers.values().iterator().next();
assertEquals(PeerType.Global, peer.getType());
assertEquals(PEER_ID, peer.getPeerId());
assertEquals(PEER1, peer.getBgpId());
assertNull(peer.getStats());
assertNotNull(peer.getPrePolicyRib());
- assertEquals(1, peer.getPrePolicyRib().getTables().size());
- final Tables prePolicyTable = peer.getPrePolicyRib().getTables().get(0);
+ assertEquals(1, peer.getPrePolicyRib().nonnullTables().size());
+ final Tables prePolicyTable = peer.getPrePolicyRib().nonnullTables().values().iterator().next();
assertEquals(Ipv4AddressFamily.class, prePolicyTable.getAfi());
assertEquals(UnicastSubsequentAddressFamily.class, prePolicyTable.getSafi());
assertFalse(prePolicyTable.getAttributes().isUptodate());
assertNotNull(peer.getPostPolicyRib());
- assertEquals(1, peer.getPostPolicyRib().getTables().size());
- final Tables postPolicyTable = peer.getPrePolicyRib().getTables().get(0);
+ assertEquals(1, peer.getPostPolicyRib().nonnullTables().size());
+ final Tables postPolicyTable = peer.getPrePolicyRib().nonnullTables().values().iterator().next();
assertEquals(Ipv4AddressFamily.class, postPolicyTable.getAfi());
assertEquals(UnicastSubsequentAddressFamily.class, postPolicyTable.getSafi());
assertFalse(postPolicyTable.getAttributes().isUptodate());
assertEquals(tlvs.getLocRibRoutesTlv().getCount(), peerStats.getLocRibRoutes());
assertEquals(tlvs.getRejectedPrefixesTlv().getCount(), peerStats.getRejectedPrefixes());
assertEquals(tlvs.getPerAfiSafiAdjRibInTlv().getCount().toString(),
- peerStats.getPerAfiSafiAdjRibInRoutes().getAfiSafi().get(0).getCount().toString());
+ peerStats.getPerAfiSafiAdjRibInRoutes().getAfiSafi().values().iterator().next().getCount()
+ .toString());
assertEquals(tlvs.getPerAfiSafiLocRibTlv().getCount().toString(),
- peerStats.getPerAfiSafiLocRibRoutes().getAfiSafi().get(0).getCount().toString());
+ peerStats.getPerAfiSafiLocRibRoutes().getAfiSafi().values().iterator().next().getCount()
+ .toString());
return peerStats;
});
AdjRibInType.PrePolicy)));
readDataOperational(getDataBroker(), peerIId.child(PrePolicyRib.class), prePolicyRib -> {
- assertTrue(!prePolicyRib.getTables().isEmpty());
- final Tables tables = prePolicyRib.getTables().get(0);
+ assertFalse(prePolicyRib.getTables().isEmpty());
+ final Tables tables = prePolicyRib.getTables().values().iterator().next();
assertTrue(tables.getAttributes().isUptodate());
assertEquals(3, ((Ipv4RoutesCase) tables.getRoutes()).getIpv4Routes().getIpv4Route().size());
return tables;
AdjRibInType.PostPolicy)));
readDataOperational(getDataBroker(), peerIId.child(PostPolicyRib.class), postPolicyRib -> {
- assertTrue(!postPolicyRib.getTables().isEmpty());
- final Tables tables = postPolicyRib.getTables().get(0);
+ assertFalse(postPolicyRib.getTables().isEmpty());
+ final Tables tables = postPolicyRib.getTables().values().iterator().next();
assertTrue(tables.getAttributes().isUptodate());
assertEquals(3, ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet
.rev180329.bmp.monitor.monitor.router.peer.post.policy.rib.tables.routes.Ipv4RoutesCase)
@Test
public void deploySecondInstance() throws Exception {
final BmpDeployerDependencies bmpDependecies = new BmpDeployerDependencies(getDataBroker(), getDomBroker(),
- this.ribExtension, this.mappingService.getCodecFactory(), this.schemaService.getGlobalContext(),
- this.clusterSSProv2);
+ this.ribExtension, this.mappingService.currentSerializer(), this.clusterSSProv2);
final BmpMonitoringStation monitoringStation2 = new BmpMonitoringStationImpl(bmpDependecies,
this.dispatcher, new MonitorId("monitor2"),
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-codec</artifactId>
+ <artifactId>mdsal-binding-dom-codec-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<type>test-jar</type>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-codec</artifactId>
+ <artifactId>mdsal-binding-dom-codec-api</artifactId>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>yang-test-util</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.slf4j.Logger;
private static final long TIMEOUT_SECONDS = 5;
@GuardedBy("this")
private final Map<String, ConfigFileProcessor> configServices = new HashMap<>();
- private final SchemaContext schemaContext;
+ private final EffectiveModelContext schemaContext;
private final BindingNormalizedNodeSerializer bindingSerializer;
private final String path;
private final Thread watcherThread;
@GuardedBy("this")
private boolean closed = false;
- public ConfigLoaderImpl(final SchemaContext schemaContext, final BindingNormalizedNodeSerializer bindingSerializer,
- final FileWatcher fileWatcher) {
+ public ConfigLoaderImpl(final EffectiveModelContext schemaContext,
+ final BindingNormalizedNodeSerializer bindingSerializer, final FileWatcher fileWatcher) {
this.schemaContext = requireNonNull(schemaContext);
this.bindingSerializer = requireNonNull(bindingSerializer);
this.path = requireNonNull(fileWatcher.getPathFile());
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.bgpcep.config.loader.spi.ConfigFileProcessor;
-import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
public abstract class AbstractConfigLoader extends AbstractConcurrentDataBrokerTest {
private WatchEvent<?> watchEvent;
@Mock
private FileWatcher fileWatcher;
- protected BindingToNormalizedNodeCodec mappingService;
- protected BindingCodecTreeFactory bindingCodecTreeFactory;
+ protected AdapterContext mappingService;
protected DOMSchemaService schemaService;
public AbstractConfigLoader() {
clearEvent();
return null;
}).when(this.processor).loadConfiguration(any());
- this.configLoader = new ConfigLoaderImpl(getSchemaContext(), this.mappingService, this.fileWatcher);
+ this.configLoader = new ConfigLoaderImpl(getSchemaContext(), this.mappingService.currentSerializer(),
+ this.fileWatcher);
this.configLoader.init();
}
@Override
protected final AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
final AbstractDataBrokerTestCustomizer customizer = super.createDataBrokerTestCustomizer();
- this.mappingService = customizer.getBindingToNormalized();
- this.bindingCodecTreeFactory = customizer.getBindingToNormalized();
+ this.mappingService = customizer.getAdapterContext();
this.schemaService = customizer.getSchemaService();
return customizer;
}
<dependencies>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-codec</artifactId>
+ <artifactId>mdsal-binding-dom-codec-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-codec</artifactId>
+ <artifactId>mdsal-binding-dom-codec-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>guava</artifactId>
</dependency>
<!--Test dependencies-->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>config-loader-impl</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-codec</artifactId>
+ <artifactId>mdsal-binding-dom-codec-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<type>test-jar</type>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-codec</artifactId>
+ <artifactId>mdsal-binding-dom-codec-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<type>test-jar</type>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
</dependency>
<!-- test dependencies -->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<scope>runtime</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>features-mdsal-trace</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>features-mdsal</artifactId>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<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>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
-->
<features name="odl-bgpcep-bgp-dependencies-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.4.0">
<feature name="odl-bgpcep-bgp-dependencies" version="${project.version}">
- <feature version="[4,5)">odl-yangtools-data-api</feature>
+ <feature version="[5,6)">odl-yangtools-data-api</feature>
</feature>
</features>
<type>xml</type>
<classifier>features</classifier>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>odl-controller-exp-netty-config</artifactId>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </dependency>
</dependencies>
</project>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-bgp-rib-impl" version="${project.version}">
+ <feature version="[2,3)">odl-controller-exp-netty-config</feature>
<configfile finalname="etc/opendaylight/bgpcep/routing-policy-default-config.xml">mvn:org.opendaylight.bgpcep/bgp-config-example/${project.version}/xml/routing-policy-default-config</configfile>
</feature>
-</features>
\ No newline at end of file
+</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-bgpcep-${project.version}">
<feature name="odl-bgpcep-extras-dependencies" version="${project.version}">
- <feature version="[6,7)">odl-netty-4</feature>
+ <feature version="[7,8)">odl-netty-4</feature>
</feature>
</features>
<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>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>
<dependencies>
<dependency>
- <groupId>${project.groupId}</groupId>
- <artifactId>pcep-impl</artifactId>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>odl-controller-exp-netty-config</artifactId>
+ <type>xml</type>
+ <classifier>features</classifier>
</dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<type>xml</type>
<classifier>features</classifier>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>pcep-impl</artifactId>
+ </dependency>
</dependencies>
</project>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+ Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ and is available at http://www.eclipse.org/legal/epl-v10.html
+-->
+<features name="odl-bgpcep-pcep-impl-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
+ <feature name="odl-bgpcep-pcep-impl" version="${project.version}">
+ <feature version="[2,3)">odl-controller-exp-netty-config</feature>
+ </feature>
+</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-bgpcep-${project.version}">
<feature name="odl-bgpcep-pcep-tunnel-provider" version="${project.version}">
- <feature version="[6,7)">odl-apache-commons-lang3</feature>
+ <feature version="[7,8)">odl-apache-commons-lang3</feature>
</feature>
</features>
<type>xml</type>
<classifier>features</classifier>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>odl-controller-exp-netty-config</artifactId>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </dependency>
</dependencies>
</project>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+ Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ and is available at http://www.eclipse.org/legal/epl-v10.html
+-->
+<features name="odl-bgpcep-programming-impl-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
+ <feature name="odl-bgpcep-programming-impl" version="${project.version}">
+ <feature version="[2,3)">odl-controller-exp-netty-config</feature>
+ </feature>
+</features>
<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>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
package org.opendaylight.graph;
import java.util.List;
+import org.eclipse.jdt.annotation.NonNull;
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.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev191125.graph.topology.Graph;
* @param key Unique Vertex Identifier
* @return Vertex or null if there is no Vertex associated to the given key in this graph
*/
- ConnectedVertex getConnectedVertex(Long key);
+ ConnectedVertex getConnectedVertex(@NonNull Long key);
/**
* Returns the Vertex associated to the given IP address.
* @param key Unique Edge Identifier
* @return Edge or null if there is no Edge associated to the given key in this graph
*/
- ConnectedEdge getConnectedEdge(Long key);
+ ConnectedEdge getConnectedEdge(@NonNull Long key);
/**
* Returns the Edge associated to the given IP address.
<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.graph.impl;
import static com.google.common.base.Preconditions.checkArgument;
* @author Olivier Dugeon
* @author Philippe Niger
*/
-
-
public class ConnectedGraphImpl implements ConnectedGraph {
-
private static final Logger LOG = LoggerFactory.getLogger(ConnectedGraphImpl.class);
/* List of Connected Vertics that composed this Connected Graph */
/* Reference to Graph Model Server to store corresponding graph in DataStore */
private final ConnectedGraphServer connectedGraphServer;
- public ConnectedGraphImpl(Graph newGraph, ConnectedGraphServer server) {
+ public ConnectedGraphImpl(final Graph newGraph, final ConnectedGraphServer server) {
this.graph = newGraph;
createConnectedGraph();
this.connectedGraphServer = server;
return;
}
/* Add all vertices */
- if (this.graph.getVertex() != null) {
- for (Vertex vertex : this.graph.getVertex()) {
- ConnectedVertexImpl cvertex = new ConnectedVertexImpl(vertex);
- vertices.put(cvertex.getKey(), cvertex);
- }
+ for (Vertex vertex : this.graph.nonnullVertex().values()) {
+ ConnectedVertexImpl cvertex = new ConnectedVertexImpl(vertex);
+ vertices.put(cvertex.getKey(), cvertex);
}
/* Add all edges */
- if (this.graph.getEdge() != null) {
- for (Edge edge : this.graph.getEdge()) {
- ConnectedEdgeImpl cedge = new ConnectedEdgeImpl(edge);
- edges.put(cedge.getKey(), cedge);
- }
+ for (Edge edge : this.graph.nonnullEdge().values()) {
+ ConnectedEdgeImpl cedge = new ConnectedEdgeImpl(edge);
+ edges.put(cedge.getKey(), cedge);
}
/* Add all prefixes */
- if (this.graph.getPrefix() != null) {
- for (Prefix prefix : this.graph.getPrefix()) {
- ConnectedVertexImpl cvertex = vertices.get(prefix.getVertexId().longValue());
- if (cvertex != null) {
- cvertex.addPrefix(prefix);
- }
- prefixes.putIfAbsent(prefix.getPrefix(), prefix);
+ for (Prefix prefix : this.graph.nonnullPrefix().values()) {
+ ConnectedVertexImpl cvertex = vertices.get(prefix.getVertexId().longValue());
+ if (cvertex != null) {
+ cvertex.addPrefix(prefix);
}
+ prefixes.putIfAbsent(prefix.getPrefix(), prefix);
}
}
* @param key Unique Vertex Key identifier
* @return new or existing Connected Vertex
*/
- private ConnectedVertexImpl updateConnectedVertex(@NonNull Long key) {
+ private ConnectedVertexImpl updateConnectedVertex(final @NonNull Long key) {
checkArgument(key != 0, "Provided Vertex Key must not be equal to 0");
ConnectedVertexImpl vertex = vertices.get(key);
if (vertex == null) {
* @param key Unique Edge Key identifier
* @return new or existing Connected Edge
*/
- private ConnectedEdgeImpl updateConnectedEdge(@NonNull Long key) {
+ private ConnectedEdgeImpl updateConnectedEdge(final @NonNull Long key) {
checkArgument(key != 0, "Provided Edge Key must not be equal to 0");
ConnectedEdgeImpl edge = edges.get(key);
if (edge == null) {
* @param dstVertex Destination Connected Vertex
* @param edge Connected Edge
*/
- private void connectVertices(ConnectedVertexImpl srcVertex, ConnectedVertexImpl dstVertex, ConnectedEdgeImpl edge) {
+ private static void connectVertices(final ConnectedVertexImpl srcVertex, final ConnectedVertexImpl dstVertex,
+ final ConnectedEdgeImpl edge) {
if (edge != null) {
edge.setSource(srcVertex);
edge.setDestination(dstVertex);
@Override
public List<ConnectedVertex> getVertices() {
- return new ArrayList<ConnectedVertex>(this.vertices.values());
+ return new ArrayList<>(this.vertices.values());
}
@Override
- public ConnectedVertex getConnectedVertex(@NonNull Long key) {
+ public ConnectedVertex getConnectedVertex(final Long key) {
return vertices.get(key);
}
@Override
- public ConnectedVertex getConnectedVertex(IpAddress address) {
+ public ConnectedVertex getConnectedVertex(final IpAddress address) {
IpPrefix prefix = null;
if (address.getIpv4Address() != null) {
prefix = new IpPrefix(new Ipv4Prefix(address.getIpv4Address().getValue() + "/32"));
@Override
public List<ConnectedEdge> getEdges() {
- return new ArrayList<ConnectedEdge>(this.edges.values());
+ return new ArrayList<>(this.edges.values());
}
@Override
- public ConnectedEdge getConnectedEdge(@NonNull Long key) {
+ public ConnectedEdge getConnectedEdge(final Long key) {
return edges.get(key);
}
@Override
- public ConnectedEdge getConnectedEdge(IpAddress address) {
+ public ConnectedEdge getConnectedEdge(final IpAddress address) {
for (ConnectedEdge cedge : edges.values()) {
if (cedge.getEdge() == null) {
continue;
@Override
public List<Prefix> getPrefixes() {
- return new ArrayList<Prefix>(this.prefixes.values());
+ return new ArrayList<>(this.prefixes.values());
}
@Override
- public Prefix getPrefix(IpPrefix prefix) {
+ public Prefix getPrefix(final IpPrefix prefix) {
return this.prefixes.get(prefix);
}
@Override
- public ConnectedVertex addVertex(Vertex vertex) {
+ public ConnectedVertex addVertex(final Vertex vertex) {
checkArgument(vertex != null, "Provided Vertex is a null object");
ConnectedVertexImpl cvertex = updateConnectedVertex(vertex.getVertexId().longValue());
Vertex old = cvertex.getVertex();
}
@Override
- public void deleteVertex(VertexKey key) {
+ public void deleteVertex(final VertexKey key) {
checkArgument(key != null, "Provided Vertex Key is a null object");
ConnectedVertexImpl cvertex = vertices.get(key.getVertexId().longValue());
if (cvertex != null) {
}
@Override
- public ConnectedEdge addEdge(Edge edge) {
+ public ConnectedEdge addEdge(final Edge edge) {
checkArgument(edge != null, "Provided Edge is a null object");
ConnectedEdgeImpl cedge = updateConnectedEdge(edge.getEdgeId().longValue());
Edge old = cedge.getEdge();
}
@Override
- public void deleteEdge(EdgeKey key) {
+ public void deleteEdge(final EdgeKey key) {
checkArgument(key != null, "Provided Edge Key is a null object");
ConnectedEdgeImpl cedge = edges.get(key.getEdgeId().longValue());
if (cedge != null) {
}
@Override
- public void addPrefix(Prefix prefix) {
+ public void addPrefix(final Prefix prefix) {
checkArgument(prefix != null, "Provided Prefix is a null object");
ConnectedVertexImpl cvertex = updateConnectedVertex(prefix.getVertexId().longValue());
cvertex.addPrefix(prefix);
}
@Override
- public void deletePrefix(IpPrefix ippfx) {
+ public void deletePrefix(final IpPrefix ippfx) {
checkArgument(ippfx != null, "Provided Prefix is a null object");
Prefix prefix = prefixes.get(ippfx);
if (prefix != null) {
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.HashMap;
import org.opendaylight.graph.ConnectedGraph;
import org.opendaylight.graph.ConnectedGraphProvider;
final WriteTransaction trans = this.chain.newWriteOnlyTransaction();
LOG.info("Create Graph Model at top level in Operational DataStore: {}", this.graphTopologyIdentifier);
trans.put(LogicalDatastoreType.OPERATIONAL, this.graphTopologyIdentifier,
- new GraphTopologyBuilder().setGraph(Collections.emptyList()).build());
+ new GraphTopologyBuilder().build());
trans.put(LogicalDatastoreType.CONFIGURATION, this.graphTopologyIdentifier,
- new GraphTopologyBuilder().setGraph(Collections.emptyList()).build());
+ new GraphTopologyBuilder().build());
LOG.info("Create Graph Model at top level in Configuration DataStore: {}", this.graphTopologyIdentifier);
trans.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
/**
* DataStore Instance Identifier creation for the various Graph components.
*/
- private InstanceIdentifier<Graph> getGraphInstanceIdentifier(String name) {
+ private InstanceIdentifier<Graph> getGraphInstanceIdentifier(final String name) {
GraphKey graphKey = new GraphKey(name);
return this.graphTopologyIdentifier.child(Graph.class, graphKey);
}
- private InstanceIdentifier<Vertex> getVertexInstanceIdentifier(Graph graph, final Vertex vertex) {
+ private InstanceIdentifier<Vertex> getVertexInstanceIdentifier(final Graph graph, final Vertex vertex) {
return this.graphTopologyIdentifier.child(Graph.class, graph.key()).child(Vertex.class, vertex.key());
}
- private InstanceIdentifier<Edge> getEdgeInstanceIdentifier(Graph graph, final Edge edge) {
+ private InstanceIdentifier<Edge> getEdgeInstanceIdentifier(final Graph graph, final Edge edge) {
return this.graphTopologyIdentifier.child(Graph.class, graph.key()).child(Edge.class, edge.key());
}
- private InstanceIdentifier<Prefix> getPrefixInstanceIdentifier(Graph graph, final Prefix prefix) {
+ private InstanceIdentifier<Prefix> getPrefixInstanceIdentifier(final Graph graph, final Prefix prefix) {
return this.graphTopologyIdentifier.child(Graph.class, graph.key()).child(Prefix.class, prefix.key());
}
*
* @param graph Graph associated to the Connected Graph
*/
- public void clearGraph(Graph graph) {
+ public void clearGraph(final Graph graph) {
Preconditions.checkArgument(graph != null, "Provided Graph is a null object");
removeFromDataStore(getGraphInstanceIdentifier(graph.getName()), "Graph(" + graph.getName() + ")");
}
* @param vertex Vertex to be inserted in the graph
* @param old Old vertex when performing an update. Must be null for a simple addition
*/
- public void addVertex(Graph graph, Vertex vertex, Vertex old) {
+ public void addVertex(final Graph graph, final Vertex vertex, final Vertex old) {
Preconditions.checkArgument(graph != null, "Provided Graph is a null object");
Preconditions.checkArgument(vertex != null, "Provided Vertex is a null object");
InstanceIdentifier<Vertex> oldId = null;
* @param graph Graph where the vertex is stored
* @param vertex Vertex to be removed
*/
- public void deleteVertex(Graph graph, Vertex vertex) {
+ public void deleteVertex(final Graph graph, final Vertex vertex) {
Preconditions.checkArgument(graph != null, "Provided Graph is a null object");
Preconditions.checkArgument(vertex != null, "Provided Vertex is a null object");
removeFromDataStore(getVertexInstanceIdentifier(graph, vertex), "Vertex(" + vertex.getName() + ")");
* @param edge Edge to be inserted in the graph
* @param old Old edge when performing an update. Must be null for a simple addition
*/
- public void addEdge(Graph graph, Edge edge, Edge old) {
+ public void addEdge(final Graph graph, final Edge edge, final Edge old) {
Preconditions.checkArgument(graph != null, "Provided Graph is a null object");
Preconditions.checkArgument(edge != null, "Provided Edge is a null object");
InstanceIdentifier<Edge> oldId = null;
* @param graph Graph where the edge is stored
* @param edge Edge to be removed
*/
- public void deleteEdge(Graph graph, Edge edge) {
+ public void deleteEdge(final Graph graph, final Edge edge) {
Preconditions.checkArgument(graph != null, "Provided Graph is a null object");
Preconditions.checkArgument(edge != null, "Provided Edge is a null object");
removeFromDataStore(getEdgeInstanceIdentifier(graph, edge), "Edge(" + edge.getName() + ")");
* @param graph Graph where the prefix will be stored
* @param prefix Prefix to be interted in the graph
*/
- public void addPrefix(Graph graph, Prefix prefix) {
+ public void addPrefix(final Graph graph, final Prefix prefix) {
Preconditions.checkArgument(graph != null, "Provided Graph is a null object");
Preconditions.checkArgument(prefix != null, "Provided Prefix is a null object");
addToDataStore(getPrefixInstanceIdentifier(graph, prefix), prefix, "Prefix(" + prefix.getPrefix() + ")");
* @param graph Graph where the prefix is stored
* @param prefix Prefix to be removed
*/
- public void deletePrefix(Graph graph, Prefix prefix) {
+ public void deletePrefix(final Graph graph, final Prefix prefix) {
Preconditions.checkArgument(graph != null, "Provided Graph is a null object");
Preconditions.checkArgument(prefix != null, "Provided Prefix is a null object");
removeFromDataStore(getPrefixInstanceIdentifier(graph, prefix), "Prefix(" + prefix.getPrefix() + ")");
@Override
public ArrayList<ConnectedGraph> getConnectedGraphs() {
- return new ArrayList<ConnectedGraph>(this.graphs.values());
+ return new ArrayList<>(this.graphs.values());
}
@Override
- public ConnectedGraph getConnectedGraph(GraphKey key) {
+ public ConnectedGraph getConnectedGraph(final GraphKey key) {
return graphs.get(key);
}
@Override
- public ConnectedGraph getConnectedGraph(String name) {
+ public ConnectedGraph getConnectedGraph(final String name) {
return graphs.get(new GraphKey(name));
}
@Override
- public Graph getGraph(GraphKey key) {
+ public Graph getGraph(final GraphKey key) {
if (graphs.containsKey(key)) {
return graphs.get(key).getGraph();
} else {
}
@Override
- public Graph getGraph(String name) {
+ public Graph getGraph(final String name) {
return getGraph(new GraphKey(name));
}
@Override
- public ConnectedGraph createConnectedGraph(String name, DomainScope scope) {
+ public ConnectedGraph createConnectedGraph(final String name, final DomainScope scope) {
Graph graph = new GraphBuilder()
.setName(name)
.setDomainScope(scope)
- .setEdge(Collections.emptyList())
- .setVertex(Collections.emptyList())
- .setPrefix(Collections.emptyList())
.build();
addToDataStore(getGraphInstanceIdentifier(name), graph, "Graph(" + name + ")");
ConnectedGraphImpl cgraph = new ConnectedGraphImpl(graph, this);
}
@Override
- public ConnectedGraph addGraph(Graph graph) {
+ public ConnectedGraph addGraph(final Graph graph) {
Preconditions.checkArgument(graph != null, "Provided Graph is a null object");
addToDataStore(getGraphInstanceIdentifier(graph.getName()), graph, "Graph(" + graph.getName() + ")");
ConnectedGraphImpl cgraph = new ConnectedGraphImpl(graph, this);
}
@Override
- public void deleteGraph(GraphKey key) {
+ public void deleteGraph(final GraphKey key) {
Preconditions.checkArgument(key != null, "Provided Graph Key is a null object");
ConnectedGraphImpl cgraph = graphs.remove(key);
/*
<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>bundle-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<!-- ODL-CONTROLLER-ARTIFACTS -->
<dependency>
<groupId>org.opendaylight.controller</groupId>
- <artifactId>mdsal-artifacts</artifactId>
- <version>1.11.0</version>
+ <artifactId>controller-artifacts</artifactId>
+ <version>2.0.0</version>
<scope>import</scope>
<type>pom</type>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>4.0.6</version>
+ <version>5.0.1</version>
<scope>import</scope>
<type>pom</type>
</dependency>
<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>
<!--test dependencies -->
<dependency>
- <groupId>javax.xml.bind</groupId>
- <artifactId>jaxb-api</artifactId>
+ <groupId>jakarta.xml.bind</groupId>
+ <artifactId>jakarta.xml.bind-api</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
if (obj.isProcessingRule()) {
final int lastIndex = epRros.size() - 1;
final EndpointRroPair endpointRroPair = epRros.get(lastIndex);
- final List<Rros> rros = endpointRroPair.getRros();
+ List<Rros> rros = endpointRroPair.getRros();
+ if (rros == null) {
+ rros = new ArrayList<>();
+ }
if (obj instanceof Rro) {
rros.add(new RrosBuilder()
.setRouteObject(new ReportedRouteObjectCaseBuilder().setRro((Rro) obj)
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
}
@Test(timeout = 20000)
- public void testReconectClient() throws InterruptedException, ExecutionException {
+ public void testReconnectClient() throws InterruptedException, ExecutionException {
final int port = InetSocketAddressUtil.getRandomPort();
final InetSocketAddress clientAddr = InetSocketAddressUtil.getRandomLoopbackInetSocketAddress(port);
assertNotNull(object);
assertTrue(object instanceof Ero);
final Ero eroObject = (Ero) object;
- assertTrue(eroObject.getSubobject().isEmpty());
+ assertNull(eroObject.getSubobject());
final ByteBuf buffer = Unpooled.buffer();
this.ctx.getObjectHandlerRegistry().serializeObject(eroObject, buffer);
<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>
<artifactId>testtool-util</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
import java.net.InetSocketAddress;
import org.opendaylight.protocol.pcep.PCEPCapability;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev181109.Tlvs1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev181109.Tlvs1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev181109.sr.pce.capability.tlv.SrPceCapabilityBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.open.object.open.TlvsBuilder;
@Override
public void setCapabilityProposal(final InetSocketAddress address, final TlvsBuilder builder) {
if (this.isSegmentRoutingCapable) {
- builder.addAugmentation(Tlvs1.class,
- new Tlvs1Builder().setSrPceCapability(new SrPceCapabilityBuilder().setMsd(Uint8.ZERO).build())
- .build());
+ builder.addAugmentation(new Tlvs1Builder()
+ .setSrPceCapability(new SrPceCapabilityBuilder().setMsd(Uint8.ZERO).build())
+ .build());
}
}
if (tlv instanceof SrPceCapability) {
tlvBuilder.setSrPceCapability((SrPceCapability) tlv);
}
- tbuilder.addAugmentation(Tlvs1.class, tlvBuilder.build());
+ tbuilder.addAugmentation(tlvBuilder.build());
}
@Override
import org.opendaylight.yangtools.yang.common.Uint8;
public class PCEPSegmentRoutingCapabilityTest {
-
private static final Tlvs EXPECTED_TLVS =
- new TlvsBuilder().addAugmentation(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment
- .routing.rev181109.Tlvs1.class, new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep
+ new TlvsBuilder().addAugmentation(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep
.segment.routing.rev181109.Tlvs1Builder().setSrPceCapability(new SrPceCapabilityBuilder()
.setMsd(Uint8.ZERO).build()).build()).build();
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressNoZone;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev181109.Tlvs3;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev181109.Tlvs3Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev181109.SidType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev181109.Tlvs1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev181109.Tlvs1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev181109.add.lsp.input.arguments.ero.subobject.subobject.type.SrEroTypeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev181109.sr.pce.capability.tlv.SrPceCapabilityBuilder;
.setDeadTimer(Uint8.valueOf(120))
.setSessionId(Uint8.ONE);
- final Tlvs1 tlv = new Tlvs1Builder().setSrPceCapability(new SrPceCapabilityBuilder().setMsd(Uint8.ONE).build())
- .build();
builder.setTlvs(new TlvsBuilder()
- .addAugmentation(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful
- .rev181109.Tlvs1.class, new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep
- .ietf.stateful.rev181109.Tlvs1Builder().build()).addAugmentation(Tlvs1.class, tlv)
- .addAugmentation(Tlvs3.class, new Tlvs3Builder().build()).build());
+ .addAugmentation(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful
+ .rev181109.Tlvs1Builder().build())
+ .addAugmentation(new Tlvs1Builder()
+ .setSrPceCapability(new SrPceCapabilityBuilder().setMsd(Uint8.ONE).build())
+ .build())
+ .addAugmentation(new Tlvs3Builder().build()).build());
final ByteBuf result = Unpooled.wrappedBuffer(OPEN_OBJECT_BYTES);
assertEquals(builder.build(),
import com.google.common.collect.Lists;
import java.nio.charset.StandardCharsets;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.path.setup.type.tlv.PathSetupTypeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.LspId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.ReportedLsp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.ReportedLspKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.reported.lsp.Path;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.reported.lsp.PathKey;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint8;
this.listener.onMessage(this.session, pcRptMsg);
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
//check sr-path
- final List<ReportedLsp> reportedLsps = pcc.getReportedLsp();
+ final Map<ReportedLspKey, ReportedLsp> reportedLsps = pcc.getReportedLsp();
assertNotNull(reportedLsps);
assertEquals(1, reportedLsps.size());
- final ReportedLsp lsp = reportedLsps.get(0);
+ final ReportedLsp lsp = reportedLsps.values().iterator().next();
assertEquals("sr-path1", lsp.getName());
- assertEquals(1, lsp.getPath().get(0).augmentation(Path1.class).getPathSetupType()
- .getPst().intValue());
- final List<Subobject> subobjects = lsp.getPath().get(0).getEro().getSubobject();
+
+ final Map<PathKey, Path> paths = lsp.getPath();
+ assertNotNull(paths);
+ final Path path = paths.values().iterator().next();
+
+ assertEquals(1, path.augmentation(Path1.class).getPathSetupType().getPst().intValue());
+ final List<Subobject> subobjects = path.getEro().nonnullSubobject();
assertEquals(1, subobjects.size());
assertEquals("1.1.1.1", ((IpNodeId)((SrEroType)subobjects.get(0).getSubobjectType())
.getNai()).getIpAddress().getIpv4AddressNoZone().getValue());
this.listener.onMessage(this.session, pcRptMsg);
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
//check second lsp sr-path
- final List<ReportedLsp> reportedLsps = pcc.getReportedLsp();
+ final Map<ReportedLspKey, ReportedLsp> reportedLsps = pcc.getReportedLsp();
assertNotNull(reportedLsps);
assertEquals(2, reportedLsps.size());
return pcc;
this.listener.onMessage(this.session, pcRptMsg);
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
//check updated sr-path
- final List<ReportedLsp> reportedLsps = pcc.getReportedLsp();
+ final Map<ReportedLspKey, ReportedLsp> reportedLsps = pcc.getReportedLsp();
assertNotNull(reportedLsps);
assertEquals(2, reportedLsps.size());
- for (final ReportedLsp rlsp : reportedLsps) {
+ for (final ReportedLsp rlsp : reportedLsps.values()) {
if (rlsp.getName().equals("sr-path1")) {
- final List<Subobject> subobjects = rlsp.getPath().get(0).getEro().getSubobject();
+ final List<Subobject> subobjects = rlsp.nonnullPath().values().iterator().next()
+ .getEro().nonnullSubobject();
assertEquals(1, subobjects.size());
assertEquals("1.1.1.2", ((IpNodeId)((SrEroType)subobjects.get(0)
.getSubobjectType()).getNai()).getIpAddress().getIpv4AddressNoZone().getValue());
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
</dependencies>
<build>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<type>test-jar</type>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
import static java.util.Objects.requireNonNull;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
private static List<Path> makeBeforeBreak(final ReportedLspBuilder rlb, final ReportedLsp previous,
final String name, final boolean remove) {
// just one path should be reported
- Preconditions.checkState(rlb.getPath().size() == 1);
+ final Path path = Iterables.getOnlyElement(rlb.getPath().values());
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.LspId reportedLspId =
- rlb.getPath().get(0).getLspId();
+ path.getLspId();
final List<Path> updatedPaths;
//lspId = 0 and remove = false -> tunnel is down, still exists but no path is signaled
//remove existing tunnel's paths now, as explicit path remove will not come
LOG.debug("Remove previous paths {} to this lsp name {}", previous.getPath(), name);
} else {
// check previous report for existing paths
- updatedPaths = new ArrayList<>(previous.getPath());
+ final Collection<Path> prev = previous.nonnullPath().values();
+ updatedPaths = new ArrayList<>(prev);
LOG.debug("Found previous paths {} to this lsp name {}", updatedPaths, name);
- for (final Path path : previous.getPath()) {
+ for (final Path prevPath : prev) {
//we found reported path in previous reports
- if (path.getLspId().getValue().toJava() == 0 || path.getLspId().equals(reportedLspId)) {
- LOG.debug("Match on lsp-id {}", path.getLspId().getValue());
+ if (prevPath.getLspId().getValue().toJava() == 0 || prevPath.getLspId().equals(reportedLspId)) {
+ LOG.debug("Match on lsp-id {}", prevPath.getLspId().getValue());
// path that was reported previously and does have the same lsp-id, path will be updated
- final boolean r = updatedPaths.remove(path);
+ final boolean r = updatedPaths.remove(prevPath);
LOG.trace("Request removed? {}", r);
}
}
// if the path does not exist in previous report, add it to path list, it's a new ERO
// only one path will be added
//lspId is 0 means confirmation message that shouldn't be added (because we have no means of deleting it later)
- LOG.trace("Adding new path {} to {}", rlb.getPath(), updatedPaths);
- updatedPaths.addAll(rlb.getPath());
+ LOG.trace("Adding new path {} to {}", path, updatedPaths);
+ updatedPaths.add(path);
if (remove) {
if (reportedLspId.getValue().toJava() == 0) {
// if lsp-id also 0, remove all paths
updatedPaths.clear();
} else {
// path is marked to be removed
- LOG.debug("Removing path {} from {}", rlb.getPath(), updatedPaths);
- final boolean r = updatedPaths.removeAll(rlb.getPath());
+ LOG.debug("Removing path {} from {}", path, updatedPaths);
+ final boolean r = updatedPaths.remove(path);
LOG.trace("Request removed? {}", r);
}
}
return Math.toIntExact(stream
.map(ReportedLsp::getPath).filter(pathList -> pathList != null && !pathList.isEmpty())
// pick the first path, as delegate status should be same in each path
- .map(pathList -> pathList.get(0))
+ .map(pathList -> pathList.values().iterator().next())
.map(path -> path.augmentation(Path1.class)).filter(Objects::nonNull)
.map(LspObject::getLsp).filter(Objects::nonNull)
.filter(Lsp::isDelegate)
private final AtomicBoolean lspUpdateCapability = new AtomicBoolean(false);
private final AtomicBoolean initiationCapability = new AtomicBoolean(false);
- private PceServerProvider pceServerProvider;
+ private final PceServerProvider pceServerProvider;
/**
* Creates a new stateful topology session listener for given server session manager.
return OperationResults.UNSENT;
}
// check if at least one of the paths has the same status as requested
- for (final Path p : rep.get().getPath()) {
+ for (final Path p : rep.get().nonnullPath().values()) {
final Path1 p1 = p.augmentation(Path1.class);
if (p1 == null) {
LOG.warn("Node {} LSP {} does not contain data", input.getNode(), input.getName());
return null;
}
// it doesn't matter how many lsps there are in the path list, we only need data that is the same in each path
- final Path1 ra = rep.get().getPath().get(0).augmentation(Path1.class);
+ final Path1 ra = rep.get().getPath().values().iterator().next().augmentation(Path1.class);
checkState(ra != null, "Reported LSP reported null from data-store.");
final Lsp reportedLsp = ra.getLsp();
checkState(reportedLsp != null, "Reported LSP does not contain LSP object.");
private static Optional<PathSetupType> getPST(final Optional<ReportedLsp> rep) {
if (rep.isPresent()) {
- final Path1 path1 = rep.get().getPath().get(0).augmentation(Path1.class);
+ final Path1 path1 = rep.get().getPath().values().iterator().next().augmentation(Path1.class);
if (path1 != null) {
final PathSetupType pst = path1.getPathSetupType();
if (!PSTUtil.isDefaultPST(pst)) {
final Map<PlspId, String> lsps, final boolean incrementalSynchro) {
//load node's lsps from DS
final PathComputationClient pcc = node.augmentation(Node1.class).getPathComputationClient();
- final List<ReportedLsp> reportedLsps = pcc.getReportedLsp();
- for (final ReportedLsp reportedLsp : reportedLsps) {
+ for (final ReportedLsp reportedLsp : pcc.nonnullReportedLsp().values()) {
final String lspName = reportedLsp.getName();
lspData.put(lspName, reportedLsp);
if (!reportedLsp.getPath().isEmpty()) {
- final Path1 path1 = reportedLsp.getPath().get(0).augmentation(Path1.class);
+ final Path1 path1 = reportedLsp.getPath().values().iterator().next().augmentation(Path1.class);
if (path1 != null) {
final PlspId plspId = path1.getLsp().getPlspId();
if (!incrementalSynchro) {
// mark lsp as stale
final ReportedLsp staleLsp = rep.get();
if (!staleLsp.getPath().isEmpty()) {
- final Path1 path1 = staleLsp.getPath().get(0).augmentation(Path1.class);
+ final Path1 path1 = staleLsp.getPath().values().iterator().next().augmentation(Path1.class);
if (path1 != null) {
Stateful07TopologySessionListener.this.staleLsps.add(path1.getLsp().getPlspId());
}
/* Call Path Computation if an ERO was not provided */
boolean segmentRouting = !PSTUtil.isDefaultPST(args2.getPathSetupType());
- if ((rb.getEro() == null)
- || (rb.getEro().getSubobject() == null)
- || (rb.getEro().getSubobject().size() == 0)) {
+ if (rb.getEro() == null
+ || rb.getEro().getSubobject() == null
+ || rb.getEro().getSubobject().size() == 0) {
/* Get a Path Computation to compute the Path from the Arguments */
PathComputation pathComputation = pceServerProvider.getPathComputation();
if (topology.getNode() == null) {
return ret;
}
- topology.getNode().stream()
+ topology.nonnullNode().values().stream()
.filter(Objects::nonNull)
.filter(node -> node.augmentation(PcepNodeConfig.class) != null)
.filter(node -> node.augmentation(PcepNodeConfig.class).getSessionConfig() != null)
if (topology.getNode() == null) {
return ret;
}
- topology.getNode().stream()
+ topology.nonnullNode().values().stream()
.filter(Objects::nonNull)
.filter(node -> node.augmentation(PcepNodeConfig.class) != null)
.filter(node -> node.augmentation(PcepNodeConfig.class).getSessionConfig() != 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.bgpcep.pcep.topology.provider;
import static org.junit.Assert.assertFalse;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
doReturn(new PortNumber(Uint16.valueOf(4189))).when(this.sessionConfig).getListenPort();
doReturn(RPC_TIMEOUT).when(this.sessionConfig).getRpcTimeout();
doReturn(TEST_TOPOLOGY_ID).when(this.topology).getTopologyId();
- doReturn(Collections.emptyList()).when(this.topology).getNode();
+ doCallRealMethod().when(this.topology).nonnullNode();
+ doReturn(Collections.emptyMap()).when(this.topology).getNode();
doReturn(null).when(this.topologyDependencies).getPceServerProvider();
final PCEPTopologyConfiguration configDep = new PCEPTopologyConfiguration(this.sessionConfig, this.topology);
import org.junit.Test;
import org.opendaylight.protocol.pcep.PCEPSession;
import org.opendaylight.protocol.pcep.pcc.mock.spi.MsgBuilderUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev181109.Tlvs3;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev181109.Tlvs3Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev181109.lsp.db.version.tlv.LspDbVersion;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev181109.lsp.db.version.tlv.LspDbVersionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated.rev181109.Stateful1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated.rev181109.Stateful1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.OperationalStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.Pcrpt;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.PlspId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.SymbolicPathName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.Tlvs1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.Tlvs1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.lsp.identifiers.tlv.LspIdentifiersBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.lsp.object.LspBuilder;
final Pcrpt pcRpt = getPcrpt(Uint32.ONE, "test");
this.listener.onMessage(session, pcRpt);
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
- assertFalse(pcc.getReportedLsp().isEmpty());
+ assertFalse(pcc.nonnullReportedLsp().isEmpty());
return pcc;
});
//check node - IncrementalSync state
assertEquals(PccSyncState.IncrementalSync, pcc.getStateSync());
//check reported LSP - persisted from previous session
- assertFalse(pcc.getReportedLsp().isEmpty());
+ assertFalse(pcc.nonnullReportedLsp().isEmpty());
return pcc;
});
//check node - synchronized
assertEquals(PccSyncState.IncrementalSync, pcc.getStateSync());
//check reported LSP is not empty
- assertEquals(2, pcc.getReportedLsp().size());
+ assertEquals(2, pcc.nonnullReportedLsp().size());
return pcc;
});
//check node - synchronized
assertEquals(PccSyncState.Synchronized, pcc.getStateSync());
//check reported LSP is empty, LSP state from previous session was purged
- assertEquals(2, pcc.getReportedLsp().size());
+ assertEquals(2, pcc.nonnullReportedLsp().size());
return pcc;
});
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
//check node - synchronized
assertEquals(PccSyncState.Synchronized, pcc.getStateSync());
- assertEquals(3,pcc.getReportedLsp().size());
+ assertEquals(3,pcc.nonnullReportedLsp().size());
return pcc;
});
}
private Open getOpen(final LspDbVersion dbVersion) {
- return new OpenBuilder(super.getLocalPref()).setTlvs(new TlvsBuilder().addAugmentation(Tlvs1.class,
- new Tlvs1Builder().setStateful(new StatefulBuilder().addAugmentation(Stateful1.class,
- new Stateful1Builder().setInitiation(Boolean.TRUE).build())
- .addAugmentation(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync
- .optimizations.rev181109.Stateful1.class, new org.opendaylight.yang.gen.v1.urn.opendaylight.params
- .xml.ns.yang.controller.pcep.sync.optimizations.rev181109.Stateful1Builder()
- .setIncludeDbVersion(Boolean.TRUE).setDeltaLspSyncCapability(Boolean.TRUE).build())
- .build()).build()).addAugmentation(Tlvs3.class, new Tlvs3Builder().setLspDbVersion(dbVersion).build())
- .build()).build();
+ return new OpenBuilder(super.getLocalPref())
+ .setTlvs(new TlvsBuilder()
+ .addAugmentation(new Tlvs1Builder()
+ .setStateful(new StatefulBuilder()
+ .addAugmentation(new Stateful1Builder().setInitiation(Boolean.TRUE).build())
+ .addAugmentation(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang
+ .controller.pcep.sync.optimizations.rev181109.Stateful1Builder()
+ .setIncludeDbVersion(Boolean.TRUE).setDeltaLspSyncCapability(Boolean.TRUE)
+ .build())
+ .build())
+ .build())
+ .addAugmentation(new Tlvs3Builder().setLspDbVersion(dbVersion).build())
+ .build())
+ .build();
}
private static Pcrpt getPcrpt(final Uint32 val, final String pathname) {
import static org.opendaylight.protocol.util.CheckTestUtil.readDataOperational;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.LspId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.PccSyncState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.TriggerSyncInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.ReportedLsp;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
assertEquals(PccSyncState.Synchronized, pcc.getStateSync());
- assertFalse(pcc.getReportedLsp().isEmpty());
+ assertFalse(pcc.nonnullReportedLsp().isEmpty());
return pcc;
});
this.listener.onMessage(this.session, pcRpt);
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
- final List<?> lsp = pcc.getReportedLsp();
+ final Map<?, ?> lsp = pcc.getReportedLsp();
assertNotNull(lsp);
assertEquals(1, lsp.size());
return pcc;
this.listener.onMessage(this.session, pcRpt);
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
assertEquals(PccSyncState.Synchronized, pcc.getStateSync());
- final List<ReportedLsp> reportedLspPcc = pcc.getReportedLsp();
- assertFalse(reportedLspPcc.isEmpty());
+ assertFalse(pcc.nonnullReportedLsp().isEmpty());
return pcc;
});
this.listener.triggerSync(new TriggerSyncInputBuilder().setNode(this.nodeId).setName("test").build());
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
assertEquals(PccSyncState.PcepTriggeredResync, pcc.getStateSync());
- assertFalse(pcc.getReportedLsp().isEmpty());
+ assertFalse(pcc.nonnullReportedLsp().isEmpty());
return pcc;
});
this.listener.onMessage(this.session, pcRpt);
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
- assertFalse(pcc.getReportedLsp().isEmpty());
+ assertFalse(pcc.nonnullReportedLsp().isEmpty());
return pcc;
});
//check node - synchronized
assertEquals(PccSyncState.Synchronized, pcc.getStateSync());
//check reported LSP
- assertEquals(1, pcc.getReportedLsp().size());
+ assertEquals(1, pcc.nonnullReportedLsp().size());
return pcc;
});
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertNull;
import static org.opendaylight.protocol.pcep.pcc.mock.spi.MsgBuilderUtil.createLsp;
import static org.opendaylight.protocol.pcep.pcc.mock.spi.MsgBuilderUtil.createPath;
import static org.opendaylight.protocol.util.CheckTestUtil.readDataOperational;
//check node - synchronized
assertEquals(PccSyncState.Synchronized, pcc.getStateSync());
//check reported LSP is empty, LSP state from previous session was purged
- assertTrue(pcc.getReportedLsp().isEmpty());
+ assertNull(pcc.getReportedLsp());
return pcc;
});
this.listener.onMessage(session, pcRpt);
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
- assertFalse(pcc.getReportedLsp().isEmpty());
+ assertFalse(pcc.nonnullReportedLsp().isEmpty());
return pcc;
});
.build(), Optional.empty(), createPath(Collections.emptyList()));
this.listener.onMessage(session, pcRpt);
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
- assertFalse(pcc.getReportedLsp().isEmpty());
+ assertFalse(pcc.nonnullReportedLsp().isEmpty());
return pcc;
});
//check node - not synchronized
assertEquals(PccSyncState.InitialResync, pcc.getStateSync());
//check reported LSP - persisted from previous session
- assertFalse(pcc.getReportedLsp().isEmpty());
+ assertFalse(pcc.nonnullReportedLsp().isEmpty());
return pcc;
});
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
assertEquals(this.testAddress, pcc.getIpAddress().getIpv4AddressNoZone().getValue());
// reported lsp so far empty, has not received response (PcRpt) yet
- assertTrue(pcc.getReportedLsp().isEmpty());
+ assertNull(pcc.getReportedLsp());
return pcc;
});
this.listener.onMessage(this.session, pcRpt);
// check created lsp
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
- assertEquals(1, pcc.getReportedLsp().size());
- final ReportedLsp reportedLsp = pcc.getReportedLsp().get(0);
+ assertEquals(1, pcc.nonnullReportedLsp().size());
+ final ReportedLsp reportedLsp = pcc.getReportedLsp().values().iterator().next();
assertEquals(this.tunnelName, reportedLsp.getName());
- assertEquals(1, reportedLsp.getPath().size());
- final Path path = reportedLsp.getPath().get(0);
+ assertEquals(1, reportedLsp.nonnullPath().size());
+ final Path path = reportedLsp.nonnullPath().values().iterator().next();
assertEquals(1, path.getEro().getSubobject().size());
assertEquals(this.eroIpPrefix, getLastEroIpPrefix(path.getEro()));
return pcc;
.ArgumentsBuilder updArgsBuilder = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang
.topology.pcep.rev200120.update.lsp.args.ArgumentsBuilder();
updArgsBuilder.setEro(createEroWithIpPrefixes(Lists.newArrayList(this.eroIpPrefix, this.dstIpPrefix)));
- updArgsBuilder.addAugmentation(Arguments3.class, new Arguments3Builder().setLsp(new LspBuilder()
+ updArgsBuilder.addAugmentation(new Arguments3Builder().setLsp(new LspBuilder()
.setDelegate(TRUE).setAdministrative(FALSE).build()).build());
final UpdateLspInput update = new UpdateLspInputBuilder().setArguments(updArgsBuilder.build())
.setName(this.tunnelName).setNetworkTopologyRef(new NetworkTopologyRef(TOPO_IID))
//check updated lsp
readDataOperational(getDataBroker(), this.pathComputationClientIId, pcc -> {
assertEquals(1, pcc.getReportedLsp().size());
- final ReportedLsp reportedLsp = pcc.getReportedLsp().get(0);
+ final ReportedLsp reportedLsp = pcc.getReportedLsp().values().iterator().next();
assertEquals(this.tunnelName, reportedLsp.getName());
assertEquals(1, reportedLsp.getPath().size());
- final Path path = reportedLsp.getPath().get(0);
+ final Path path = reportedLsp.getPath().values().iterator().next();
assertEquals(2, path.getEro().getSubobject().size());
assertEquals(this.dstIpPrefix, getLastEroIpPrefix(path.getEro()));
assertEquals(1, listenerState.getDelegatedLspsCount().intValue());
<artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
</dependencies>
<scm>
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.PcepEntityIdRpcAug;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.PcepEntityIdRpcAugBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.PcepEntityIdStatsAug;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.StatefulCapabilitiesRpcAug;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.StatefulCapabilitiesRpcAugBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.StatefulCapabilitiesStatsAug;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.StatefulMessagesRpcAug;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.StatefulMessagesRpcAugBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.StatefulMessagesStatsAug;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stats.rev171113.pcep.session.state.LocalPref;
}
@Override
- @SuppressWarnings("checkstyle:LineLength")
public ListenableFuture<RpcResult<GetStatsOutput>> getStats(final GetStatsInput input) {
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.input.Topology> iTopologies =
- input.getTopology();
- final List<TopologyId> iTopologyIds;
+ final var iTopologies = input.getTopology();
+ final Collection<TopologyId> iTopologyIds;
if (iTopologies != null) {
- iTopologyIds = iTopologies.stream().map(
- org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.input.Topology::getTopologyId)
+ iTopologyIds = iTopologies.values().stream()
+ .map(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc
+ .rev190321.get.stats.input.Topology::getTopologyId)
.collect(Collectors.toList());
} else {
iTopologyIds = getAvailableTopologyIds();
}
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.output.Topology> oTopologies =
- new ArrayList<>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321
+ .get.stats.output.Topology> oTopologies = new ArrayList<>();
iTopologyIds.forEach(iTopologyId -> {
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.input.topology.Node> iNodes;
- if (input.getTopology() != null) {
- iNodes = input.getTopology().stream().filter(t -> t.getTopologyId().equals(iTopologyId)).findFirst()
+ final Collection<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc
+ .rev190321.get.stats.input.topology.Node> iNodes;
+ if (iTopologies != null) {
+ final var nodes = iTopologies.values().stream()
+ .filter(t -> iTopologyId.equals(t.getTopologyId()))
+ .findFirst()
.get().getNode();
+ iNodes = nodes != null ? nodes.values() : null;
} else {
iNodes = null;
}
final List<NodeId> iNodeIds;
if (iNodes != null) {
- iNodeIds = iNodes.stream().map(
- org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.input.topology.Node::getNodeId)
+ iNodeIds = iNodes.stream()
+ .map(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc
+ .rev190321.get.stats.input.topology.Node::getNodeId)
.collect(Collectors.toList());
} else {
iNodeIds = getAvailableNodeIds(iTopologyId);
}
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.output.topology.Node> oNodes =
- new ArrayList<>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc
+ .rev190321.get.stats.output.topology.Node> oNodes = new ArrayList<>();
iNodeIds.forEach(iNodeId -> {
final InstanceIdentifier<PcepSessionState> iid = InstanceIdentifier.builder(NetworkTopology.class)
.child(Topology.class, new TopologyKey(iTopologyId)).child(Node.class, new NodeKey(iNodeId))
.augmentation(PcepTopologyNodeStatsAug.class).child(PcepSessionState.class).build();
- if (!sessionStateMap.containsKey(iid)) {
+ final PcepSessionState state = sessionStateMap.get(iid);
+ if (state == null) {
LOG.debug("Pcep session stats not available for node {} in topology {}", iNodeId.getValue(),
iTopologyId.getValue());
}
- oNodes.add(
- new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.output.topology.NodeBuilder()
- .setNodeId(iNodeId)
- .setPcepSessionState(transformStatefulAugmentation(sessionStateMap.get(iid))).build());
+ oNodes.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc
+ .rev190321.get.stats.output.topology.NodeBuilder()
+ .setNodeId(iNodeId)
+ .setPcepSessionState(transformStatefulAugmentation(state)).build());
});
- oTopologies.add(
- new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.output.TopologyBuilder()
- .setTopologyId(iTopologyId).setNode(oNodes).build());
+ oTopologies.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc
+ .rev190321.get.stats.output.TopologyBuilder().setTopologyId(iTopologyId).setNode(oNodes).build());
});
final RpcResult<GetStatsOutput> res =
if (topoMessage != null) {
final StatefulMessagesStatsAug messageStatsAug = topoMessage.augmentation(StatefulMessagesStatsAug.class);
if (messageStatsAug != null) {
- final StatefulMessagesRpcAug messageRpcAug = new StatefulMessagesRpcAugBuilder()
- .setLastReceivedRptMsgTimestamp(messageStatsAug.getLastReceivedRptMsgTimestamp())
- .setReceivedRptMsgCount(messageStatsAug.getReceivedRptMsgCount())
- .setSentInitMsgCount(messageStatsAug.getSentInitMsgCount())
- .setSentUpdMsgCount(messageStatsAug.getSentUpdMsgCount()).build();
- sb.setMessages(new MessagesBuilder(topoMessage).removeAugmentation(StatefulMessagesStatsAug.class)
- .addAugmentation(StatefulMessagesRpcAug.class, messageRpcAug).build());
+ sb.setMessages(new MessagesBuilder(topoMessage)
+ .removeAugmentation(StatefulMessagesStatsAug.class)
+ .addAugmentation(new StatefulMessagesRpcAugBuilder()
+ .setLastReceivedRptMsgTimestamp(messageStatsAug.getLastReceivedRptMsgTimestamp())
+ .setReceivedRptMsgCount(messageStatsAug.getReceivedRptMsgCount())
+ .setSentInitMsgCount(messageStatsAug.getSentInitMsgCount())
+ .setSentUpdMsgCount(messageStatsAug.getSentUpdMsgCount())
+ .build())
+ .build());
}
}
final StatefulCapabilitiesStatsAug capabilityStatsAug =
topoPeerCapability.augmentation(StatefulCapabilitiesStatsAug.class);
if (capabilityStatsAug != null) {
- final StatefulCapabilitiesRpcAug capabilityRpcAug = new StatefulCapabilitiesRpcAugBuilder()
- .setActive(capabilityStatsAug.isActive()).setInstantiation(capabilityStatsAug.isInstantiation())
- .setStateful(capabilityStatsAug.isStateful()).build();
sb.setPeerCapabilities(new PeerCapabilitiesBuilder(topoPeerCapability)
.removeAugmentation(StatefulCapabilitiesStatsAug.class)
- .addAugmentation(StatefulCapabilitiesRpcAug.class, capabilityRpcAug).build());
+ .addAugmentation(new StatefulCapabilitiesRpcAugBuilder()
+ .setActive(capabilityStatsAug.isActive())
+ .setInstantiation(capabilityStatsAug.isInstantiation())
+ .setStateful(capabilityStatsAug.isStateful())
+ .build())
+ .build());
}
}
if (topoLocalPref != null) {
final PcepEntityIdStatsAug entityStatsAug = topoLocalPref.augmentation(PcepEntityIdStatsAug.class);
if (entityStatsAug != null) {
- final PcepEntityIdRpcAug entityRpcAug = new PcepEntityIdRpcAugBuilder()
- .setSpeakerEntityIdValue(entityStatsAug.getSpeakerEntityIdValue()).build();
- sb.setLocalPref(new LocalPrefBuilder(topoLocalPref).removeAugmentation(PcepEntityIdStatsAug.class)
- .addAugmentation(PcepEntityIdRpcAug.class, entityRpcAug).build());
+ sb.setLocalPref(new LocalPrefBuilder(topoLocalPref)
+ .removeAugmentation(PcepEntityIdStatsAug.class)
+ .addAugmentation(new PcepEntityIdRpcAugBuilder()
+ .setSpeakerEntityIdValue(entityStatsAug.getSpeakerEntityIdValue())
+ .build())
+ .build());
}
}
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.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.PcepEntityIdRpcAug;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.PcepEntityIdRpcAugBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.PcepEntityIdStatsAug;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.PcepEntityIdStatsAugBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.StatefulCapabilitiesRpcAug;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.StatefulCapabilitiesRpcAugBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.StatefulCapabilitiesStatsAug;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.StatefulCapabilitiesStatsAugBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.StatefulMessagesRpcAug;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stateful.stats.rev181109.StatefulMessagesRpcAugBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.GetStatsInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.GetStatsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.GetStatsOutputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.stats.rev181109.PcepTopologyNodeStatsAug;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.stats.rev181109.PcepTopologyNodeStatsAugBuilder;
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.NetworkTopologyBuilder;
}
private static Node createPcepNode(final String nodeId) {
- return new NodeBuilder().setNodeId(new NodeId(nodeId))
- .addAugmentation(PcepTopologyNodeStatsAug.class,
- new PcepTopologyNodeStatsAugBuilder().setPcepSessionState(createTopologySessionState()).build())
+ return new NodeBuilder()
+ .setNodeId(new NodeId(nodeId))
+ .addAugmentation(new PcepTopologyNodeStatsAugBuilder()
+ .setPcepSessionState(createTopologySessionState())
+ .build())
.build();
}
.setReceivedMsgCount(Uint32.valueOf(4))
.setReplyTime(replyTime)
.setErrorMessages(errorMsg)
- .addAugmentation(StatefulMessagesStatsAug.class, statefulMsg).build();
+ .addAugmentation(statefulMsg).build();
final PeerCapabilities capabilities = new PeerCapabilitiesBuilder()
- .addAugmentation(StatefulCapabilitiesStatsAug.class, new StatefulCapabilitiesStatsAugBuilder()
- .setStateful(true).setInstantiation(true).setActive(true).build())
+ .addAugmentation(new StatefulCapabilitiesStatsAugBuilder()
+ .setStateful(true)
+ .setInstantiation(true)
+ .setActive(true)
+ .build())
.build();
final LocalPref localPref = new LocalPrefBuilder()
.setDeadtimer(Uint8.valueOf(120))
.setIpAddress("127.0.0.1")
.setSessionId(Uint16.ZERO)
- .addAugmentation(PcepEntityIdStatsAug.class, new PcepEntityIdStatsAugBuilder()
+ .addAugmentation(new PcepEntityIdStatsAugBuilder()
.setSpeakerEntityIdValue(new byte[] {0x01, 0x02, 0x03, 0x04})
.build())
.build();
.setReceivedMsgCount(Uint32.valueOf(4))
.setReplyTime(replyTime)
.setErrorMessages(errorMsg)
- .addAugmentation(StatefulMessagesRpcAug.class, statefulMsg).build();
+ .addAugmentation(statefulMsg).build();
final PeerCapabilities capabilities = new PeerCapabilitiesBuilder()
- .addAugmentation(StatefulCapabilitiesRpcAug.class, new StatefulCapabilitiesRpcAugBuilder()
+ .addAugmentation(new StatefulCapabilitiesRpcAugBuilder()
.setStateful(true).setInstantiation(true).setActive(true).build())
.build();
.setDeadtimer(Uint8.valueOf(120))
.setIpAddress("127.0.0.1")
.setSessionId(Uint16.ZERO)
- .addAugmentation(PcepEntityIdRpcAug.class, new PcepEntityIdRpcAugBuilder()
+ .addAugmentation(new PcepEntityIdRpcAugBuilder()
.setSpeakerEntityIdValue(new byte[] {0x01, 0x02, 0x03, 0x04})
.build())
.build();
}
@Test
- @SuppressWarnings("checkstyle:LineLength")
public void testGetStatsAllMatch() throws Exception {
GetStatsInput in;
- final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.output.Topology ot1 =
- createGetStatsOutput(TOPOLOGY_ID1, Collections.singletonList(NODE_ID1), createRpcSessionState())
- .getTopology().get(0);
- final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.output.Topology ot2 =
- createGetStatsOutput(TOPOLOGY_ID2, Arrays.asList(NODE_ID2, NODE_ID3), createRpcSessionState())
- .getTopology().get(0);
+ final var ot1 = createGetStatsOutput(TOPOLOGY_ID1, Collections.singletonList(NODE_ID1), createRpcSessionState())
+ .getTopology().values() .iterator().next();
+ final var ot2 = createGetStatsOutput(TOPOLOGY_ID2, Arrays.asList(NODE_ID2, NODE_ID3), createRpcSessionState())
+ .getTopology().values().iterator().next();
final GetStatsOutput out = new GetStatsOutputBuilder().setTopology(Arrays.asList(ot1, ot2)).build();
// Implicitly match all PCEP topologies and nodes
performCountTest(in, out);
// Explicitly match all PCEP topologies and nodes
- final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.input.Topology it1 =
- createGetStatsInput(TOPOLOGY_ID1, Collections.singletonList(NODE_ID1)).getTopology().get(0);
- final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.input.Topology it2 =
- createGetStatsInput(TOPOLOGY_ID2, Arrays.asList(NODE_ID2, NODE_ID3)).getTopology().get(0);
+ final var it1 = createGetStatsInput(TOPOLOGY_ID1, Collections.singletonList(NODE_ID1)).getTopology().values()
+ .iterator().next();
+ final var it2 = createGetStatsInput(TOPOLOGY_ID2, Arrays.asList(NODE_ID2, NODE_ID3)).getTopology().values()
+ .iterator().next();
in = new GetStatsInputBuilder().setTopology(Arrays.asList(it1, it2)).build();
performCountTest(in, out);
}
private void performTest(final GetStatsInput in, final GetStatsOutput out) throws Exception {
final RpcResult<GetStatsOutput> result = rpcService.getStats(in).get();
- assertEquals(result.getResult(), out);
+ assertEquals(out, result.getResult());
assertTrue(result.isSuccessful());
assertTrue(result.getErrors().isEmpty());
}
final RpcResult<GetStatsOutput> result = rpcService.getStats(in).get();
assertEquals(result.getResult().getTopology().size(), out.getTopology().size());
assertTrue(result.isSuccessful());
- assertEquals(result.getResult().getTopology().stream().flatMap(t -> t.getNode().stream()).count(),
- out.getTopology().stream().flatMap(t -> t.getNode().stream()).count());
+ assertEquals(result.getResult().nonnullTopology().values().stream()
+ .flatMap(t -> t.nonnullNode().values().stream()).count(),
+ out.nonnullTopology().values().stream().flatMap(t -> t.nonnullNode().values().stream()).count());
assertTrue(result.isSuccessful());
assertTrue(result.getErrors().isEmpty());
}
- @SuppressWarnings("checkstyle:LineLength")
private static GetStatsInput createGetStatsInput(final String topologyId, final List<String> nodeIds) {
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.input.topology.Node> nodes;
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321
+ .get.stats.input.topology.Node> nodes;
if (nodeIds != null) {
- nodes = nodeIds.stream().map(
- nodeId -> new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.input.topology.NodeBuilder()
- .setNodeId(new NodeId(nodeId)).build())
+ nodes = nodeIds.stream()
+ .map(nodeId -> new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology
+ .stats.rpc.rev190321.get.stats.input.topology.NodeBuilder()
+ .setNodeId(new NodeId(nodeId))
+ .build())
.collect(Collectors.toList());
} else {
nodes = null;
}
- final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.input.Topology topology;
+ final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get
+ .stats.input.Topology topology;
if (topologyId != null) {
- topology =
- new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.input.TopologyBuilder()
- .setTopologyId(new TopologyId(topologyId)).setNode(nodes).build();
+ topology = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc
+ .rev190321.get.stats.input.TopologyBuilder()
+ .setTopologyId(new TopologyId(topologyId))
+ .setNode(nodes)
+ .build();
} else {
topology = null;
}
.build();
}
- @SuppressWarnings("checkstyle:LineLength")
private static GetStatsOutput createGetStatsOutput(final String topologyId, final List<String> nodeIds,
final PcepSessionState state) {
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.output.topology.Node> nodes;
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321
+ .get.stats.output.topology.Node> nodes;
if (nodeIds != null) {
- nodes = nodeIds.stream().map(
- nodeId -> new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.output.topology.NodeBuilder()
- .setNodeId(new NodeId(nodeId)).setPcepSessionState(state).build())
+ nodes = nodeIds.stream()
+ .map(nodeId -> new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology
+ .stats.rpc.rev190321.get.stats.output.topology.NodeBuilder()
+ .setNodeId(new NodeId(nodeId))
+ .setPcepSessionState(state)
+ .build())
.collect(Collectors.toList());
} else {
nodes = null;
}
- final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.output.Topology topology;
+ final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get
+ .stats.output.Topology topology;
if (topologyId != null) {
- topology =
- new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc.rev190321.get.stats.output.TopologyBuilder()
- .setTopologyId(new TopologyId(topologyId)).setNode(nodes).build();
+ topology = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.topology.stats.rpc
+ .rev190321.get.stats.output.TopologyBuilder()
+ .setTopologyId(new TopologyId(topologyId))
+ .setNode(nodes)
+ .build();
} else {
topology = null;
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<artifactId>pcep-impl</artifactId>
<type>test-jar</type>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.AdministrativeStatus;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.Arguments2;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.Arguments2Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.PcepCreateP2pTunnelInput1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.lsp.object.LspBuilder;
final AdministrativeStatus adminStatus = this.p2pTunnelInput.augmentation(PcepCreateP2pTunnelInput1.class)
.getAdministrativeStatus();
if (adminStatus != null) {
- args.addAugmentation(Arguments2.class, new Arguments2Builder().setLsp(new LspBuilder()
+ args.addAugmentation(new Arguments2Builder().setLsp(new LspBuilder()
.setAdministrative(adminStatus == AdministrativeStatus.Active).build()).build());
}
return args.build();
}
final RemoveLspInputBuilder ab = new RemoveLspInputBuilder();
ab.setName(link.augmentation(Link1.class).getSymbolicPathName());
- ab.setNode(node.getSupportingNode().get(0).key().getNodeRef());
+ ab.setNode(node.nonnullSupportingNode().values().iterator().next().key().getNodeRef());
return Futures.transform(
this.topologyService.removeLsp(ab.build()),
RpcResult::getResult, MoreExecutors.directExecutor());
import static java.util.Objects.requireNonNull;
import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.PathComputationClient;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.ReportedLsp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.reported.lsp.Path;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.Link1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.Link1Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.SupportingNode1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.SupportingNode1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.tunnel.pcep.supporting.node.attributes.PathComputationClientBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.LinkId;
return;
}
- for (final ReportedLsp l : pccnode.getPathComputationClient().getReportedLsp()) {
+ for (final ReportedLsp l : pccnode.getPathComputationClient().nonnullReportedLsp().values()) {
lsps.add(id.builder().augmentation(Node1.class).child(PathComputationClient.class)
.child(ReportedLsp.class, l.key()).build());
}
}
private SupportingNode createSupportingNode(final NodeId sni, final Boolean inControl) {
- final SupportingNodeKey sk = new SupportingNodeKey(sni, this.source);
- final SupportingNodeBuilder snb = new SupportingNodeBuilder();
- snb.setNodeRef(sni);
- snb.withKey(sk);
- snb.addAugmentation(SupportingNode1.class, new SupportingNode1Builder().setPathComputationClient(
- new PathComputationClientBuilder().setControlling(inControl).build()).build());
-
- return snb.build();
+ return new SupportingNodeBuilder()
+ .setNodeRef(sni)
+ .withKey(new SupportingNodeKey(sni, this.source))
+ .addAugmentation(new SupportingNode1Builder().setPathComputationClient(
+ new PathComputationClientBuilder().setControlling(inControl).build()).build())
+ .build();
}
private void handleSni(final InstanceIdentifier<Node> sni, final Node node, final Boolean inControl,
* so it does not have a supporting node pointer. Since we now know what it is,
* fill it in.
*/
- if (node.getSupportingNode() != null) {
- for (final SupportingNode sn : node.getSupportingNode()) {
- if (sn.getNodeRef().equals(k.getNodeId())) {
- have = true;
- break;
- }
+ for (final SupportingNode sn : node.nonnullSupportingNode().values()) {
+ if (sn.getNodeRef().equals(k.getNodeId())) {
+ have = true;
+ break;
}
}
if (!have) {
final IpAddress addr, final InstanceIdentifier<Node> sni, final Boolean inControl)
throws ExecutionException, InterruptedException {
final Topology topo = trans.read(LogicalDatastoreType.OPERATIONAL, this.target).get().get();
- if (topo.getNode() != null) {
- for (final Node n : topo.getNode()) {
- if (n.getTerminationPoint() != null) {
- for (final TerminationPoint tp : n.getTerminationPoint()) {
- final TerminationPoint1 tpa = tp.augmentation(TerminationPoint1.class);
- if (tpa != null) {
- final TerminationPointType tpt = tpa.getIgpTerminationPointAttributes()
- .getTerminationPointType();
- if (tpt instanceof Ip) {
- for (final IpAddress address : ((Ip) tpt).getIpAddress()) {
- if (addr.equals(address)) {
- handleSni(sni, n, inControl, trans);
- return this.target.builder().child(Node.class, n.key())
- .child(TerminationPoint.class, tp.key()).build();
- }
- }
- } else {
- LOG.debug("Ignoring termination point type {}", tpt);
+ for (final Node n : topo.nonnullNode().values()) {
+ for (final TerminationPoint tp : n.nonnullTerminationPoint().values()) {
+ final TerminationPoint1 tpa = tp.augmentation(TerminationPoint1.class);
+ if (tpa != null) {
+ final TerminationPointType tpt = tpa.getIgpTerminationPointAttributes()
+ .getTerminationPointType();
+ if (tpt instanceof Ip) {
+ for (final IpAddress address : ((Ip) tpt).getIpAddress()) {
+ if (addr.equals(address)) {
+ handleSni(sni, n, inControl, trans);
+ return this.target.builder().child(Node.class, n.key())
+ .child(TerminationPoint.class, tp.key()).build();
}
}
+ } else {
+ LOG.debug("Ignoring termination point type {}", tpt);
}
}
}
final TerminationPointKey tpk = new TerminationPointKey(new TpId(url));
final TerminationPointBuilder tpb = new TerminationPointBuilder();
tpb.withKey(tpk).setTpId(tpk.getTpId());
- tpb.addAugmentation(TerminationPoint1.class, new TerminationPoint1Builder().setIgpTerminationPointAttributes(
- new IgpTerminationPointAttributesBuilder().setTerminationPointType(
- new IpBuilder().setIpAddress(Lists.newArrayList(addr)).build()).build()).build());
+ tpb.addAugmentation(new TerminationPoint1Builder()
+ .setIgpTerminationPointAttributes(new IgpTerminationPointAttributesBuilder()
+ .setTerminationPointType(new IpBuilder().setIpAddress(Lists.newArrayList(addr)).build())
+ .build())
+ .build());
final NodeKey nk = new NodeKey(new NodeId(url));
final NodeBuilder nb = new NodeBuilder();
final ReportedLsp value) throws ExecutionException, InterruptedException {
final InstanceIdentifier<Node> ni = identifier.firstIdentifierOf(Node.class);
- final Path1 rl = value.getPath().get(0).augmentation(Path1.class);
+ final Path1 rl = value.nonnullPath().values().iterator().next().augmentation(Path1.class);
final AddressFamily af = rl.getLsp().getTlvs().getLspIdentifiers().getAddressFamily();
throw new IllegalArgumentException("Unsupported address family: " + af.implementedInterface());
}
- final Path path0 = value.getPath().get(0);
+ final Path path0 = value.nonnullPath().values().iterator().next();
final Link1Builder lab = new Link1Builder();
if (path0.getBandwidth() != null) {
lab.setBandwidth(path0.getBandwidth().getBandwidth());
.setSourceTp(src.firstKeyOf(TerminationPoint.class).getTpId()).build());
lb.setDestination(new DestinationBuilder().setDestNode(dst.firstKeyOf(Node.class).getNodeId())
.setDestTp(dst.firstKeyOf(TerminationPoint.class).getTpId()).build());
- lb.addAugmentation(Link1.class, lab.build());
- lb.addAugmentation(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful
- .rev181109.Link1.class, slab.build());
+ lb.addAugmentation(lab.build());
+ lb.addAugmentation(slab.build());
trans.put(LogicalDatastoreType.OPERATIONAL, linkForLsp(id), lb.build());
}
boolean orphDstNode = true;
boolean orphDstTp = true;
boolean orphSrcTp = true;
- for (final Link lw : nonNullList(topology.getLink())) {
+ for (final Link lw : topology.nonnullLink().values()) {
LOG.trace("Checking link {}", lw);
final NodeId sn = lw.getSource().getSourceNode();
DataBroker getDataProvider() {
return dataProvider;
}
-
- private static <T> List<T> nonNullList(final List<T> nullable) {
- return nullable != null ? nullable : ImmutableList.of();
- }
}
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.TopologyTypes1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.TopologyTypes1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.topology.tunnel.pcep.type.TopologyTunnelPcepBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
tx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, getTopologyReference().getInstanceIdentifier(),
new TopologyBuilder().setTopologyId(this.tunneltopologyId)
.setTopologyTypes(new TopologyTypesBuilder()
- .addAugmentation(TopologyTypes1.class, new TopologyTypes1Builder()
+ .addAugmentation(new TopologyTypes1Builder()
.setTopologyTunnelPcep(
new TopologyTunnelPcepBuilder().build()).build()).build())
.setNode(new ArrayList<>()).build());
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.FailureType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.OperationResult;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.p2p.rev130819.tunnel.p2p.path.cfg.attributes.ExplicitHops;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.p2p.rev130819.tunnel.p2p.path.cfg.attributes.ExplicitHopsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.ExplicitHops1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.SupportingNode1;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
// Hidden on purpose
}
- public static Ero buildEro(final List<ExplicitHops> explicitHops) {
+ public static Ero buildEro(final Map<ExplicitHopsKey, ExplicitHops> explicitHops) {
final EroBuilder b = new EroBuilder();
- if (!explicitHops.isEmpty()) {
+ if (explicitHops != null && !explicitHops.isEmpty()) {
final List<Subobject> subobjs = new ArrayList<>(explicitHops.size());
- for (final ExplicitHops h : explicitHops) {
+ for (final ExplicitHops h : explicitHops.values()) {
final ExplicitHops1 h1 = h.augmentation(ExplicitHops1.class);
if (h1 != null) {
}
public static NodeId supportingNode(final Node node) {
- for (final SupportingNode n : node.getSupportingNode()) {
+ for (final SupportingNode n : node.nonnullSupportingNode().values()) {
final SupportingNode1 n1 = n.augmentation(SupportingNode1.class);
if (n1 != null && n1.getPathComputationClient().isControlling()) {
return n.key().getNodeRef();
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.AdministrativeStatus;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.Arguments3;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.Arguments3Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.PcepUpdateTunnelInput1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.lsp.object.LspBuilder;
final AdministrativeStatus adminStatus = this.updateTunnelInput.augmentation(PcepUpdateTunnelInput1.class)
.getAdministrativeStatus();
if (adminStatus != null) {
- args.addAugmentation(Arguments3.class, new Arguments3Builder().setLsp(new LspBuilder()
+ args.addAugmentation(new Arguments3Builder().setLsp(new LspBuilder()
.setAdministrative(adminStatus == AdministrativeStatus.Active).build()).build());
}
ab.setArguments(args.build());
import static org.junit.Assert.assertNull;
import static org.opendaylight.protocol.util.CheckTestUtil.readDataOperational;
+import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import java.util.Collections;
+import java.util.Iterator;
import java.util.concurrent.ExecutionException;
import org.junit.After;
import org.junit.Assert;
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.Ipv4AddressNoZone;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.concepts.rev131125.Bandwidth;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.Path1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.Path1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.lsp.identifiers.tlv.LspIdentifiersBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.lsp.identifiers.tlv.lsp.identifiers.address.family.Ipv4CaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.bandwidth.object.BandwidthBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.Ipv4ExtendedTunnelId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.LspId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.Node1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.Node1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.PccSyncState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.PathComputationClientBuilder;
final Node dst;
final Node src;
- if (tunnelTopo.getNode().get(0).getNodeId().equals(srcId)) {
- src = tunnelTopo.getNode().get(0);
- dst = tunnelTopo.getNode().get(1);
+ final Iterator<Node> it = tunnelTopo.nonnullNode().values().iterator();
+ final Node tmp = it.next();
+ if (tmp.getNodeId().equals(srcId)) {
+ src = tmp;
+ dst = it.next();
} else {
- src = tunnelTopo.getNode().get(1);
- dst = tunnelTopo.getNode().get(0);
+ src = it.next();
+ dst = tmp;
}
Assert.assertEquals(srcId, src.getNodeId());
Assert.assertEquals(1, dst.getTerminationPoint().size());
Assert.assertEquals(1, src.getTerminationPoint().size());
- final TerminationPoint dstTp = dst.getTerminationPoint().get(0);
- final TerminationPoint srcTp = src.getTerminationPoint().get(0);
+ final TerminationPoint dstTp = dst.nonnullTerminationPoint().values().iterator().next();
+ final TerminationPoint srcTp = src.nonnullTerminationPoint().values().iterator().next();
final TpId dstNodeTpId = new TpId(dstId.getValue());
final TpId srcNodeTpId = new TpId(srcId.getValue());
Assert.assertEquals(dstNodeTpId, dstTp.getTpId());
Assert.assertEquals(1, src.getSupportingNode().size());
Assert.assertNull(dst.getSupportingNode());
- final SupportingNode sNode = src.getSupportingNode().get(0);
+ final SupportingNode sNode = src.nonnullSupportingNode().values().iterator().next();
Assert.assertEquals(NODE1_ID, sNode.key().getNodeRef());
- Assert.assertEquals(1, tunnelTopo.getLink().size());
- final Link link = tunnelTopo.getLink().get(0);
+ Assert.assertEquals(1, tunnelTopo.nonnullLink().size());
+ final Link link = tunnelTopo.nonnullLink().values().iterator().next();
Assert.assertEquals(srcId, link.getSource().getSourceNode());
Assert.assertEquals(srcNodeTpId, link.getSource().getSourceTp());
Assert.assertEquals(dstId, link.getDestination().getDestNode());
assertNotNull(updatedNodeTopo.getNode());
Assert.assertEquals(2, updatedNodeTopo.getNode().size());
final Node updatedNode;
- if (updatedNodeTopo.getNode().get(0).getNodeId().equals(srcId)) {
- updatedNode = updatedNodeTopo.getNode().get(1);
+ if (updatedNodeTopo.nonnullNode().values().iterator().next().getNodeId().equals(srcId)) {
+ updatedNode = Iterables.get(updatedNodeTopo.nonnullNode().values(), 1);
} else {
- updatedNode = updatedNodeTopo.getNode().get(0);
+ updatedNode = updatedNodeTopo.nonnullNode().values().iterator().next();
}
assertNotNull(updatedNode.getSupportingNode());
- Assert.assertEquals(1, updatedNode.getSupportingNode().size());
- final SupportingNode sNode2 = updatedNode.getSupportingNode().get(0);
+ Assert.assertEquals(1, updatedNode.nonnullSupportingNode().size());
+ final SupportingNode sNode2 = updatedNode.nonnullSupportingNode().values().iterator().next();
Assert.assertEquals(NODE2_ID, sNode2.getNodeRef());
Assert.assertEquals(2, updatedNodeTopo.getLink().size());
return updatedNodeTopo;
});
readDataOperational(getDataBroker(), TUNNEL_TOPO_IID, updatedNodeTopo -> {
- final Link link2;
- if (updatedNodeTopo.getLink().get(0).getSource().getSourceNode().equals(srcId)) {
- link2 = updatedNodeTopo.getLink().get(1);
- } else {
- link2 = updatedNodeTopo.getLink().get(0);
+ Link link2;
+ Iterator<Link> it2 = updatedNodeTopo.nonnullLink().values().iterator();
+ link2 = it2.next();
+ if (srcId.equals(link2.getSource().getSourceNode())) {
+ link2 = it2.next();
}
+
assertEquals(dstId, link2.getSource().getSourceNode());
assertEquals(dstNodeTpId, link2.getSource().getSourceTp());
assertEquals(srcId, link2.getDestination().getDestNode());
pathBuilder.withKey(new PathKey(new LspId(lspId)));
pathBuilder.setBandwidth(new BandwidthBuilder().setBandwidth(
new Bandwidth(new byte[]{0x00, 0x00, (byte) 0xff, (byte) 0xff})).build());
- pathBuilder.addAugmentation(Path1.class, new Path1Builder().setLsp(new LspBuilder().setTlvs(new TlvsBuilder()
+ pathBuilder.addAugmentation(new Path1Builder().setLsp(new LspBuilder().setTlvs(new TlvsBuilder()
.setLspIdentifiers(new LspIdentifiersBuilder().setAddressFamily(new Ipv4CaseBuilder().setIpv4(
new Ipv4Builder().setIpv4TunnelSenderAddress(new Ipv4AddressNoZone(ipv4Address))
.setIpv4ExtendedTunnelId(new Ipv4ExtendedTunnelId(ipv4Address))
.setReportedLsp(Lists.newArrayList(reportedLps))
.setIpAddress(new IpAddressNoZone(new Ipv4AddressNoZone(ipv4Address)))
.build());
- nodeBuilder.addAugmentation(Node1.class, node1Builder.build());
+ nodeBuilder.addAugmentation(node1Builder.build());
final WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
wTx.put(LogicalDatastoreType.OPERATIONAL, PCEP_TOPO_IID.builder().child(Node.class,
new NodeKey(nodeId)).build(), nodeBuilder.build());
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.concepts.rev131125.Bandwidth;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.topology.rev140113.NetworkTopologyRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.AdministrativeStatus;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.PcepCreateP2pTunnelInput1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.PcepCreateP2pTunnelInput1Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.PcepUpdateTunnelInput1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.PcepUpdateTunnelInput1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.ClassType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.endpoints.address.family.Ipv4Case;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev181109.PcepCreateP2pTunnelInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev181109.PcepDestroyTunnelInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev181109.PcepUpdateTunnelInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.ExplicitHops1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.ExplicitHops1Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.Link1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.Link1Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.SupportingNode1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.SupportingNode1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.tunnel.pcep.supporting.node.attributes.PathComputationClientBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.programming.rev130930.create.p2p.tunnel.input.DestinationBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.node.attributes.SupportingNode;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.node.attributes.SupportingNodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.node.attributes.SupportingNodeKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.TerminationPoint1;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.TerminationPoint1Builder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.igp.termination.point.attributes.IgpTerminationPointAttributesBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.igp.termination.point.attributes.igp.termination.point.attributes.termination.point.type.IpBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint8;
import org.osgi.framework.BundleContext;
final TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
tpBuilder.setTpId(tpId);
tpBuilder.withKey(new TerminationPointKey(tpId));
- tpBuilder.addAugmentation(TerminationPoint1.class, new TerminationPoint1Builder()
+ tpBuilder.addAugmentation(new TerminationPoint1Builder()
.setIgpTerminationPointAttributes(new IgpTerminationPointAttributesBuilder()
.setTerminationPointType(new IpBuilder()
.setIpAddress(Collections.singletonList(new IpAddress(new Ipv4Address(ipv4Address))))
nodeBuilder.setTerminationPoint(Lists.newArrayList(tpBuilder.build()));
final SupportingNode supportingNode = new SupportingNodeBuilder()
.withKey(new SupportingNodeKey(nodeId, new TopologyId("dummy")))
- .addAugmentation(SupportingNode1.class, new SupportingNode1Builder()
+ .addAugmentation(new SupportingNode1Builder()
.setPathComputationClient(new PathComputationClientBuilder()
.setControlling(true).build()).build()).build();
nodeBuilder.setSupportingNode(Lists.newArrayList(supportingNode));
return nodeBuilder.build();
}
- private static ExplicitHops createExplicitHop(final String ipv4Prefix) {
- final ExplicitHopsBuilder explcitHopsBuilder = new ExplicitHopsBuilder();
- explcitHopsBuilder.addAugmentation(ExplicitHops1.class, new ExplicitHops1Builder()
- .setSubobjectType(new IpPrefixCaseBuilder().setIpPrefix(new IpPrefixBuilder()
- .setIpPrefix(new IpPrefix(new Ipv4Prefix(ipv4Prefix))).build()).build()).build());
- return explcitHopsBuilder.build();
+ private static ExplicitHops createExplicitHop(final String ipv4Prefix, Uint32 order) {
+ return new ExplicitHopsBuilder()
+ .setOrder(order)
+ .addAugmentation(new ExplicitHops1Builder()
+ .setSubobjectType(new IpPrefixCaseBuilder().setIpPrefix(new IpPrefixBuilder()
+ .setIpPrefix(new IpPrefix(new Ipv4Prefix(ipv4Prefix))).build()).build())
+ .build())
+ .build();
}
@Before
createInputBuilder.setClassType(classType);
createInputBuilder.setSymbolicPathName(tunnelName);
createInputBuilder.setExplicitHops(Collections.emptyList());
- createInputBuilder.addAugmentation(PcepCreateP2pTunnelInput1.class, new PcepCreateP2pTunnelInput1Builder()
+ createInputBuilder.addAugmentation(new PcepCreateP2pTunnelInput1Builder()
.setAdministrativeStatus(AdministrativeStatus.Active).build());
this.tunnelProgramming.pcepCreateP2pTunnel(createInputBuilder.build());
//check add-lsp input
updateInputBuilder.setNetworkTopologyRef(topologyRef);
updateInputBuilder.setBandwidth(bwd);
updateInputBuilder.setClassType(classType);
- updateInputBuilder.setExplicitHops(Lists.newArrayList(createExplicitHop(IPV4_PREFIX1),
- createExplicitHop(IPV4_PREFIX2)));
+ updateInputBuilder.setExplicitHops(Lists.newArrayList(createExplicitHop(IPV4_PREFIX1, Uint32.ONE),
+ createExplicitHop(IPV4_PREFIX2, Uint32.TWO)));
updateInputBuilder.setLinkId(LINK1_ID);
- updateInputBuilder.addAugmentation(PcepUpdateTunnelInput1.class, new PcepUpdateTunnelInput1Builder()
+ updateInputBuilder.addAugmentation(new PcepUpdateTunnelInput1Builder()
.setAdministrativeStatus(AdministrativeStatus.Active).build());
this.tunnelProgramming.pcepUpdateTunnel(updateInputBuilder.build());
//check update-lsp input
.rev131021.link.attributes.DestinationBuilder().setDestNode(NODE2_ID).setDestTp(TP2_ID).build());
linkBuilder.setLinkId(LINK1_ID);
linkBuilder.withKey(new LinkKey(LINK1_ID));
- linkBuilder.addAugmentation(Link1.class, new Link1Builder().setSymbolicPathName(LINK1_ID.getValue()).build());
+ linkBuilder.addAugmentation(new Link1Builder().setSymbolicPathName(LINK1_ID.getValue()).build());
final WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
wTx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL,
TOPO_IID.builder().child(Link.class, new LinkKey(LINK1_ID)).build(), linkBuilder.build());
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<artifactId>yang-parser-api</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
<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>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.protocol.rsvp.parser.spi.subobjects;
import static java.util.Objects.requireNonNull;
import com.google.common.base.Preconditions;
-
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import java.util.ArrayList;
<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</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<artifactId>netty-transport</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
<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>
Code Review / bgpcep.git / commitdiff