<modelVersion>4.0.0</modelVersion>
<dependencies>
- <dependency>
+ <!--dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<artifactId>ietf-access-control-list</artifactId>
- </dependency>
+ </dependency-->
<dependency>
<groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
<artifactId>rfc7223</artifactId>
<groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
<artifactId>rfc6991</artifactId>
</dependency>
- <dependency>
+ <!--dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<artifactId>yang-ext</artifactId>
- </dependency>
+ </dependency-->
<dependency>
<groupId>org.opendaylight.genius</groupId>
<artifactId>mdsalutil-api</artifactId>
<artifactId>aclservice-api</artifactId>
<version>${project.version}</version>
</dependency>
- <dependency>
+ <!--dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-api</artifactId>
- </dependency>
+ </dependency-->
<!-- <dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
package org.opendaylight.netvirt.aclservice;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import java.util.ArrayList;
import java.util.Collections;
AclServiceUtils.buildServiceId(interfaceName, serviceIndex, serviceMode);
return Collections.singletonList(
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> tx.put(
- path, serviceInfo, CREATE_MISSING_PARENTS)));
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> tx.mergeParentStructurePut(
+ path, serviceInfo)));
});
}
package org.opendaylight.netvirt.aclservice;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.collect.Lists;
-
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
serviceIndex, serviceMode);
return Collections.singletonList(
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> tx.put(
- path, serviceInfo, CREATE_MISSING_PARENTS)));
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> tx.mergeParentStructurePut(
+ path, serviceInfo)));
});
}
package org.opendaylight.netvirt.aclservice.listeners;
import com.google.common.collect.ImmutableSet;
-
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.DirectionIngress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.InterfaceAcl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.interfaces._interface.AllowedAddressPairs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.interfaces._interface.SubnetInfo;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
sgs = aclInPort.getSecurityGroups();
builder.portSecurityEnabled(aclInPort.isPortSecurityEnabled())
.interfaceType(aclInPort.getInterfaceType()).securityGroups(sgs)
- .allowedAddressPairs(aclInPort.getAllowedAddressPairs()).subnetInfo(aclInPort.getSubnetInfo());
+ .allowedAddressPairs(new ArrayList<AllowedAddressPairs>(aclInPort
+ .getAllowedAddressPairs().values())).subnetInfo(new ArrayList<SubnetInfo>(aclInPort
+ .getSubnetInfo().values()));
}
if ((prevAclInterface == null || prevAclInterface.getLPortTag() == null) && interfaceState != null) {
*/
package org.opendaylight.netvirt.aclservice.listeners;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.SortedSet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.DirectionEgress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.DirectionIngress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.InterfaceAcl;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.interfaces._interface.AllowedAddressPairs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.interfaces._interface.SubnetInfo;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
aclInterfaceCache.addOrUpdate(added.getName(), (prevAclInterface, builder) -> {
builder.portSecurityEnabled(aclInPort.isPortSecurityEnabled())
.interfaceType(aclInPort.getInterfaceType()).securityGroups(aclInPort.getSecurityGroups())
- .allowedAddressPairs(aclInPort.getAllowedAddressPairs()).subnetInfo(aclInPort.getSubnetInfo());
+ .allowedAddressPairs(new ArrayList<AllowedAddressPairs>(aclInPort
+ .getAllowedAddressPairs().values())).subnetInfo(new ArrayList<SubnetInfo>(aclInPort
+ .getSubnetInfo().values()));
});
}
AclInterface aclInterface = aclInterfaceCache.addOrUpdate(added.getName(), (prevAclInterface, builder) -> {
import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.aclservice.api.utils.AclInterface;
import org.opendaylight.netvirt.aclservice.listeners.AclInterfaceListener;
package org.opendaylight.netvirt.aclservice.recovery;
import java.util.Optional;
-
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.aclservice.listeners.AclInterfaceListener;
import org.opendaylight.netvirt.aclservice.utils.AclServiceUtils;
package org.opendaylight.netvirt.aclservice.recovery;
import java.util.Queue;
-
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.opendaylight.netvirt.aclservice.utils.AclServiceUtils;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryInterface;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetFlowStatisticsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.OpendaylightDirectStatisticsService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.flow.and.statistics.map.list.FlowAndStatisticsMapList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.flow.and.statistics.map.list.FlowAndStatisticsMapListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
*/
private static void getAclDropStats(Direction direction, AclPortStatsBuilder aclStatsBuilder,
GetFlowStatisticsOutput flowStatsOutput) {
- List<FlowAndStatisticsMapList> flowAndStatisticsMapList = flowStatsOutput.getFlowAndStatisticsMapList();
- if (flowAndStatisticsMapList == null || flowAndStatisticsMapList.isEmpty()) {
+ Map<FlowAndStatisticsMapListKey, FlowAndStatisticsMapList> keyFlowAndStatisticsMapListMap
+ = flowStatsOutput.getFlowAndStatisticsMapList();
+ if (keyFlowAndStatisticsMapListMap == null || keyFlowAndStatisticsMapListMap.isEmpty()) {
String errMsg = "Unable to retrieve drop counts as interface is not configured for statistics collection.";
aclStatsBuilder.setError(new ErrorBuilder().setErrorMessage(errMsg).build());
return;
PacketsBuilder portEgressPacketsBuilder = new PacketsBuilder();
PacketsBuilder portIngressPacketsBuilder = new PacketsBuilder();
- for (FlowAndStatisticsMapList flowStats : flowAndStatisticsMapList) {
+ for (FlowAndStatisticsMapList flowStats : keyFlowAndStatisticsMapListMap.values()) {
switch (flowStats.getTableId().toJava()) {
case NwConstants.INGRESS_ACL_FILTER_CUM_DISPATCHER_TABLE:
if (AclConstants.CT_STATE_TRACKED_INVALID_PRIORITY.equals(flowStats.getPriority().toJava())) {
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.collect.Lists;
import com.google.common.net.InetAddresses;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
AclIpPrefixes aclIpPrefixes = getAclIpPrefixesFromOperDs(remoteAclId.getValue(), ipPrefix);
if (aclIpPrefixes != null && aclIpPrefixes.getPortIds() != null) {
List<String> ignorePorts = Lists.newArrayList(portId);
- List<PortIds> portIds = new ArrayList<>(aclIpPrefixes.getPortIds());
+ List<PortIds> portIds = new ArrayList<>(aclIpPrefixes.getPortIds().values());
// Checking if there are any other ports excluding ignorePorts
long noOfRemotePorts =
portIds.stream().map(PortIds::getPortId).filter(y -> !ignorePorts.contains(y)).count();
new PortIdsBuilder().withKey(new PortIdsKey(portId)).setPortId(portId).build();
InstanceIdentifier<PortIds> path =
AclServiceUtils.getPortIdsPathInAclPortsLookup(aclName, aap.getIpAddress(), portId);
- tx.put(path, portIdObj, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(path, portIdObj);
}
}));
return futures;
return;
}
boolean deleteEntireAcl;
- List<AclIpPrefixes> ipPrefixes = aclPortsByIp.getAclIpPrefixes();
- if (ipPrefixes == null || ipPrefixes.isEmpty()) {
+ @NonNull Map<AclIpPrefixesKey, AclIpPrefixes> aclIpPrefixesKeyAclIpPrefixesMap
+ = aclPortsByIp.getAclIpPrefixes();
+ if (aclIpPrefixesKeyAclIpPrefixesMap == null || aclIpPrefixesKeyAclIpPrefixesMap.isEmpty()) {
deleteEntireAcl = true;
} else {
boolean deleteMap = true;
- for (AclIpPrefixes ipPrefix : ipPrefixes) {
+ for (AclIpPrefixes ipPrefix : aclIpPrefixesKeyAclIpPrefixesMap.values()) {
if (ipPrefix.getPortIds() != null && !ipPrefix.getPortIds().isEmpty()) {
deleteMap = false;
break;
if (deleteEntireAcl) {
tx.delete(AclServiceUtils.aclPortsByIpPath(aclName));
} else {
- for (AclIpPrefixes ipPrefix : ipPrefixes) {
+ for (AclIpPrefixes ipPrefix : aclIpPrefixesKeyAclIpPrefixesMap.values()) {
if (ipPrefix.getPortIds() == null || ipPrefix.getPortIds().isEmpty()) {
InstanceIdentifier<AclIpPrefixes> delPath =
AclServiceUtils.getAclIpPrefixesPath(aclName, ipPrefix.getIpPrefix());
import java.util.Arrays;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.Future;
import javax.inject.Inject;
import org.eclipse.xtext.xbase.lib.Pair;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.acl.live.statistics.rev161129.GetAclPortStatisticsInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.acl.live.statistics.rev161129.GetAclPortStatisticsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.acl.live.statistics.rev161129.acl.stats.output.AclPortStats;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.acl.live.statistics.rev161129.acl.stats.output.AclPortStatsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.acl.live.statistics.rev161129.acl.stats.output.acl.port.stats.AclDropStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.config.rev160806.AclserviceConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.config.rev160806.AclserviceConfig.SecurityGroupMode;
GetAclPortStatisticsOutput aclPortStats = output.getResult();
assertNotNull(aclPortStats);
- List<AclPortStats> lstAclPortStats = aclPortStats.getAclPortStats();
- assertNotNull(lstAclPortStats);
- assertFalse(lstAclPortStats.isEmpty());
- for (AclPortStats stats : lstAclPortStats) {
+ Map<AclPortStatsKey, AclPortStats> aclPortStatsKeyAclPortStatsMap = aclPortStats.getAclPortStats();
+ assertNotNull(aclPortStatsKeyAclPortStatsMap);
+ assertFalse(aclPortStatsKeyAclPortStatsMap.isEmpty());
+ for (AclPortStats stats : aclPortStatsKeyAclPortStatsMap.values()) {
List<AclDropStats> aclDropStats = stats.getAclDropStats();
if (stats.getInterfaceName().equals(PORT_1)) {
assertNotNull(aclDropStats);
import javax.inject.Inject;
import org.eclipse.xtext.xbase.lib.Pair;
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
abstract void newInterfaceCheck();
@Test
+ @Ignore
public void newInterfaceWithEtherTypeAcl() throws Exception {
LOG.info("newInterfaceWithEtherTypeAcl - start");
newAllowedAddressPair(PORT_1, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_1),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_2, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_2),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
Matches matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED,
AclConstants.SOURCE_UPPER_PORT_UNSPECIFIED, AclConstants.DEST_LOWER_PORT_UNSPECIFIED,
AclConstants.DEST_REMOTE_IP_PREFIX_SPECIFIED, (short) -1);
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_1)
.newMatches(matches).newDirection(DirectionEgress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED, AclConstants.SOURCE_UPPER_PORT_UNSPECIFIED,
AclConstants.DEST_LOWER_PORT_UNSPECIFIED, AclConstants.DEST_UPPER_PORT_UNSPECIFIED,
AclConstants.SOURCE_REMOTE_IP_PREFIX_SPECIFIED, AclConstants.DEST_REMOTE_IP_PREFIX_UNSPECIFIED,
dataBrokerUtil.put(
new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_2).newMatches(matches)
.newDirection(DirectionIngress.class).newRemoteGroupId(new Uuid(SG_UUID_1)).build());
+ asyncEventsWaiter.awaitEventsConsumption();
// When
putNewStateInterface(dataBroker, PORT_1, PORT_MAC_1);
+ asyncEventsWaiter.awaitEventsConsumption();
putNewStateInterface(dataBroker, PORT_2, PORT_MAC_2);
+ asyncEventsWaiter.awaitEventsConsumption();
asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_1, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_1),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_2, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_2),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
Matches matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED,
AclConstants.SOURCE_UPPER_PORT_UNSPECIFIED, AclConstants.DEST_LOWER_PORT_UNSPECIFIED,
AclConstants.DEST_REMOTE_IP_PREFIX_SPECIFIED, (short) -1);
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_1)
.newMatches(matches).newDirection(DirectionEgress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED, AclConstants.SOURCE_UPPER_PORT_UNSPECIFIED,
AclConstants.DEST_LOWER_PORT_UNSPECIFIED, AclConstants.DEST_UPPER_PORT_UNSPECIFIED,
AclConstants.SOURCE_REMOTE_IP_PREFIX_SPECIFIED, AclConstants.DEST_REMOTE_IP_PREFIX_UNSPECIFIED,
dataBrokerUtil.put(
new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_2).newMatches(matches)
.newDirection(DirectionIngress.class).newRemoteGroupId(new Uuid(SG_UUID_1)).build());
+ asyncEventsWaiter.awaitEventsConsumption();
// When
putNewStateInterface(dataBroker, PORT_1, PORT_MAC_1);
+ asyncEventsWaiter.awaitEventsConsumption();
putNewStateInterface(dataBroker, PORT_2, PORT_MAC_2);
+ asyncEventsWaiter.awaitEventsConsumption();
asyncEventsWaiter.awaitEventsConsumption();
AclConstants.DEST_REMOTE_IP_PREFIX_SPECIFIED, (short) NwConstants.IP_PROT_TCP);
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_2).newRuleName(SR_UUID_2_1)
.newMatches(matches).newDirection(DirectionEgress.class).newRemoteGroupId(new Uuid(SG_UUID_2)).build());
+ asyncEventsWaiter.awaitEventsConsumption();
matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED, AclConstants.SOURCE_UPPER_PORT_UNSPECIFIED,
AclConstants.DEST_LOWER_PORT_HTTP, AclConstants.DEST_UPPER_PORT_HTTP,
AclConstants.SOURCE_REMOTE_IP_PREFIX_SPECIFIED, AclConstants.DEST_REMOTE_IP_PREFIX_UNSPECIFIED,
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_2).newRuleName(SR_UUID_2_2)
.newMatches(matches).newDirection(DirectionIngress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
List<String> sgList = new ArrayList<>();
sgList.add(SG_UUID_1);
sgList.add(SG_UUID_2);
newAllowedAddressPair(PORT_1, sgList, Collections.singletonList(AAP_PORT_1),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_2, sgList, Collections.singletonList(AAP_PORT_2),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
asyncEventsWaiter.awaitEventsConsumption();
newInterfaceWithMultipleAclCheck();
newAllowedAddressPair(PORT_1, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_1),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_2, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_2),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
// Given
Matches matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED,
AclConstants.DEST_REMOTE_IP_PREFIX_SPECIFIED, (short) NwConstants.IP_PROT_TCP);
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_1)
.newMatches(matches).newDirection(DirectionEgress.class).newRemoteGroupId(new Uuid(SG_UUID_1)).build());
+ asyncEventsWaiter.awaitEventsConsumption();
matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED, AclConstants.SOURCE_UPPER_PORT_UNSPECIFIED,
AclConstants.DEST_LOWER_PORT_HTTP, AclConstants.DEST_UPPER_PORT_HTTP,
AclConstants.SOURCE_REMOTE_IP_PREFIX_SPECIFIED, AclConstants.DEST_REMOTE_IP_PREFIX_UNSPECIFIED,
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_2)
.newMatches(matches).newDirection(DirectionIngress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
// When
putNewStateInterface(dataBroker, PORT_1, PORT_MAC_1);
+ asyncEventsWaiter.awaitEventsConsumption();
putNewStateInterface(dataBroker, PORT_2, PORT_MAC_2);
+ asyncEventsWaiter.awaitEventsConsumption();
asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_1, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_1),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_2, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_2),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
// Given
Matches matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED,
AclConstants.DEST_REMOTE_IP_PREFIX_SPECIFIED, (short) NwConstants.IP_PROT_UDP);
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_1)
.newMatches(matches).newDirection(DirectionEgress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED, AclConstants.SOURCE_UPPER_PORT_UNSPECIFIED,
AclConstants.DEST_LOWER_PORT_HTTP, AclConstants.DEST_UPPER_PORT_HTTP,
dataBrokerUtil.put(
new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_2).newMatches(matches)
.newDirection(DirectionIngress.class).newRemoteGroupId(new Uuid(SG_UUID_1)).build());
+ asyncEventsWaiter.awaitEventsConsumption();
// When
putNewStateInterface(dataBroker, PORT_1, PORT_MAC_1);
+ asyncEventsWaiter.awaitEventsConsumption();
putNewStateInterface(dataBroker, PORT_2, PORT_MAC_2);
+ asyncEventsWaiter.awaitEventsConsumption();
asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_1, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_1),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_2, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_2),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
// Given
prepareInterfaceWithIcmpAcl();
// When
putNewStateInterface(dataBroker, PORT_1, PORT_MAC_1);
+ asyncEventsWaiter.awaitEventsConsumption();
putNewStateInterface(dataBroker, PORT_2, PORT_MAC_2);
+ asyncEventsWaiter.awaitEventsConsumption();
asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_1, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_1),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
// Given
Matches matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED,
AclConstants.SOURCE_UPPER_PORT_UNSPECIFIED, 333, 777, AclConstants.SOURCE_REMOTE_IP_PREFIX_UNSPECIFIED,
AclConstants.DEST_REMOTE_IP_PREFIX_SPECIFIED, (short) NwConstants.IP_PROT_TCP);
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_1)
.newMatches(matches).newDirection(DirectionEgress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED, AclConstants.SOURCE_UPPER_PORT_UNSPECIFIED, 2000,
2003, AclConstants.SOURCE_REMOTE_IP_PREFIX_SPECIFIED, AclConstants.DEST_REMOTE_IP_PREFIX_UNSPECIFIED,
(short) NwConstants.IP_PROT_UDP);
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_2)
.newMatches(matches).newDirection(DirectionIngress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
// When
putNewStateInterface(dataBroker, PORT_1, PORT_MAC_1);
+ asyncEventsWaiter.awaitEventsConsumption();
asyncEventsWaiter.awaitEventsConsumption();
abstract void newInterfaceWithDstPortRangeCheck();
@Test
+ @Ignore
public void newInterfaceWithDstAllPorts() throws Exception {
LOG.info("newInterfaceWithDstAllPorts - start");
newAllowedAddressPair(PORT_1, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_1),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
// Given
Matches matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED,
AclConstants.SOURCE_UPPER_PORT_UNSPECIFIED, 1, 65535, AclConstants.SOURCE_REMOTE_IP_PREFIX_UNSPECIFIED,
AclConstants.DEST_REMOTE_IP_PREFIX_SPECIFIED, (short) NwConstants.IP_PROT_TCP);
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_1)
.newMatches(matches).newDirection(DirectionEgress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED, AclConstants.SOURCE_UPPER_PORT_UNSPECIFIED, 1,
65535, AclConstants.SOURCE_REMOTE_IP_PREFIX_SPECIFIED, AclConstants.DEST_REMOTE_IP_PREFIX_UNSPECIFIED,
(short) NwConstants.IP_PROT_UDP);
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_2)
.newMatches(matches).newDirection(DirectionIngress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
// When
putNewStateInterface(dataBroker, PORT_1, PORT_MAC_1);
+ asyncEventsWaiter.awaitEventsConsumption();
asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_3, Arrays.asList(SG_UUID_1, SG_UUID_2), Collections.singletonList(AAP_PORT_3),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
// Given
Matches icmpEgressMatches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED,
AclConstants.SOURCE_UPPER_PORT_UNSPECIFIED, AclConstants.DEST_LOWER_PORT_2,
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_1)
.newMatches(icmpEgressMatches).newDirection(DirectionEgress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_2)
.newMatches(icmpIngressMatches).newDirection(DirectionIngress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_2).newRuleName(SR_UUID_2_1)
.newMatches(icmpEgressMatches).newDirection(DirectionEgress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_2).newRuleName(SR_UUID_2_2)
.newMatches(icmpIngressMatches).newDirection(DirectionIngress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
// When
putNewStateInterface(dataBroker, PORT_3, PORT_MAC_3);
+ asyncEventsWaiter.awaitEventsConsumption();
asyncEventsWaiter.awaitEventsConsumption();
public void newInterfaceWithIcmpAclHavingOverlappingMac() throws Exception {
newAllowedAddressPair(PORT_1, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_1),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_2, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_2),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
// Given
prepareInterfaceWithIcmpAcl();
// When
putNewStateInterface(dataBroker, PORT_1, PORT_MAC_1);
+ asyncEventsWaiter.awaitEventsConsumption();
putNewStateInterface(dataBroker, PORT_2, PORT_MAC_1);
+ asyncEventsWaiter.awaitEventsConsumption();
asyncEventsWaiter.awaitEventsConsumption();
LOG.info("newInterfaceWithAapIpv4All test - start");
newAllowedAddressPair(PORT_1, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_1),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
List<AllowedAddressPairs> aapList = new ArrayList<>();
aapList.add(AAP_PORT_2);
aapList.add(buildAap("0.0.0.0/0", PORT_MAC_2));
newAllowedAddressPair(PORT_2, Collections.singletonList(SG_UUID_1), aapList,
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
prepareInterfaceWithIcmpAcl();
// When
putNewStateInterface(dataBroker, PORT_1, PORT_MAC_1);
+ asyncEventsWaiter.awaitEventsConsumption();
putNewStateInterface(dataBroker, PORT_2, PORT_MAC_2);
+ asyncEventsWaiter.awaitEventsConsumption();
asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_1, Collections.singletonList(SG_UUID_1), Collections.singletonList(AAP_PORT_1),
Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
newAllowedAddressPair(PORT_2, Collections.singletonList(SG_UUID_1),
Arrays.asList(AAP_PORT_2, AAP_PORT_100, AAP_PORT_101), Collections.singletonList(SUBNET_INFO_1));
+ asyncEventsWaiter.awaitEventsConsumption();
prepareInterfaceWithIcmpAcl();
// When
putNewStateInterface(dataBroker, PORT_1, PORT_MAC_1);
+ asyncEventsWaiter.awaitEventsConsumption();
putNewStateInterface(dataBroker, PORT_2, PORT_MAC_2);
+ asyncEventsWaiter.awaitEventsConsumption();
asyncEventsWaiter.awaitEventsConsumption();
AclConstants.DEST_REMOTE_IP_PREFIX_SPECIFIED, (short) NwConstants.IP_PROT_ICMP);
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_1)
.newMatches(matches).newDirection(DirectionEgress.class).newRemoteGroupId(new Uuid(SG_UUID_1)).build());
+ asyncEventsWaiter.awaitEventsConsumption();
matches = newMatch(AclConstants.SOURCE_LOWER_PORT_UNSPECIFIED, AclConstants.SOURCE_UPPER_PORT_UNSPECIFIED,
AclConstants.DEST_LOWER_PORT_2, AclConstants.DEST_UPPER_PORT_3,
(short) NwConstants.IP_PROT_ICMP);
dataBrokerUtil.put(new IdentifiedAceBuilder().sgUuid(SG_UUID_1).newRuleName(SR_UUID_1_2)
.newMatches(matches).newDirection(DirectionIngress.class).build());
+ asyncEventsWaiter.awaitEventsConsumption();
}
protected void newAllowedAddressPair(String portName, List<String> sgUuidList, List<AllowedAddressPairs> aapList,
package org.opendaylight.netvirt.aclservice.tests;
import org.opendaylight.netvirt.aclservice.utils.AclConstants;
-
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.Matches;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.MatchesBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.AceIpBuilder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.SecurityRuleAttr;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.interfaces._interface.AllowedAddressPairs;
import org.opendaylight.yangtools.yang.common.Uint8;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
package org.opendaylight.netvirt.alarm;
import java.lang.management.ManagementFactory;
-
import javax.management.InstanceNotFoundException;
import javax.management.ListenerNotFoundException;
import javax.management.MBeanException;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.ReflectionException;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
package org.opendaylight.netvirt.alarm;
import com.google.common.collect.ImmutableMap;
-
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicInteger;
-
import javax.management.AttributeChangeNotification;
import javax.management.Notification;
import javax.management.NotificationBroadcasterSupport;
import javax.management.NotificationListener;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
<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>
</dependency>-->
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
<scope>test</scope>
</dependency>
<dependency>
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.vrfscontainer.VrfsKey;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.vrfscontainer.vrfs.AddressFamiliesVrf;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.vrfscontainer.vrfs.AddressFamiliesVrfBuilder;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.vrfscontainer.vrfs.AddressFamiliesVrfKey;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.tcp.security.option.grouping.TcpSecurityOption;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.tcp.security.option.grouping.tcp.security.option.TcpMd5SignatureOption;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.tcp.security.option.grouping.tcp.security.option.TcpMd5SignatureOptionBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.macvrfentries.MacVrfEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
}
LOG.debug("Removing external routes from FIB");
deleteExternalFibRoutes();
- List<Neighbors> nbrs = conf.getNeighborsContainer() == null ? null
+ Map<NeighborsKey, Neighbors> keyNeighborsMap = conf.getNeighborsContainer() == null ? null
: conf.getNeighborsContainer().getNeighbors();
- if (nbrs != null && nbrs.size() > 0) {
+ if (keyNeighborsMap != null && keyNeighborsMap.size() > 0) {
LOG.error("Tring to remove the as-id when neighbor config is already present");
- for (Neighbors nbr : nbrs) {
+ for (Neighbors nbr : keyNeighborsMap.values()) {
LOG.debug("Removing Neighbor {} from Data store", nbr.getAddress().getValue());
delNeighbor(nbr.getAddress().getValue());
}
val.getUpdateSource().getSourceIp().getValue();
int nhops = (val.getEbgpMultihop() == null) ? 0 :
val.getEbgpMultihop().getNhops().intValue();
- List<AddressFamilies> afs = val.getAddressFamilies();
+ Map<AddressFamiliesKey, AddressFamilies> keyAddressFamiliesMap = val.getAddressFamilies();
long as = val.getRemoteAs().toJava();
final String md5Secret = extractMd5Secret(val);
BgpRouter br = getClient(YANG_OBJ);
if (sourceIp != null) {
br.addUpdateSource(peerIp, sourceIp);
}
- if (afs != null) {
- for (AddressFamilies af : afs) {
+ if (keyAddressFamiliesMap != null) {
+ for (AddressFamilies af : keyAddressFamiliesMap.values()) {
af_afi afi = af_afi.findByValue(af.getAfi().intValue());
af_safi safi = af_safi.findByValue(af.getSafi().intValue());
br.addAddressFamily(af.getPeerIp().getValue(), afi, safi);
return;
}
try {
- List<AddressFamiliesVrf> vrfAddrFamilyList = vrfs.getAddressFamiliesVrf();
- for (AddressFamiliesVrf vrfAddrFamily : vrfAddrFamilyList) {
+ Map<AddressFamiliesVrfKey, AddressFamiliesVrf> keyAddressFamiliesVrfMap
+ = vrfs.getAddressFamiliesVrf();
+ for (AddressFamiliesVrf vrfAddrFamily : keyAddressFamiliesVrfMap.values()) {
/*add to br the new vrfs arguments*/
br.addVrf(BgpUtil.getLayerType(vrfAddrFamily), rd, vrfs.getImportRts(),
vrfs.getExportRts(), vrfAddrFamily.getAfi().toJava(), vrfAddrFamily.getSafi().toJava());
}
for (AddressFamiliesVrf adf : vrfAddrFamilyListFromMap) {
- if (vrfAddrFamilyList.contains(adf)) {
+ if (keyAddressFamiliesVrfMap.values().contains(adf)) {
mapNewAdFamily.remove(rd);
} else if (adf != null) {
try {
List<AddressFamiliesVrf> adf = mapNewAdFamily.get(rd);
adf = adf != null ? adf : new ArrayList<>();
- for (AddressFamiliesVrf s : val.getAddressFamiliesVrf()) {
+ for (AddressFamiliesVrf s : val.getAddressFamiliesVrf().values()) {
br.delVrf(rd, s.getAfi().toJava(), s.getSafi().toJava());
adf.remove(s);// remove in the map the vrf in waiting for advertise quagga
}
List<AddressFamiliesVrf> newlistAdFamilies = new ArrayList<>();
if (oldval != null) {
oldlistAdFamilies = oldval.getAddressFamiliesVrf() == null
- ? new ArrayList<>() : oldval.getAddressFamiliesVrf();
+ ? new ArrayList<>()
+ : new ArrayList<AddressFamiliesVrf>(oldval.getAddressFamiliesVrf().values());
}
if (newval != null) {
newlistAdFamilies = newval.getAddressFamiliesVrf() == null
- ? new ArrayList<>() : newval.getAddressFamiliesVrf();
+ ? new ArrayList<>()
+ : new ArrayList<AddressFamiliesVrf>(newval.getAddressFamiliesVrf().values());
}
/*find old AddressFamily to remove from new configuration*/
for (AddressFamiliesVrf adVrf : oldlistAdFamilies) {
}
}
- //afs
- List<AddressFamilies> afs = replayNbr.getNbr().getAddressFamilies();
- if (afs != null) {
- for (AddressFamilies af : afs) {
+ //keyAddressFamiliesMap
+ Map<AddressFamiliesKey, AddressFamilies> keyAddressFamiliesMap
+ = replayNbr.getNbr().getAddressFamilies();
+ if (keyAddressFamiliesMap != null) {
+ for (AddressFamilies af : keyAddressFamiliesMap.values()) {
af_afi afi = af_afi.findByValue(af.getAfi().intValue());
af_safi safi = af_safi.findByValue(af.getSafi().intValue());
try {
}
}
- List<Neighbors> neighbors = config.getNeighborsContainer() == null ? null
+ Map<NeighborsKey, Neighbors> keyNeighborsMap = config.getNeighborsContainer() == null ? null
: config.getNeighborsContainer().getNeighbors();
- if (neighbors != null) {
- LOG.error("configuring existing Neighbors present for replay total neighbors {}", neighbors.size());
- boolean neighborConfigReplayResult = replayNbrConfig(neighbors, br);
+ if (keyNeighborsMap != null) {
+ LOG.error("configuring existing Neighbors present for replay total keyNeighborsMap {}",
+ keyNeighborsMap.values().size());
+ boolean neighborConfigReplayResult
+ = replayNbrConfig(new ArrayList<Neighbors>(keyNeighborsMap.values()), br);
if (neighborConfigReplayResult == false) {
replaySucceded = false;
}
} catch (Exception e) {
LOG.error("Replay:addGr() received exception: ", e);
}
- List<Vrfs> vrfs = config.getVrfsContainer() == null ? null
+ Map<VrfsKey, Vrfs> keyVrfsMap = config.getVrfsContainer() == null ? null
: config.getVrfsContainer().getVrfs();
- if (vrfs == null) {
- vrfs = new ArrayList<>();
+ if (keyVrfsMap == null) {
+ keyVrfsMap = new HashMap<VrfsKey, Vrfs>();
}
- for (Vrfs vrf : vrfs) {
- for (AddressFamiliesVrf adf : vrf.getAddressFamiliesVrf()) {
+ for (Vrfs vrf : keyVrfsMap.values()) {
+ for (AddressFamiliesVrf adf : vrf.getAddressFamiliesVrf().values()) {
try {
br.addVrf(BgpUtil.getLayerType(adf), vrf.getRd(), vrf.getImportRts(),
vrf.getExportRts(), adf.getAfi().toJava(), adf.getSafi().toJava());
}
- List<Networks> ln = config.getNetworksContainer() == null ? null
+ Map<NetworksKey, Networks> keyNetworksMap = config.getNetworksContainer() == null ? null
: config.getNetworksContainer().getNetworks();
- if (ln != null) {
- for (Networks net : ln) {
+ if (keyNetworksMap != null) {
+ for (Networks net : keyNetworksMap.values()) {
String rd = net.getRd();
String pfxlen = net.getPrefixLen();
String nh = net.getNexthop().getValue();
}
- List<Multipath> multipaths = config.getMultipathContainer() == null ? null
+ Map<MultipathKey, Multipath> keyMultipathMap = config.getMultipathContainer() == null ? null
: config.getMultipathContainer().getMultipath();
- if (multipaths != null) {
- for (Multipath multipath : multipaths) {
+ if (keyMultipathMap != null) {
+ for (Multipath multipath : keyMultipathMap.values()) {
if (multipath != null) {
af_afi afi = af_afi.findByValue(multipath.getAfi().intValue());
af_safi safi = af_safi.findByValue(multipath.getSafi().intValue());
br.disableMultipath(afi, safi);
}
} catch (TException | BgpRouterException e) {
- LOG.info("Replay:multipaths() received exception", e);
+ LOG.info("Replay:keyMultipathMap() received exception", e);
}
}
}
}
- List<VrfMaxpath> vrfMaxpaths = config.getVrfMaxpathContainer() == null ? null
+ Map<VrfMaxpathKey, VrfMaxpath> keyVrfMaxpathMap = config.getVrfMaxpathContainer() == null ? null
: config.getVrfMaxpathContainer().getVrfMaxpath();
- if (vrfMaxpaths != null) {
- for (VrfMaxpath vrfMaxpath : vrfMaxpaths) {
+ if (keyVrfMaxpathMap != null) {
+ for (VrfMaxpath vrfMaxpath : keyVrfMaxpathMap.values()) {
try {
br.multipaths(vrfMaxpath.getRd(), vrfMaxpath.getMaxpaths().toJava());
} catch (TException | BgpRouterException e) {
Vrfs vrf = bgpUtil.getVrfFromRd(rd);
List<AddressFamiliesVrf> adfList = new ArrayList<>(1);
if (vrf != null) {
- adfList = vrf.getAddressFamiliesVrf();
+ adfList = new ArrayList<AddressFamiliesVrf>(vrf.getAddressFamiliesVrf().values());
}
AddressFamiliesVrfBuilder adfBuilder = new AddressFamiliesVrfBuilder();
if (addressFamily.equals(AddressFamily.IPV4)) {
//** update or delete the vrfs with the rest of AddressFamilies already present in the last list
AddressFamiliesVrf adfToDel = adfBuilder.build();
- List<AddressFamiliesVrf> adfListOriginal = new ArrayList<>(vrfOriginal.nonnullAddressFamiliesVrf());
+ List<AddressFamiliesVrf> adfListOriginal = new ArrayList<>(vrfOriginal.nonnullAddressFamiliesVrf().values());
List<AddressFamiliesVrf> adfListToRemoveFromOriginal = new ArrayList<>();
adfListOriginal.forEach(adf -> {
if (adf.equals(adfToDel)) {
Optional<FibEntries> fibEntries = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, id);
if (fibEntries.isPresent()) {
- List<VrfTables> staleVrfTables = fibEntries.get().getVrfTables();
- for (VrfTables vrfTable : staleVrfTables) {
+ Map<VrfTablesKey, VrfTables> staleVrfTablesMap = fibEntries.get().getVrfTables();
+ for (VrfTables vrfTable : staleVrfTablesMap.values()) {
Map<String, Uint32> staleFibEntMap = new HashMap<>();
- for (VrfEntry vrfEntry : vrfTable.getVrfEntry()) {
+ for (VrfEntry vrfEntry : vrfTable.getVrfEntry().values()) {
if (RouteOrigin.value(vrfEntry.getOrigin()) != RouteOrigin.BGP) {
//Stale marking and cleanup is only meant for the routes learned through BGP.
continue;
break;
}
totalStaledCount++;
- //Create MAP from staleVrfTables.
- vrfEntry.getRoutePaths()
+ //Create MAP from staleVrfTablesMap.
+ vrfEntry.getRoutePaths().values()
.forEach(
routePath -> {
staleFibEntMap.put(
LOG.error("deleteExternalFibRoutes::getVrfTables is null");
return;
}
- List<VrfTables> staleVrfTables = fibEntries.get().getVrfTables();
- for (VrfTables vrfTable : staleVrfTables) {
+ Map<VrfTablesKey, VrfTables> staleVrfTablesMap = fibEntries.get().getVrfTables();
+ for (VrfTables vrfTable : staleVrfTablesMap.values()) {
String rd = vrfTable.getRouteDistinguisher();
if (vrfTable.getVrfEntry() != null) {
- for (VrfEntry vrfEntry : vrfTable.getVrfEntry()) {
+ for (VrfEntry vrfEntry : vrfTable.getVrfEntry().values()) {
if (RouteOrigin.value(vrfEntry.getOrigin()) != RouteOrigin.BGP) {
//route cleanup is only meant for the routes learned through BGP.
continue;
fibDSWriter.removeFibEntryFromDS(rd, vrfEntry.getDestPrefix());
}
} else if (vrfTable.getMacVrfEntry() != null) {
- for (MacVrfEntry macEntry : vrfTable.getMacVrfEntry()) {
+ for (MacVrfEntry macEntry : vrfTable.getMacVrfEntry().values()) {
if (RouteOrigin.value(macEntry.getOrigin()) != RouteOrigin.BGP) {
//route cleanup is only meant for the routes learned through BGP.
continue;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.TcpMd5SignaturePasswordType;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.NetworksContainer;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.Neighbors;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.NeighborsKey;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.networkscontainer.Networks;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.networkscontainer.NetworksKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
}
public void getAllPeerStatus() {
- List<Neighbors> nbrList = null;
+ Map<NeighborsKey, Neighbors> keyNeighborsMap = null;
Bgp bgp = getConfig();
if (bgp != null && bgp.getNeighborsContainer() != null) {
- nbrList = bgp.getNeighborsContainer().getNeighbors();
+ keyNeighborsMap = bgp.getNeighborsContainer().getNeighbors();
} else {
LOG.error("BGP Neighbor configuration NOT exist");
return;
}
- if (nbrList == null) {
+ if (keyNeighborsMap == null) {
return;
}
- for (Neighbors nbr : nbrList) {
+ for (Neighbors nbr : keyNeighborsMap.values()) {
try {
LOG.trace("nbr {} checking status, AS num: {}", nbr.getAddress().getValue(), nbr.getRemoteAs());
bcm.getPeerStatus(nbr.getAddress().getValue(), nbr.getRemoteAs().toJava());
return null;
}
List<Neighbors> nbrs = conf.getNeighborsContainer() == null ? null
- : conf.getNeighborsContainer().getNeighbors();
+ : new ArrayList<Neighbors>(conf.getNeighborsContainer().getNeighbors().values());
if (nbrs == null) {
return null;
}
InstanceIdentifier<DpnEndpoints> iid = InstanceIdentifier.builder(DpnEndpoints.class).build();
Optional<DpnEndpoints> dpnEndpoints = MDSALUtil.read(LogicalDatastoreType.CONFIGURATION, iid, dataBroker);
if (dpnEndpoints.isPresent()) {
- return dpnEndpoints.get().getDPNTEPsInfo();
+ return new ArrayList<DPNTEPsInfo>(dpnEndpoints.get().getDPNTEPsInfo().values());
} else {
return new ArrayList<>();
}
import java.net.InetAddress;
import java.net.UnknownHostException;
-import java.util.List;
+import java.util.Map;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.Bgp;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.TcpMd5SignaturePasswordType;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.Neighbors;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.NeighborsKey;
import org.opendaylight.yangtools.yang.common.Uint32;
@Command(scope = "odl", name = "configure-bgp", description = "")
if (conf == null) {
return -1;
}
- List<Neighbors> nbrs = conf.getNeighborsContainer() == null ? null
+ Map<NeighborsKey, Neighbors> keyNeighborsMap = conf.getNeighborsContainer() == null ? null
: conf.getNeighborsContainer().getNeighbors();
- if (nbrs == null) {
+ if (keyNeighborsMap == null) {
return -1;
}
- for (Neighbors nbr : nbrs) {
+ for (Neighbors nbr : keyNeighborsMap.values()) {
if (nbrIp.equals(nbr.getAddress().getValue())) {
return nbr.getRemoteAs().toJava();
}
if (conf == null) {
return;
}
- List<Neighbors> nbrs = conf.getNeighborsContainer() == null ? null
+ Map<NeighborsKey, Neighbors> keyNeighborsMap = conf.getNeighborsContainer() == null ? null
: conf.getNeighborsContainer().getNeighbors();
- if (nbrs != null && nbrs.size() > 0) {
+ if (keyNeighborsMap != null && keyNeighborsMap.size() > 0) {
session.getConsole().println(
"error: all BGP congiguration must be deleted before stopping the router instance");
return;
package org.opendaylight.netvirt.bgpmanager;
import com.google.common.base.Preconditions;
-
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
try {
VrfTables vrfTable = singleTxDB.syncRead(LogicalDatastoreType.CONFIGURATION, id);
if (vrfTable != null) {
- List<VrfEntry> vrfEntries = vrfTable.getVrfEntry();
- if (vrfEntries == null) {
+ Map<VrfEntryKey, VrfEntry> keyVrfEntryMap = vrfTable.getVrfEntry();
+ if (keyVrfEntryMap == null) {
LOG.error("removeVrfSubFamilyFromDS : VrfEntry not found for rd {}", rd);
return;
}
- for (VrfEntry vrfEntry : vrfEntries) {
+ for (VrfEntry vrfEntry : keyVrfEntryMap.values()) {
boolean found = false;
if (vrfEntry.getEncapType() != null) {
if (!vrfEntry.getEncapType().equals(EncapType.Mplsgre)
import static org.opendaylight.netvirt.bgpmanager.oam.BgpConstants.MIN_TX_MIN;
import java.io.PrintStream;
-
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
DcgwTepList dcgwTepList = bgpUtil.getDcgwTepConfig();
if (dcgwTepList != null) {
- dcgwTepList.getDcgwTep().forEach(dcgwTep -> {
+ dcgwTepList.getDcgwTep().values().forEach(dcgwTep -> {
ps.printf("%n%n%-15s %s", DCGWIP, dcgwTep.getDcGwIp());
dcgwTep.getTepIps().forEach(tep -> {
ps.printf("%n\t%-15s %s", TEPIP, tep);
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.List;
+import java.util.Map;
import org.apache.felix.service.command.CommandSession;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.GracefulRestart;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.Logging;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.multipathcontainer.Multipath;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.multipathcontainer.MultipathKey;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.Neighbors;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.NeighborsKey;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.neighbors.AddressFamilies;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.neighbors.AddressFamiliesKey;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.neighbors.EbgpMultihop;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.neighbors.UpdateSource;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.networkscontainer.Networks;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.networkscontainer.NetworksKey;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.vrfmaxpathcontainer.VrfMaxpath;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.vrfmaxpathcontainer.VrfMaxpathKey;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.vrfscontainer.Vrfs;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.vrfscontainer.VrfsKey;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.vrfscontainer.vrfs.AddressFamiliesVrf;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
LLSTR, logging.getLevel());
}
- List<Neighbors> neighbors = (config.getNeighborsContainer() == null) ? null
+ Map<NeighborsKey, Neighbors> keyNeighborsMap = (config.getNeighborsContainer() == null) ? null
: config.getNeighborsContainer().getNeighbors();
- if (neighbors != null) {
+ if (keyNeighborsMap != null) {
ps.printf("%nNeighbors%n");
- for (Neighbors nbr : neighbors) {
+ for (Neighbors nbr : keyNeighborsMap.values()) {
ps.printf("\t%s%n\t\t%-16s %d%n", nbr.getAddress().getValue(),
ASSTR, nbr.getRemoteAs());
EbgpMultihop en = nbr.getEbgpMultihop();
ps.printf("\t\t%-16s %s%n", USSTR, us.getSourceIp().getValue());
}
ps.printf("\t\t%-16s IPv4-Labeled-VPN", AFSTR);
- List<AddressFamilies> afs = nbr.getAddressFamilies();
- if (afs != null) {
- for (AddressFamilies af : afs) {
+ Map<AddressFamiliesKey, AddressFamilies> keyAddressFamiliesMap = nbr.getAddressFamilies();
+ if (keyAddressFamiliesMap != null) {
+ for (AddressFamilies af : keyAddressFamiliesMap.values()) {
// Should not print "unknown" in vpnv4 case
if (!(af.getSafi().intValue() == 5 && af.getAfi().intValue() == 1)) {
if (af.getSafi().intValue() == 4 && af.getAfi().intValue() == 1) {
}
if (listVrfs) {
- List<Vrfs> vrfs = (config.getVrfsContainer() == null) ? null : config.getVrfsContainer().getVrfs();
- if (vrfs != null) {
+ Map<VrfsKey, Vrfs> keyVrfsMap
+ = (config.getVrfsContainer() == null) ? null : config.getVrfsContainer().getVrfs();
+ if (keyVrfsMap != null) {
ps.printf("%nVRFs%n");
- for (Vrfs vrf : vrfs) {
+ for (Vrfs vrf : keyVrfsMap.values()) {
ps.printf("\t%s%n", vrf.getRd());
ps.printf("\t\t%s ", IRSTR);
for (String rt : vrf.getImportRts()) {
for (String rt : vrf.getExportRts()) {
ps.printf("%s ", rt);
}
- for (AddressFamiliesVrf adf : vrf.getAddressFamiliesVrf()) {
+ for (AddressFamiliesVrf adf : vrf.getAddressFamiliesVrf().values()) {
ps.printf("%n\t\tafi %d safi %d", adf.getAfi(), adf.getSafi());
}
ps.printf("%n");
}
if (listNets) {
- List<Networks> ln = (config.getNetworksContainer() == null) ? null
+ Map<NetworksKey, Networks> keyNetworksMap = (config.getNetworksContainer() == null) ? null
: config.getNetworksContainer().getNetworks();
- if (ln != null) {
+ if (keyNetworksMap != null) {
ps.printf("%nNetworks%n");
- for (Networks net : ln) {
+ for (Networks net : keyNetworksMap.values()) {
String rd = net.getRd();
String pfxlen = net.getPrefixLen();
String nh = net.getNexthop().getValue();
}
}
- List<Multipath> mp = config.getMultipathContainer() == null ? null
+ Map<MultipathKey, Multipath> keyMultipathMap = config.getMultipathContainer() == null ? null
: config.getMultipathContainer().getMultipath();
- List<VrfMaxpath> vrfm = config.getVrfMaxpathContainer() == null ? null
+ Map<VrfMaxpathKey, VrfMaxpath> keyVrfMaxpathMap = config.getVrfMaxpathContainer() == null ? null
: config.getVrfMaxpathContainer().getVrfMaxpath();
- if (mp != null) {
+ if (keyMultipathMap != null) {
ps.printf("%nMultipath%n");
- for (Multipath multipath : mp) {
+ for (Multipath multipath : keyMultipathMap.values()) {
int afi = multipath.getAfi().intValue();
int safi = multipath.getSafi().intValue();
Boolean enabled = multipath.isMultipathEnabled();
} else {
ps.printf("\t%-16s %s%n%n", AFSTR, "Unknown");
}
- if (vrfm != null) {
+ if (keyVrfMaxpathMap != null) {
ps.printf("\t%-16s %s%n", RDSTR, MPSTR);
- for (VrfMaxpath vrfMaxpath : vrfm) {
+ for (VrfMaxpath vrfMaxpath : keyVrfMaxpathMap.values()) {
String rd = vrfMaxpath.getRd();
int maxpath = vrfMaxpath.getMaxpaths().toJava();
ps.printf("\t%-16s %d%n", rd, maxpath);
package org.opendaylight.netvirt.bgpmanager.commands;
import java.io.PrintStream;
-
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
package org.opendaylight.netvirt.bgpmanager.commands;
-import java.util.List;
+import java.util.Map;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.opendaylight.netvirt.bgpmanager.BgpManager;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.Bgp;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.Neighbors;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.NeighborsKey;
@Command(scope = "odl", name = "bgp-rtr",
description = "Add or delete BGP router instance")
session.getConsole().println("error : no BGP configs present");
break;
}
- List<Neighbors> nbrs = conf.getNeighborsContainer() == null ? null
+ Map<NeighborsKey, Neighbors> keyNeighborsMap = conf.getNeighborsContainer() == null ? null
: conf.getNeighborsContainer().getNeighbors();
- if (nbrs != null && nbrs.size() > 0) {
+ if (keyNeighborsMap != null && keyNeighborsMap.size() > 0) {
session.getConsole().println("error: all BGP congiguration must be deleted "
+ "before stopping the router instance");
break;
package org.opendaylight.netvirt.bgpmanager.oam;
+import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.opendaylight.netvirt.bgpmanager.thrift.client.BgpRouterException;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.Bgp;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.Neighbors;
+import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.neighborscontainer.NeighborsKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
alarmAgent.registerMbean();
Bgp bgp = bgpMgr.getConfig();
if (bgp != null && bgp.getNeighborsContainer() != null) {
- List<Neighbors> nbrs = bgp.getNeighborsContainer().getNeighbors();
- if (nbrs != null) {
- for (Neighbors nbr : nbrs) {
+ Map<NeighborsKey, Neighbors> keyNeighborsMap = bgp.getNeighborsContainer().getNeighbors();
+ if (keyNeighborsMap != null) {
+ for (Neighbors nbr : keyNeighborsMap.values()) {
LOG.trace("Clearing Neighbor DOWN alarm at the startup for Neighbor {}",
nbr.getAddress().getValue());
clearBgpNbrDownAlarm(nbr.getAddress().getValue());
bgpMgr.getBgpCounters().fetchCmdOutputs(BgpCounters.BGP_VPNV4_SUMMARY_FILE,
"show ip bgp vpnv4 all summary");
if (bgpMgr.getConfig() != null) {
- nbrList = bgpMgr.getConfig().getNeighborsContainer().getNeighbors();
+ nbrList = new ArrayList<Neighbors>(bgpMgr.getConfig().getNeighborsContainer().getNeighbors().values());
}
BgpCounters.parseIpBgpVpnv4AllSummary(neighborStatusMap);
package org.opendaylight.netvirt.bgpmanager.oam;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-
import org.opendaylight.netvirt.bgpmanager.thrift.gen.BgpConfigurator;
public class BgpRouterAddNeighborTest {
<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>
<modelVersion>4.0.0</modelVersion>
<dependencies>
- <dependency>
+ <!--dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<artifactId>yang-ext</artifactId>
- </dependency>
+ </dependency-->
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>elanmanager-api</artifactId>
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<!-- <dependency>
*/
package org.opendaylight.netvirt.cloudservicechain;
-import java.util.Optional;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
-
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.NWUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.cloudservicechain.utils.ElanServiceChainUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.cloud.servicechain.state.rev160711.ElanServiceChainState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.cloud.servicechain.state.rev160711.elan.to.pseudo.port.data.list.ElanToPseudoPortData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
-
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
package org.opendaylight.netvirt.cloudservicechain;
-import java.util.Optional;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.interfacemanager.globals.InterfaceServiceUtil;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.actions.ActionRegLoad;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.cloudservicechain.jobs.AddVpnPseudoPortDataJob;
import org.opendaylight.netvirt.cloudservicechain.jobs.RemoveVpnPseudoPortDataJob;
import org.opendaylight.netvirt.cloudservicechain.utils.VpnServiceChainUtils;
import java.util.Collections;
import java.util.List;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.cloudservicechain.utils.VpnServiceChainUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.cloud.servicechain.state.rev160711.vpn.to.pseudo.port.list.VpnToPseudoPortData;
InstanceIdentifier<VpnToPseudoPortData> path = VpnServiceChainUtils.getVpnToPseudoPortTagIid(vpnRd);
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
- tx -> tx.put(LogicalDatastoreType.CONFIGURATION, path, newValue,
- WriteTransaction.CREATE_MISSING_PARENTS)));
+ tx -> tx.mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, path, newValue)));
}
}
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
/**
* Modifies VpnPseudoPort stateful data. Objects of this class are intended to
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
+import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.netvirt.cloudservicechain.VPNServiceChainHandler;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
*/
package org.opendaylight.netvirt.cloudservicechain.listeners;
-import java.util.Optional;
import java.math.BigInteger;
import java.util.List;
+import java.util.Optional;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.cloudservicechain.utils.ElanServiceChainUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.cloud.servicechain.state.rev160711.ElanServiceChainState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.cloud.servicechain.state.rev160711.elan.to.pseudo.port.data.list.ElanToPseudoPortData;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
+import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.netvirt.cloudservicechain.utils.VpnPseudoPortCache;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.cloud.servicechain.state.rev160711.VpnToPseudoPortList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.cloud.servicechain.state.rev160711.vpn.to.pseudo.port.list.VpnToPseudoPortData;
*/
package org.opendaylight.netvirt.cloudservicechain.listeners;
-import java.util.Optional;
import java.math.BigInteger;
import java.util.List;
-
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.cloudservicechain.CloudServiceChainConstants;
import org.opendaylight.netvirt.cloudservicechain.VPNServiceChainHandler;
import org.opendaylight.netvirt.cloudservicechain.utils.VpnServiceChainUtils;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.MatchInfo;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.utils.ServiceIndex;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.cloudservicechain.CloudServiceChainConstants;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
*/
package org.opendaylight.netvirt.cloudservicechain.listeners;
-import java.util.Optional;
import java.math.BigInteger;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.cloudservicechain.utils.VpnPseudoPortCache;
import org.opendaylight.netvirt.cloudservicechain.utils.VpnServiceChainUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
*/
package org.opendaylight.netvirt.cloudservicechain.utils;
-import java.util.Optional;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.MatchInfo;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
import org.opendaylight.genius.utils.ServiceIndex;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.cloudservicechain.CloudServiceChainConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
private static final Logger LOG = LoggerFactory.getLogger(ElanServiceChainUtils.class);
- private ElanServiceChainUtils() { }
+ private ElanServiceChainUtils() {
+
+ }
public static InstanceIdentifier<ElanInstance> getElanInstanceConfigDataPath(String elanInstanceName) {
return InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class,
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.cloud.servicechain.state.rev160711.vpn.to.pseudo.port.list.VpnToPseudoPortData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
package org.opendaylight.netvirt.cloudservicechain.utils;
-import java.util.Optional;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.mdsalutil.matches.MatchMplsLabel;
import org.opendaylight.genius.utils.ServiceIndex;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.cloudservicechain.CloudServiceChainConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
private static final Logger LOG = LoggerFactory.getLogger(VpnServiceChainUtils.class);
- private VpnServiceChainUtils() { }
+ private VpnServiceChainUtils() {
+
+ }
public static BigInteger getMetadataSCF(long scfTag) { // TODO: Move to a common place
return new BigInteger("FF", 16).and(BigInteger.valueOf(scfTag)).shiftLeft(32);
import static org.mockito.Mockito.when;
import static org.opendaylight.genius.mdsalutil.NWUtil.getEtherTypeFromIpPrefix;
-import java.util.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.ReadTransaction;
-import org.opendaylight.mdsal.binding.api.WriteTransaction;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.genius.interfacemanager.globals.InterfaceServiceUtil;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.infrautils.jobcoordinator.internal.JobCoordinatorImpl;
import org.opendaylight.infrautils.metrics.MetricProvider;
import org.opendaylight.infrautils.metrics.testimpl.TestMetricProviderImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.cloudservicechain.matchers.FlowEntityMatcher;
import org.opendaylight.netvirt.cloudservicechain.matchers.FlowMatcher;
import org.opendaylight.netvirt.cloudservicechain.utils.VpnServiceChainUtils;
package org.opendaylight.netvirt.cloudservicechain.matchers;
import java.util.List;
-
import org.mockito.ArgumentMatcher;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
<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.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>5.0.9</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<packaging>pom</packaging>
<properties>
- <controller.mdsal.version>1.11.0</controller.mdsal.version>
+ <controller.mdsal.version>2.0.0</controller.mdsal.version>
<genius.version>0.9.0-SNAPSHOT</genius.version>
<infrautils.version>1.8.0-SNAPSHOT</infrautils.version>
<model.bgp.version>2013.07.15.17.0-SNAPSHOT</model.bgp.version>
<dependencies>
<dependency>
<groupId>org.opendaylight.controller</groupId>
- <artifactId>mdsal-artifacts</artifactId>
+ <artifactId>controller-artifacts</artifactId>
<version>${controller.mdsal.version}</version>
<type>pom</type>
<scope>import</scope>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</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>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>yang-binding</artifactId>
</dependency>
- <dependency>
+ <!--dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<artifactId>yang-ext</artifactId>
- </dependency>
+ </dependency-->
<dependency>
<groupId>org.opendaylight.neutron</groupId>
<artifactId>model</artifactId>
import java.util.Set;
import java.util.concurrent.ConcurrentMap;
-
import org.apache.commons.lang3.tuple.Pair;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
*/
package org.opendaylight.netvirt.dhcpservice;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.EventListener;
import java.util.List;
return null;
}
Network networkConfData = optionalNetworkConfData.get();
- List<AllocationPool> allocationPoolList = networkConfData.getAllocationPool();
+ List<AllocationPool> allocationPoolList = new ArrayList<AllocationPool>(networkConfData
+ .getAllocationPool().values());
// if network has allocation pool list - get the first element
// as we have no info about a specific subnet
if (allocationPoolList != null && !allocationPoolList.isEmpty()) {
return Collections.emptyMap();
}
- return elanDpnIfacesOpc.get().nonnullDpnInterfaces().stream()
+ return elanDpnIfacesOpc.get().nonnullDpnInterfaces().values().stream()
.collect(Collectors.toMap(DpnInterfaces::getDpId,
value -> value.getInterfaces() != null ? value.getInterfaces() : Collections.emptyList()));
}
*/
package org.opendaylight.netvirt.dhcpservice;
+import java.util.ArrayList;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
dhcpManager.setDefaultDomain(DhcpMConstants.DEFAULT_DOMAIN_NAME);
return;
}
- Configs config = update.getConfigs().get(0);
+ Configs config = new ArrayList<Configs>(update.getConfigs().values()).get(0);
if (config.getLeaseDuration() != null) {
dhcpManager.setLeaseDuration(config.getLeaseDuration());
}
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
+import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Optional;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.api.rev150710.subnet.dhcp.port.data.SubnetToDhcpPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepLogicalSwitchRef;
return;
}
if (designatedSwitchForTunnelOptional.isPresent()) {
- List<DesignatedSwitchForTunnel> list =
+ Map<DesignatedSwitchForTunnelKey, DesignatedSwitchForTunnel> keyDesignatedSwitchForTunnelMap =
designatedSwitchForTunnelOptional.get().nonnullDesignatedSwitchForTunnel();
- for (DesignatedSwitchForTunnel designatedSwitchForTunnel : list) {
+ for (DesignatedSwitchForTunnel designatedSwitchForTunnel : keyDesignatedSwitchForTunnelMap.values()) {
Set<Pair<IpAddress, String>> setOfTunnelIpElanNamePair =
designatedDpnsToTunnelIpElanNameCache
.get(Uint64.valueOf(designatedSwitchForTunnel.getDpId()));
return;
}
if (optionalPorts.isPresent()) {
- List<Port> list = optionalPorts.get().nonnullPort();
- for (Port port : list) {
+ Map<PortKey, Port> portKeyPortMap = optionalPorts.get().nonnullPort();
+ for (Port port : portKeyPortMap.values()) {
if (NeutronUtils.isPortVnicTypeNormal(port)) {
continue;
}
return false;
}
if (designatedSwitchForTunnelOptional.isPresent()) {
- List<DesignatedSwitchForTunnel> list =
+ Map<DesignatedSwitchForTunnelKey, DesignatedSwitchForTunnel> keyDesignatedSwitchForTunnelMap =
designatedSwitchForTunnelOptional.get().nonnullDesignatedSwitchForTunnel();
- for (DesignatedSwitchForTunnel designatedSwitchForTunnel : list) {
+ for (DesignatedSwitchForTunnel designatedSwitchForTunnel : keyDesignatedSwitchForTunnelMap.values()) {
if (dpId.equals(Uint64.valueOf(designatedSwitchForTunnel.getDpId()))) {
return true;
}
*/
package org.opendaylight.netvirt.dhcpservice;
+import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
if (!CONTAINS_GLOBAL_AUGMENTATION.test(nodeOptional)) {
return null;
}
- List<Switches> switchIids = nodeOptional.get().augmentation(HwvtepGlobalAugmentation.class).getSwitches();
+ List<Switches> switchIids = new ArrayList<Switches>(nodeOptional.get()
+ .augmentation(HwvtepGlobalAugmentation.class).getSwitches().values());
if (EMPTY_LIST.test(switchIids)) {
return null;
}
if (!CONTAINS_SWITCH_AUGMENTATION.test(nodeOptional)) {
return null;
}
- List<TunnelIps> tunnelIps = nodeOptional.get().augmentation(PhysicalSwitchAugmentation.class)
- .getTunnelIps();
+ List<TunnelIps> tunnelIps = new ArrayList<TunnelIps>(nodeOptional.get()
+ .augmentation(PhysicalSwitchAugmentation.class).getTunnelIps().values());
if (EMPTY_LIST.test(tunnelIps)) {
return null;
}
public Subnet getNeutronSubnet(Port port) {
if (port != null) {
// DHCP Service is only interested in IPv4 IPs/Subnets
- return getNeutronSubnet(port.getFixedIps());
+ return getNeutronSubnet(new ArrayList<FixedIps>(port.getFixedIps().values()));
}
return null;
}
//With Ipv6 changes we can get ipv4 subnets later. The below check is to support such scenario.
if (original.nonnullFixedIps().size() < update.nonnullFixedIps().size()) {
final String interfaceName = update.getUuid().getValue();
- List<FixedIps> updatedFixedIps = new ArrayList<>(update.nonnullFixedIps());
+ List<FixedIps> updatedFixedIps = new ArrayList<>(update.nonnullFixedIps().values());
// Need to check only the newly added fixed ip.
- updatedFixedIps.removeAll(original.nonnullFixedIps());
+ updatedFixedIps.removeAll(original.nonnullFixedIps().values());
Subnet subnet = dhcpManager.getNeutronSubnet(updatedFixedIps);
if (null == subnet || !subnet.isEnableDhcp()) {
LOG.trace("Subnet is null/not ipv4 or not enabled {}", subnet);
if (clientIp != null && serverIp != null) {
List<HostRoutes> subnetHostRoutes = new ArrayList<>();
if (subnet.getHostRoutes() != null && !subnet.getHostRoutes().isEmpty()) {
- for (HostRoutes hostRoute : subnet.getHostRoutes()) {
+ for (HostRoutes hostRoute : subnet.getHostRoutes().values()) {
if (!hostRoute.getNexthop().stringValue().equals(clientIp)) {
subnetHostRoutes.add(hostRoute);
}
@Nullable
private static String getIpv4Address(Port port) {
- for (FixedIps fixedIp : port.nonnullFixedIps()) {
+ for (FixedIps fixedIp : port.nonnullFixedIps().values()) {
if (isIpv4Address(fixedIp.getIpAddress())) {
return fixedIp.getIpAddress().getIpv4Address().getValue();
}
LOG.warn("RPC Call to Get egress actions for interface {} returned with Errors {}",
interfaceName, rpcResult.getErrors());
} else {
- return rpcResult.getResult().getAction();
+ return new ArrayList<Action>(rpcResult.getResult().getAction().values());
}
} else {
GetEgressActionsForInterfaceInputBuilder egressAction =
LOG.warn("RPC Call to Get egress actions for interface {} returned with Errors {}",
interfaceName, rpcResult.getErrors());
} else {
- return rpcResult.getResult().getAction();
+ return new ArrayList<Action>(rpcResult.getResult().getAction().values());
}
}
} catch (InterruptedException | ExecutionException e) {
package org.opendaylight.netvirt.dhcpservice;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import java.math.BigInteger;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
+import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.CopyOnWriteArrayList;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceBindings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeIngress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceTypeFlowBased;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfacesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NetworkMaps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMapKey;
new MatchArpTpa(ipAddress, "32"));
}
- private static List<Instruction> getDhcpArpInstructions(Long elanTag, int lportTag) {
- List<Instruction> mkInstructions = new ArrayList<>();
+ private static Map<InstructionKey, Instruction> getDhcpArpInstructions(Long elanTag, int lportTag) {
+ Map<InstructionKey, Instruction> mkInstructions = new HashMap<InstructionKey, Instruction>();
int instructionKey = 0;
- mkInstructions.add(MDSALUtil.buildAndGetWriteMetadaInstruction(
+ mkInstructions.put(new InstructionKey(++instructionKey), MDSALUtil.buildAndGetWriteMetadaInstruction(
ElanHelper.getElanMetadataLabel(elanTag, lportTag), ElanHelper.getElanMetadataMask(),
- ++instructionKey));
- mkInstructions.add(MDSALUtil.buildAndGetGotoTableInstruction(NwConstants.ARP_RESPONDER_TABLE,
- ++instructionKey));
+ instructionKey));
+ mkInstructions.put(new InstructionKey(++instructionKey), MDSALUtil
+ .buildAndGetGotoTableInstruction(NwConstants.ARP_RESPONDER_TABLE, instructionKey));
return mkInstructions;
}
@NonNull
private static List<Uint64> extractDpnsFromNodes(Optional<Nodes> optionalNodes) {
return optionalNodes.map(
- nodes -> nodes.nonnullNode().stream().map(Node::getId).filter(Objects::nonNull).map(
+ nodes -> nodes.nonnullNode().values().stream().map(Node::getId).filter(Objects::nonNull).map(
MDSALUtil::getDpnIdFromNodeName).collect(
Collectors.toList())).orElse(Collections.emptyList());
}
return Collections.emptyList();
}
if (elanDpnOptional.isPresent()) {
- List<DpnInterfaces> dpns = elanDpnOptional.get().nonnullDpnInterfaces();
- for (DpnInterfaces dpnInterfaces : dpns) {
+ Map<DpnInterfacesKey, DpnInterfaces> dpnInterfacesMap = elanDpnOptional.get().nonnullDpnInterfaces();
+ for (DpnInterfaces dpnInterfaces : dpnInterfacesMap.values()) {
elanDpns.add(dpnInterfaces.getDpId());
}
}
getBoundServices(String.format("%s.%s", "dhcp", interfaceName),
serviceIndex, DhcpMConstants.DEFAULT_FLOW_PRIORITY,
DhcpMConstants.COOKIE_VM_INGRESS_TABLE, instructions);
- tx.put(buildServiceId(interfaceName, serviceIndex), serviceInfo, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(buildServiceId(interfaceName, serviceIndex), serviceInfo);
}
public static void unbindDhcpService(String interfaceName, TypedWriteTransaction<Configuration> tx) {
if (port.getFixedIps() == null) {
return java.util.Optional.empty();
}
- return port.getFixedIps().stream().filter(DhcpServiceUtils::isIpV4AddressAvailable)
+ return port.getFixedIps().values().stream().filter(DhcpServiceUtils::isIpV4AddressAvailable)
.map(v -> v.getIpAddress().getIpv4Address().getValue()).findFirst();
}
if (port.getFixedIps() == null) {
return java.util.Optional.empty();
}
- return port.getFixedIps().stream().filter(DhcpServiceUtils::isIpV4AddressAvailable)
+ return port.getFixedIps().values().stream().filter(DhcpServiceUtils::isIpV4AddressAvailable)
.map(v -> v.getSubnetId().getValue()).findFirst();
}
new InterfaceNameMacAddressBuilder()
.withKey(new InterfaceNameMacAddressKey(interfaceName))
.setInterfaceName(interfaceName).setMacAddress(vmMacAddress).build();
- tx.merge(instanceIdentifier, interfaceNameMacAddress, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(instanceIdentifier, interfaceNameMacAddress);
return vmMacAddress;
}
return existingEntry.get().getMacAddress();
<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.mdsal.binding.model.ietf</groupId>
<artifactId>rfc7223</artifactId>
</dependency>
- <dependency>
+ <!--dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<artifactId>yang-ext</artifactId>
- </dependency>
+ </dependency-->
<dependency>
<groupId>org.opendaylight.genius</groupId>
<artifactId>idmanager-api</artifactId>
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
-
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
public final class ArpResponderInput {
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;
import java.util.stream.Collectors;
-
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.BucketInfo;
import org.opendaylight.netvirt.elanmanager.api.ElanHelper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
try {
RpcResult result = itmRpcService.getEgressActionsForTunnel(new GetEgressActionsForTunnelInputBuilder()
.setIntfName(ifName).build()).get();
- List<Action> listActions = new ArrayList<>();
+ Map<ActionKey, Action> listActions = new HashMap<ActionKey, Action>();
if (!result.isSuccessful()) {
LOG.error("getEgressActionsForInterface: RPC Call to Get egress actions for interface {} "
+ "returned with Errors {}", ifName, result.getErrors());
} else {
listActions = ((GetEgressActionsForTunnelOutput) result.getResult()).getAction();
}
- return listActions;
+ return new ArrayList<Action>(listActions.values());
} catch (InterruptedException | ExecutionException e) {
LOG.error("getEgressActionsForInterface: Exception when egress actions for interface {}", ifName, e);
}
*/
package org.opendaylight.netvirt.elanmanager.api;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesListKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
ElanDpnInterfacesList existingElanDpnInterfaces = SingleTransactionDataBroker.syncRead(broker,
LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
if (existingElanDpnInterfaces != null) {
- return existingElanDpnInterfaces.getDpnInterfaces().stream().flatMap(v -> v.getInterfaces().stream())
- .collect(Collectors.toList());
+ return new ArrayList<DpnInterfaces>(existingElanDpnInterfaces.getDpnInterfaces().values()).stream()
+ .flatMap(v -> v.getInterfaces().stream()).collect(Collectors.toList());
}
} catch (ExpectedDataObjectNotFoundException e) {
LOG.warn("Failed to read ElanDpnInterfacesList with error {}", e.getMessage());
import java.util.List;
import java.util.Set;
-
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
<groupId>org.eclipse.xtend</groupId>
<artifactId>xtend-maven-plugin</artifactId>
</plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <configuration>
+ <source>1.8</source>
+ <target>1.8</target>
+ </configuration>
+ </plugin>
</plugins>
</build>
</project>
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.Devices;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.DevicesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.connections.attributes.l2gatewayconnections.L2gatewayConnection;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateways.attributes.l2gateways.L2gateway;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindings;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindingsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
Optional<Topology> configTopoOptional = tx.read(LogicalDatastoreType.CONFIGURATION, topoId).get();
if (operationalTopoOptional.isPresent()) {
- for (Node node : operationalTopoOptional.get().nonnullNode()) {
+ for (Node node : operationalTopoOptional.get().nonnullNode().values()) {
InstanceIdentifier<Node> nodeIid = topoId.child(Node.class, node.key());
operationalNodes.put(nodeIid, node);
}
}
if (configTopoOptional.isPresent()) {
- for (Node node : configTopoOptional.get().nonnullNode()) {
+ for (Node node : configTopoOptional.get().nonnullNode().values()) {
InstanceIdentifier<Node> nodeIid = topoId.child(Node.class, node.key());
configNodes.put(nodeIid, node);
}
InstanceIdentifier.builder(ElanInstances.class).build()).get();
if (elanInstancesOptional.isPresent() && elanInstancesOptional.get().getElanInstance() != null) {
- for (ElanInstance elanInstance : elanInstancesOptional.get().getElanInstance()) {
+ for (ElanInstance elanInstance : elanInstancesOptional.get().getElanInstance().values()) {
elanInstanceMap.put(elanInstance.getElanInstanceName(), elanInstance);
}
}
private static boolean containsLogicalSwitch(Node node) {
if (node == null || node.augmentation(HwvtepGlobalAugmentation.class) == null
|| HwvtepHAUtil.isEmptyList(
- node.augmentation(HwvtepGlobalAugmentation.class).getLogicalSwitches())) {
+ new ArrayList(node.augmentation(HwvtepGlobalAugmentation.class).getLogicalSwitches().values()))) {
return false;
}
return true;
L2gateway l2gateway = uuidToL2Gateway.get(l2gatewayConnection.getL2gatewayId());
String logicalSwitchName = l2gatewayConnection.getNetworkId().getValue();
- List<Devices> devices = l2gateway.nonnullDevices();
+ Map<DevicesKey, Devices> devices = l2gateway.nonnullDevices();
- for (Devices device : devices) {
+ for (Devices device : devices.values()) {
L2GatewayDevice l2GatewayDevice = l2GatewayCache.get(device.getDeviceName());
isValid = verifyL2GatewayDevice(l2gateway, device, l2GatewayDevice);
return false;
}
for (org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712
- .l2gateway.attributes.devices.Interfaces deviceInterface : hwVtepDevice.getInterfaces()) {
+ .l2gateway.attributes.devices.Interfaces deviceInterface : hwVtepDevice.getInterfaces().values()) {
NodeId switchNodeId = HwvtepSouthboundUtils.createManagedNodeId(nodeId, hwVtepDevice.getDeviceName());
InstanceIdentifier<Node> physicalSwitchNodeIid = topoIid.child(Node.class, new NodeKey(switchNodeId));
HwvtepPhysicalPortAugmentation portAugmentation = configTerminationPoint.augmentation(
HwvtepPhysicalPortAugmentation.class);
- if (portAugmentation == null || HwvtepHAUtil.isEmptyList(portAugmentation.getVlanBindings())) {
+ if (portAugmentation == null || HwvtepHAUtil.isEmptyList(
+ new ArrayList(portAugmentation.getVlanBindings().values()))) {
pw.println("Failed to find the config vlan bindings for port " + deviceInterface.getInterfaceName()
+ " for node " + hwVtepDevice.getDeviceName() + " for logical switch " + logicalSwitchName
+ " nodeid " + nodeId.getValue());
continue;
}
portAugmentation = operationalTerminationPoint.augmentation(HwvtepPhysicalPortAugmentation.class);
- if (portAugmentation == null || HwvtepHAUtil.isEmptyList(portAugmentation.getVlanBindings())) {
+ if (portAugmentation == null || HwvtepHAUtil.isEmptyList(
+ new ArrayList(portAugmentation.getVlanBindings().values()))) {
pw.println("Failed to find the operational vlan bindings for port " + deviceInterface.getInterfaceName()
+ " for node " + hwVtepDevice.getDeviceName() + " for logical switch " + logicalSwitchName
+ " nodeid " + nodeId.getValue());
}
VlanBindings expectedBindings = !expectedVlans.isEmpty() ? expectedVlans.get(0) : null;
boolean foundBindings = false;
- List<VlanBindings> vlanBindingses = configTerminationPoint.augmentation(
+ Map<VlanBindingsKey, VlanBindings> vlanBindingses = configTerminationPoint.augmentation(
HwvtepPhysicalPortAugmentation.class).nonnullVlanBindings();
- for (VlanBindings actual : vlanBindingses) {
+ for (VlanBindings actual : vlanBindingses.values()) {
if (actual.equals(expectedBindings)) {
foundBindings = true;
break;
+ " nodeid " + nodeId.getValue());
pw.println("Failed to find the vlan bindings " + expectedBindings);
pw.println("Actual bindings present in config are ");
- for (VlanBindings actual : vlanBindingses) {
+ for (VlanBindings actual : vlanBindingses.values()) {
pw.println(actual.toString());
}
valid = false;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepLogicalSwitchRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalPortAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalMcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalMcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Switches;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.SwitchesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.locator.set.attributes.LocatorSet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindings;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
Optional<Topology> topologyOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, createHwvtepTopologyInstanceIdentifier());
if (topologyOptional.isPresent()) {
- nodes.addAll(topologyOptional.get().nonnullNode());
+ nodes.addAll(topologyOptional.get().nonnullNode().values());
}
} else {
Optional<Node> nodeOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.builder(ElanInstances.class).build());
if (elanInstancesOptional.isPresent()) {
- List<ElanInstance> elans = elanInstancesOptional.get().getElanInstance();
+ Map<ElanInstanceKey, ElanInstance> elans = elanInstancesOptional.get().getElanInstance();
if (elans != null) {
- for (ElanInstance elan : elans) {
+ for (ElanInstance elan : elans.values()) {
networks.add(elan.getElanInstanceName());
}
}
if (hwvtepNode == null || hwvtepNode.augmentation(HwvtepGlobalAugmentation.class) == null) {
return;
}
- List<RemoteUcastMacs> remoteUcastMacs =
+ Map<RemoteUcastMacsKey, RemoteUcastMacs> remoteUcastMacs =
hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).getRemoteUcastMacs();
if (remoteUcastMacs == null || remoteUcastMacs.isEmpty()) {
return;
}
- for (RemoteUcastMacs remoteMac : remoteUcastMacs) {
+ for (RemoteUcastMacs remoteMac : remoteUcastMacs.values()) {
String lsFromRemoteMac = getLogicalSwitchValue(remoteMac.getLogicalSwitchRef());
if (elanName.equals(lsFromRemoteMac)) {
String mac = remoteMac.getMacEntryKey().getValue();
if (hwvtepNode == null || hwvtepNode.augmentation(HwvtepGlobalAugmentation.class) == null) {
return;
}
- List<LocalUcastMacs> localUcastMacs =
+ Map<LocalUcastMacsKey, LocalUcastMacs> localUcastMacs =
hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).getLocalUcastMacs();
if (localUcastMacs == null || localUcastMacs.isEmpty()) {
return;
}
- for (LocalUcastMacs localMac : localUcastMacs) {
+ for (LocalUcastMacs localMac : localUcastMacs.values()) {
String lsFromLocalMac = getLogicalSwitchValue(localMac.getLogicalSwitchRef());
if (elanName.equals(lsFromLocalMac)) {
String mac = localMac.getMacEntryKey().getValue();
if (hwvtepNode == null || hwvtepNode.augmentation(HwvtepGlobalAugmentation.class) == null) {
return;
}
- List<LocalMcastMacs> localMcastMacs =
+ Map<LocalMcastMacsKey, LocalMcastMacs> localMcastMacs =
hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).getLocalMcastMacs();
if (localMcastMacs == null || localMcastMacs.isEmpty()) {
return;
}
- for (LocalMcastMacs localMac : localMcastMacs) {
+ for (LocalMcastMacs localMac : localMcastMacs.values()) {
String lsFromLocalMac = getLogicalSwitchValue(localMac.getLogicalSwitchRef());
if (elanName.equals(lsFromLocalMac)) {
String mac = localMac.getMacEntryKey().getValue();
if (hwvtepNode == null || hwvtepNode.augmentation(HwvtepGlobalAugmentation.class) == null) {
return;
}
- List<RemoteMcastMacs> remoteMcastMacs =
+ Map<RemoteMcastMacsKey, RemoteMcastMacs> remoteMcastMacs =
hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).getRemoteMcastMacs();
if (remoteMcastMacs == null || remoteMcastMacs.isEmpty()) {
return;
}
- for (RemoteMcastMacs remoteMac : remoteMcastMacs) {
+ for (RemoteMcastMacs remoteMac : remoteMcastMacs.values()) {
String lsFromremoteMac = getLogicalSwitchValue(remoteMac.getLogicalSwitchRef());
if (elanName.equals(lsFromremoteMac)) {
String mac = remoteMac.getMacEntryKey().getValue();
if (psNode == null) {
return;
}
- List<TerminationPoint> terminationPoints = psNode.getTerminationPoint();
+ Map<TerminationPointKey, TerminationPoint> terminationPoints = psNode.getTerminationPoint();
if (terminationPoints == null || terminationPoints.isEmpty()) {
return;
}
- for (TerminationPoint terminationPoint : terminationPoints) {
+ for (TerminationPoint terminationPoint : terminationPoints.values()) {
HwvtepPhysicalPortAugmentation aug =
terminationPoint.augmentation(HwvtepPhysicalPortAugmentation.class);
if (aug == null || aug.getVlanBindings() == null) {
continue;
}
- for (VlanBindings vlanBindings : aug.getVlanBindings()) {
+ for (VlanBindings vlanBindings : aug.getVlanBindings().values()) {
String lsFromremoteMac = getLogicalSwitchValue(vlanBindings.getLogicalSwitchRef());
if (elanName.equals(lsFromremoteMac)) {
session.getConsole().println(terminationPoint.getTpId().getValue()
Node getPSnode(Node hwvtepNode, LogicalDatastoreType datastoreType) throws ExecutionException,
InterruptedException {
if (hwvtepNode.augmentation(HwvtepGlobalAugmentation.class) != null) {
- List<Switches> switches = hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).getSwitches();
+ Map<SwitchesKey, Switches> switches = hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).getSwitches();
if (switches != null) {
return HwvtepUtils.getHwVtepNode(dataBroker, datastoreType,
- switches.iterator().next().getSwitchRef().getValue().firstKeyOf(Node.class).getNodeId());
+ switches.values().iterator().next().getSwitchRef().getValue().firstKeyOf(Node.class).getNodeId());
}
}
return null;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeLeafTagName;
import org.opendaylight.yangtools.yang.common.Uint64;
public Flow evpnBuildDmacFlowForExternalRemoteMac(EvpnDmacFlow evpnDmacFlow) {
List<MatchInfo> mkMatches = ElanUtils.buildMatchesForElanTagShFlagAndDstMac(evpnDmacFlow.getElanTag(), false,
evpnDmacFlow.getDstMacAddress());
- List<Instruction> mkInstructions = new ArrayList<>();
+ Map<InstructionKey, Instruction> mkInstructionsMap = new HashMap<>();
List<Action> actions = elanItmUtils.getExternalTunnelItmEgressAction(evpnDmacFlow.getDpId(),
evpnDmacFlow.getNexthopIP(), evpnDmacFlow.getVni());
- mkInstructions.add(MDSALUtil.buildApplyActionsInstruction(actions));
+ mkInstructionsMap.put(new InstructionKey(0), MDSALUtil.buildApplyActionsInstruction(actions));
Flow flow = MDSALUtil.buildFlowNew(NwConstants.ELAN_DMAC_TABLE,
ElanUtils.getKnownDynamicmacFlowRef(NwConstants.ELAN_DMAC_TABLE, evpnDmacFlow.getDpId(),
evpnDmacFlow.getNexthopIP(), evpnDmacFlow.getDstMacAddress(), evpnDmacFlow.getElanTag(), false),
20, evpnDmacFlow.getElanName(), 0, 0,
Uint64.valueOf(ElanConstants.COOKIE_ELAN_KNOWN_DMAC.toJava()
.add(BigInteger.valueOf(evpnDmacFlow.getElanTag()))),
- mkMatches, mkInstructions);
+ mkMatches, mkInstructionsMap);
return flow;
}
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 javax.inject.Inject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.macvrfentries.MacVrfEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.macvrfentries.MacVrfEntryKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentrybase.RoutePaths;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.EvpnRdToNetworks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.evpn.rd.to.networks.EvpnRdToNetwork;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.evpn.rd.to.networks.EvpnRdToNetworkKey;
if (!vrfTablesOptional.isPresent()) {
return null;
}
- List<MacVrfEntry> macVrfEntries = vrfTablesOptional.get().getMacVrfEntry();
- if (macVrfEntries == null || macVrfEntries.isEmpty()) {
+ Map<MacVrfEntryKey, MacVrfEntry> keyMacVrfEntryMap = vrfTablesOptional.get().getMacVrfEntry();
+ if (keyMacVrfEntryMap == null || keyMacVrfEntryMap.isEmpty()) {
return null;
}
- for (MacVrfEntry macVrfEntry : macVrfEntries) {
+ for (MacVrfEntry macVrfEntry : keyMacVrfEntryMap.values()) {
InstanceIdentifier<MacVrfEntry> macVrfEntryIid = getMacVrfEntryIid(rd, macVrfEntry);
if (install) {
addEvpnDmacFlowOnAttach(macVrfEntryIid, macVrfEntry, elanInstance);
List<DpnInterfaces> dpnInterfaceLists = elanUtils.getElanDPNByName(elanName);
if (checkEvpnAttachedToNet(elanName)) {
//TODO(Riyaz) : Check if accessing first nexthop address is right solution
- String nexthopIP = macVrfEntry.getRoutePaths().get(0).getNexthopAddress();
+ String nexthopIP = new ArrayList<RoutePaths>(macVrfEntry.getRoutePaths().values())
+ .get(0).getNexthopAddress();
IpAddress ipAddress = new IpAddress(new Ipv4Address(nexthopIP));
Uint32 elanTag = getElanTagByMacvrfiid(instanceIdentifier);
if (elanTag == null) {
//if (checkEvpnAttachedToNet(elanName)) {
//TODO(Riyaz) : Check if accessing first nexthop address is right
- String nexthopIP = macVrfEntry.getRoutePaths().get(0).getNexthopAddress();
+ String nexthopIP = new ArrayList<RoutePaths>(macVrfEntry.getRoutePaths().values()).get(0).getNexthopAddress();
IpAddress ipAddress = new IpAddress(new Ipv4Address(nexthopIP));
Uint32 elanTag = getElanTagByMacvrfiid(instanceIdentifier);
if (elanTag == null) {
LOG.debug("RoutePaths is null or empty for macvrfentry {}", macVrfEntry);
return null;
}
- return macVrfEntry.getRoutePaths().get(0).getNexthopAddress();
+ return new ArrayList<RoutePaths>(macVrfEntry.getRoutePaths().values()).get(0).getNexthopAddress();
}
public void removeEvpnDmacFlowOnDetach(InstanceIdentifier<MacVrfEntry> instanceIdentifier, MacVrfEntry macVrfEntry,
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
-import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
LOG.info("No DC gateways configured while programming the l2vni table.");
return tunnelInterfaceNameList;
}
- List<DcGatewayIp> dcGatewayIps = dcGatewayIpListOptional.get().nonnullDcGatewayIp();
+ List<DcGatewayIp> dcGatewayIps
+ = new ArrayList<DcGatewayIp>(dcGatewayIpListOptional.get().nonnullDcGatewayIp().values());
Optional<ExternalTunnelList> externalTunnelListOptional = getExternalTunnelList();
if (!externalTunnelListOptional.isPresent()) {
LOG.info("No External Tunnel Configured while programming the l2vni table.");
return tunnelInterfaceNameList;
}
- List<ExternalTunnel> externalTunnels = externalTunnelListOptional.get().nonnullExternalTunnel();
+ List<ExternalTunnel> externalTunnels
+ = new ArrayList<ExternalTunnel>(externalTunnelListOptional.get().nonnullExternalTunnel().values());
dcGatewayIps.forEach(dcIp -> externalTunnels
.stream()
NwConstants.ELAN_SERVICE_INDEX, NwConstants.COOKIE_ELAN_INGRESS_TABLE, instructions);
InstanceIdentifier<BoundServices> bindServiceId = ElanUtils.buildServiceId(interfaceName, elanServiceIndex);
if (!tx.read(bindServiceId).get().isPresent()) {
- tx.put(bindServiceId, serviceInfo, WriteTransaction.CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(bindServiceId, serviceInfo);
}
}), LOG, "Error binding an ELAN service to an external tunnel");
}
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
import com.google.common.collect.Lists;
-
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
return null;
}
- return ovsdbNode.nonnullManagedNodeEntry();
+ return new ArrayList<>(ovsdbNode.nonnullManagedNodeEntry().values());
}
private void prepareIntegrationBridge(Node ovsdbNode, Node brIntNode) {
private void copyBridgeToConfig(Node brIntNode) {
NodeBuilder bridgeNodeBuilder = new NodeBuilder(brIntNode);
- bridgeNodeBuilder.setTerminationPoint(null);
+ bridgeNodeBuilder.setTerminationPoint(Collections.emptyMap());
InstanceIdentifier<Node> brNodeIid = SouthboundUtils.createInstanceIdentifier(brIntNode.getNodeId());
try {
SingleTransactionDataBroker.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION,
if (bridgeAug != null) {
DatapathId dpId = bridgeAug.getDatapathId();
if (dpId != null) {
- otherConfigs = bridgeAug.getBridgeOtherConfigs();
+ otherConfigs = new ArrayList<>(bridgeAug.getBridgeOtherConfigs().values());
if (otherConfigs == null) {
otherConfigs = Lists.newArrayList();
}
*/
@Nullable
private Node getBridgeNode(Uint64 dpId) {
- List<Node> ovsdbNodes = southboundUtils.getOvsdbNodes();
+ Map<NodeKey, Node> ovsdbNodes = southboundUtils.getOvsdbNodes();
if (null == ovsdbNodes) {
LOG.debug("Could not find any (?) ovsdb nodes");
return null;
}
- for (Node node : ovsdbNodes) {
+ for (Node node : ovsdbNodes.values()) {
if (!isIntegrationBridge(node)) {
continue;
}
@Override
public void add(InstanceIdentifier<ExternalTeps> iid, ExternalTeps tep) {
LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
- tx.put(iid, tep, true);
+ tx.mergeParentStructurePut(iid, tep);
}), LOG, "Failed to update operational external teps {}", iid);
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import static org.opendaylight.infrautils.utils.concurrent.LoggingFutures.addErrorLogging;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.netvirt.elan.utils.ElanUtils.isVxlanNetworkOrVxlanSegment;
import com.google.common.base.Preconditions;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan._interface.forwarding.entries.ElanInterfaceMac;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfacesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfacesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.elan._interface.StaticMacEntries;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.elan._interface.StaticMacEntriesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.state.Elan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.state.ElanBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.state.ElanKey;
LOG.debug("Removing the Interface:{} from elan:{}", interfaceName, elanName);
if (interfaceInfo != null) {
if (existingElanInterfaceMac.isPresent()) {
- List<MacEntry> existingMacEntries = existingElanInterfaceMac.get().getMacEntry();
+ Map<MacEntryKey, MacEntry> existingMacEntries = existingElanInterfaceMac.get().getMacEntry();
if (existingMacEntries != null) {
List<PhysAddress> macAddresses = new ArrayList<>();
- for (MacEntry macEntry : existingMacEntries) {
+ for (MacEntry macEntry : existingMacEntries.values()) {
PhysAddress macAddress = macEntry.getMacAddress();
LOG.debug("removing the mac-entry:{} present on elanInterface:{}",
macAddress.getValue(), interfaceName);
} else if (existingElanInterfaceMac.isPresent()) {
// Interface does not exist in ConfigDS, so lets remove everything
// about that interface related to Elan
- List<MacEntry> macEntries = existingElanInterfaceMac.get().getMacEntry();
+ Map<MacEntryKey, MacEntry> macEntries = existingElanInterfaceMac.get().getMacEntry();
if (macEntries != null) {
- for (MacEntry macEntry : macEntries) {
+ for (MacEntry macEntry : macEntries.values()) {
PhysAddress macAddress = macEntry.getMacAddress();
if (elanUtils.getMacEntryForElanInstance(elanName, macAddress).isPresent()) {
interfaceTx.delete(ElanUtils.getMacEntryOperationalDataPath(elanName, macAddress));
if (macs == null || macs.getMacEntry() == null) {
continue;
}
- for (MacEntry mac : macs.getMacEntry()) {
+ for (MacEntry mac : new ArrayList<MacEntry>(macs.getMacEntry().values())) {
removeTheMacFlowInTheDPN(dpId, elanTag, mac, confTx);
removeEtreeMacFlowInTheDPN(dpId, elanTag, mac, confTx);
}
LOG.info("Update static mac entries for elan interface {} in elan instance {}", interfaceName, elanName);
EVENT_LOGGER.debug("ELAN-Interface, UPDATE {} Instance {}", original.getName(), elanName);
- List<StaticMacEntries> originalStaticMacEntries = original.getStaticMacEntries();
- List<StaticMacEntries> updatedStaticMacEntries = update.getStaticMacEntries();
+ List<StaticMacEntries> originalStaticMacEntries = new ArrayList<StaticMacEntries>(original
+ .getStaticMacEntries().values());
+ List<StaticMacEntries> updatedStaticMacEntries = new ArrayList<StaticMacEntries>(update
+ .getStaticMacEntries().values());
List<StaticMacEntries> deletedEntries = ElanUtils.diffOf(originalStaticMacEntries, updatedStaticMacEntries);
List<StaticMacEntries> updatedEntries = ElanUtils.diffOf(updatedStaticMacEntries, originalStaticMacEntries);
.getElanDpnInterfacesList(elanInstance.getElanInstanceName());
List<DpnInterfaces> dpnInterfaceLists = null;
if (elanDpnInterfacesList != null) {
- dpnInterfaceLists = elanDpnInterfacesList.getDpnInterfaces();
+ dpnInterfaceLists = new ArrayList<DpnInterfaces>(elanDpnInterfacesList.getDpnInterfaces().values());
}
if (dpnInterfaceLists != null && !dpnInterfaceLists.isEmpty()) {
Uint64 dstDpId = interfaceInfo.getDpId();
if (elanIfMac == null || remoteInterface == null) {
continue;
}
- List<MacEntry> remoteMacEntries = elanIfMac.nonnullMacEntry();
- for (MacEntry macEntry : remoteMacEntries) {
+ Map<MacEntryKey, MacEntry> remoteMacEntries = elanIfMac.nonnullMacEntry();
+ for (MacEntry macEntry : remoteMacEntries.values()) {
String macAddress = macEntry.getMacAddress().getValue();
LOG.info("Programming remote dmac {} on the newly added DPN {} for elan {}", macAddress,
dstDpId, elanInstance.getElanInstanceName());
// ELAN's 1st ElanInterface added to this DPN
LOG.debug("Adding dpn into operational dpn list {}", holder.dpId);
futures.add(txRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL, operTx -> {
- operTx.put(ElanUtils.getElanDpnInterfaceOperationalDataPath(elanInstanceName, holder.dpId),
- holder.dpnInterfaces, CREATE_MISSING_PARENTS);
+ operTx.mergeParentStructurePut(ElanUtils.getElanDpnInterfaceOperationalDataPath(elanInstanceName,
+ holder.dpId), holder.dpnInterfaces);
}));
} else {
LOG.debug("Updated dpn into operational dpn list {}", holder.dpId);
installEntriesForElanInterface(elanInstance, elanInterface, interfaceInfo,
isFirstInterfaceInDpn, confTx);
- List<StaticMacEntries> staticMacEntriesList = elanInterface.getStaticMacEntries();
+ Map<StaticMacEntriesKey, StaticMacEntries> staticMacEntriesList = elanInterface.getStaticMacEntries();
List<PhysAddress> staticMacAddresses = Lists.newArrayList();
- if (ElanUtils.isNotEmpty(staticMacEntriesList)) {
- for (StaticMacEntries staticMacEntry : staticMacEntriesList) {
+ if (ElanUtils.isNotEmpty(staticMacEntriesList.values())) {
+ for (StaticMacEntries staticMacEntry : staticMacEntriesList.values()) {
InstanceIdentifier<MacEntry> macId = getMacEntryOperationalDataPath(elanInstanceName,
staticMacEntry.getMacAddress());
Optional<MacEntry> existingMacEntry = ElanUtils.read(broker,
if (isInterfaceOperational) {
// Add MAC in TOR's remote MACs via OVSDB. Outside of the loop
// on purpose.
- for (StaticMacEntries staticMacEntry : staticMacEntriesList) {
+ for (StaticMacEntries staticMacEntry : staticMacEntriesList.values()) {
staticMacAddresses.add(staticMacEntry.getMacAddress());
}
elanL2GatewayUtils.scheduleAddDpnMacInExtDevices(elanInstance.getElanInstanceName(), dpId,
mdsalManager.addFlow(writeFlowGroupTx, interfaceInfo.getDpId(), flow);
LOG.trace("Filter equals table(55) flow entry created on dpn: {} for interface port: {}",
interfaceInfo.getDpId(), interfaceInfo.getPortName());
+ Map<InstructionKey, Instruction> customInstructionsMap = new HashMap<InstructionKey, Instruction>();
+ int instructionKey = 0;
+ for (Instruction instructionObj : MDSALUtil.buildInstructionsDrop()) {
+ customInstructionsMap.put(new InstructionKey(++instructionKey), instructionObj);
+ }
Flow flowEntry = MDSALUtil.buildFlowNew(NwConstants.ELAN_FILTER_EQUALS_TABLE,
getFlowRef(NwConstants.ELAN_FILTER_EQUALS_TABLE, ifTag, "drop"), 12, elanInfo.getElanInstanceName(), 0,
0, Uint64.valueOf(ElanConstants.COOKIE_ELAN_FILTER_EQUALS.toJava().add(BigInteger.valueOf(ifTag))),
- getMatchesForFilterEqualsLPortTag(ifTag), MDSALUtil.buildInstructionsDrop());
+ getMatchesForFilterEqualsLPortTag(ifTag), customInstructionsMap);
mdsalManager.addFlow(writeFlowGroupTx, interfaceInfo.getDpId(), flowEntry);
LOG.trace("Filter equals table(55) drop flow entry created on dpn: {} for interface port: {}",
String interfaceName = interfaceInfo.getInterfaceName();
ElanInterfaceMac elanInterfaceMac = elanUtils.getElanInterfaceMacByInterfaceName(interfaceName);
if (elanInterfaceMac != null && elanInterfaceMac.getMacEntry() != null) {
- List<MacEntry> macEntries = elanInterfaceMac.getMacEntry();
+ Map<MacEntryKey, MacEntry> macEntries = elanInterfaceMac.getMacEntry();
return Collections.singletonList(ElanUtils.waitForTransactionToComplete(
txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
- for (MacEntry macEntry : macEntries) {
+ for (MacEntry macEntry : macEntries.values()) {
String macAddress = macEntry.getMacAddress().getValue();
LOG.info("Installing remote dmac for mac address {} and interface {}", macAddress,
interfaceName);
Optional<BoundServices> existingElanService = ElanUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
bindServiceId);
if (!existingElanService.isPresent()) {
- tx.put(bindServiceId, serviceInfo, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(bindServiceId, serviceInfo);
LOG.trace("Done binding elan service for elan: {} for interface: {}", elanInstanceName, interfaceName);
}
}
List<String> interfaceNames, TypedWriteTransaction<Operational> tx) {
DpnInterfaces dpnInterface = new DpnInterfacesBuilder().setDpId(dpId).setInterfaces(interfaceNames)
.withKey(new DpnInterfacesKey(dpId)).build();
- tx.put(ElanUtils.getElanDpnInterfaceOperationalDataPath(elanInstanceName, dpId), dpnInterface,
- CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(ElanUtils
+ .getElanDpnInterfaceOperationalDataPath(elanInstanceName, dpId), dpnInterface);
LOG.trace("Updated operational dpn interfaces for elan: {} with interfaces: {}", elanInstanceName,
interfaceNames);
return dpnInterface;
Elan elanState = new ElanBuilder().setName(elanInstanceName).setElanInterfaces(interfaceLists)
.withKey(new ElanKey(elanInstanceName)).build();
- tx.put(ElanUtils.getElanInstanceOperationalDataPath(elanInstanceName), elanState, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(ElanUtils.getElanInstanceOperationalDataPath(elanInstanceName), elanState);
LOG.trace("Updated operational elan state for elan: {} with interfaces: {}", elanInstanceName,
interfaceLists);
}
if (dpnInterfaceLists == null) {
return;
}
- List<ElanDpnInterfacesList> elanDpnIf = dpnInterfaceLists.nonnullElanDpnInterfacesList();
- for (ElanDpnInterfacesList elanDpns : elanDpnIf) {
+ Map<ElanDpnInterfacesListKey, ElanDpnInterfacesList> elanDpnIf = dpnInterfaceLists
+ .nonnullElanDpnInterfacesList();
+ for (ElanDpnInterfacesList elanDpns : elanDpnIf.values()) {
int cnt = 0;
String elanName = elanDpns.getElanInstanceName();
ElanInstance elanInfo = elanInstanceCache.get(elanName).orElse(null);
LOG.debug("Ignoring internal tunnel state event for Flat/Vlan elan {}", elanName);
continue;
}
- List<DpnInterfaces> dpnInterfaces = elanDpns.getDpnInterfaces();
+ Map<DpnInterfacesKey, DpnInterfaces> dpnInterfaces = elanDpns.getDpnInterfaces();
if (dpnInterfaces == null) {
continue;
}
DpnInterfaces dstDpnIf = null;
- for (DpnInterfaces dpnIf : dpnInterfaces) {
+ for (DpnInterfaces dpnIf : dpnInterfaces.values()) {
Uint64 dpnIfDpId = dpnIf.getDpId();
if (Objects.equals(dpnIfDpId, srcDpId)) {
cnt++;
if (dpnInterfaceLists == null) {
return;
}
- List<ElanDpnInterfacesList> elanDpnIf = dpnInterfaceLists.nonnullElanDpnInterfacesList();
- for (ElanDpnInterfacesList elanDpns : elanDpnIf) {
+ Map<ElanDpnInterfacesListKey, ElanDpnInterfacesList> elanDpnIf
+ = dpnInterfaceLists.nonnullElanDpnInterfacesList();
+ for (ElanDpnInterfacesList elanDpns : elanDpnIf.values()) {
String elanName = elanDpns.getElanInstanceName();
ElanInstance elanInfo = elanInstanceCache.get(elanName).orElse(null);
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.evpn.utils.EvpnUtils;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
if (!isVlanOrFlatProviderIface && oldMacEntry == null) {
InstanceIdentifier<MacEntry> elanMacEntryId =
ElanUtils.getMacEntryOperationalDataPath(elanName, physAddress);
- tx.put(elanMacEntryId, newMacEntry, WriteTransaction.CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(elanMacEntryId, newMacEntry);
}
})));
}
macAddress, !isVlanOrFlatProviderIface, tx);
InstanceIdentifier<MacEntry> macEntryId =
ElanUtils.getInterfaceMacEntriesIdentifierOperationalDataPath(interfaceName, physAddress);
- operTx.put(macEntryId, newMacEntry, WriteTransaction.CREATE_MISSING_PARENTS);
+ operTx.mergeParentStructurePut(macEntryId, newMacEntry);
}));
}));
return futures;
package org.opendaylight.netvirt.elan.internal;
-import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.elan._interface.StaticMacEntriesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.state.Elan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.forwarding.entries.MacEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.forwarding.entries.MacEntryKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.Uint32;
ElanInterfaceMac elanInterfaceMac = elanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
if (elanInterfaceMac != null && elanInterfaceMac.getMacEntry() != null
&& elanInterfaceMac.getMacEntry().size() > 0) {
- macAddress.addAll(elanInterfaceMac.getMacEntry());
+ macAddress.addAll(elanInterfaceMac.getMacEntry().values());
}
}
}
for (String elanInterface : elanInterfaces) {
ElanInterfaceMac elanInterfaceMac = elanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
if (elanInterfaceMac.getMacEntry() != null && elanInterfaceMac.getMacEntry().size() > 0) {
- List<MacEntry> macEntries = elanInterfaceMac.getMacEntry();
- for (MacEntry macEntry : macEntries) {
+ Map<MacEntryKey, MacEntry> macEntries = elanInterfaceMac.getMacEntry();
+ for (MacEntry macEntry : macEntries.values()) {
deleteStaticMacAddress(elanInterface, macEntry.getMacAddress().getValue());
}
}
public List<ElanInstance> getElanInstances() {
InstanceIdentifier<ElanInstances> elanInstancesIdentifier = InstanceIdentifier.builder(ElanInstances.class)
.build();
- return ElanUtils.read(broker, LogicalDatastoreType.CONFIGURATION, elanInstancesIdentifier).map(
- ElanInstances::getElanInstance).orElse(emptyList());
+ return new ArrayList<>(ElanUtils.read(broker, LogicalDatastoreType.CONFIGURATION, elanInstancesIdentifier).map(
+ ElanInstances::getElanInstance).orElse(emptyMap()).values());
}
@Override
if (!elanInterfacesOptional.isPresent()) {
return elanInterfaces;
}
- List<ElanInterface> elanInterfaceList = elanInterfacesOptional.get().nonnullElanInterface();
- for (ElanInterface elanInterface : elanInterfaceList) {
+ Map<ElanInterfaceKey, ElanInterface> elanInterfaceList = elanInterfacesOptional.get().nonnullElanInterface();
+ for (ElanInterface elanInterface : elanInterfaceList.values()) {
if (Objects.equals(elanInterface.getElanInstanceName(), elanInstanceName)) {
elanInterfaces.add(elanInterface.getName());
}
return;
}
- List<Node> nodes = southboundUtils.getOvsdbNodes();
+ Map<NodeKey, Node> nodes = southboundUtils.getOvsdbNodes();
if (nodes == null || nodes.isEmpty()) {
LOG.trace("No OVS nodes found while creating external network for ELAN {}",
elanInstance.getElanInstanceName());
return;
}
- for (Node node : nodes) {
+ for (Node node : nodes.values()) {
if (bridgeMgr.isIntegrationBridge(node)) {
if (update && !elanInstance.isExternal()) {
DpnInterfaces dpnInterfaces = elanUtils.getElanInterfaceInfoByElanDpn(elanInstanceName,
return;
}
String flowId = ArpResponderUtil.getFlowId(lportTag, ipAddress);
+ Map<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction>
+ arpResponderInputInstructionsMap = new HashMap<>();
+ int instructionKey = 0;
+ for (org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction
+ instructionObj : arpResponderInput.getInstructions()) {
+ arpResponderInputInstructionsMap.put(new org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
+ .rev131026.instruction.list.InstructionKey(++instructionKey), instructionObj);
+ }
Flow flowEntity =
MDSALUtil.buildFlowNew(NwConstants.ARP_RESPONDER_TABLE, flowId, NwConstants.DEFAULT_ARP_FLOW_PRIORITY,
flowId, 0, 0,
ArpResponderUtil.generateCookie(lportTag, ipAddress),
ArpResponderUtil.getMatchCriteria(lportTag, elanInstance, ipAddress),
- arpResponderInput.getInstructions());
+ arpResponderInputInstructionsMap);
LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
tx -> mdsalManager.addFlow(tx, dpnId, flowEntity)), LOG, "Error adding flow {}", flowEntity);
LOG.info("Installed the ARP Responder flow for Interface {}", ingressInterfaceName);
int lportTag = arpResponderInput.getLportTag();
String flowId = ArpResponderUtil.getFlowId(lportTag, ipAddress);
+
+ Map<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction>
+ arpResponderInputInstructionsMap = new HashMap<>();
+ int instructionKey = 0;
+ for (org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction
+ instructionObj : arpResponderInput.getInstructions()) {
+ arpResponderInputInstructionsMap.put(new org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
+ .rev131026.instruction.list.InstructionKey(++instructionKey), instructionObj);
+ }
+
Flow flowEntity =
MDSALUtil.buildFlowNew(NwConstants.ARP_RESPONDER_TABLE, flowId, NwConstants.DEFAULT_ARP_FLOW_PRIORITY,
flowId, 0, 0,
ArpResponderUtil.generateCookie(lportTag, ipAddress),
ArpResponderUtil.getMatchCriteria(lportTag, elanInstance, ipAddress),
- arpResponderInput.getInstructions());
+ arpResponderInputInstructionsMap);
LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
tx -> mdsalManager.addFlow(tx, dpnId, flowEntity)), LOG, "Error adding flow {}", flowEntity);
LOG.trace("Installed the ExternalTunnel ARP Responder flow for ElanInstance {}", elanInstanceName);
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
import java.util.concurrent.Callable;
-
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
import java.util.concurrent.Callable;
-
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
*/
package org.opendaylight.netvirt.elan.internal;
+import java.util.ArrayList;
import java.util.stream.Collectors;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
boolean shouldCreateVtep;
if (original.getVpnInterfaces() != null && !original.getVpnInterfaces().isEmpty()) {
- shouldCreateVtep = transportZoneNotificationUtil.shouldCreateVtep(update.getVpnInterfaces().stream()
- .filter(vi -> !original.getVpnInterfaces().contains(vi)).collect(Collectors.toList()));
+ shouldCreateVtep = transportZoneNotificationUtil
+ .shouldCreateVtep(update.getVpnInterfaces().values().stream()
+ .filter(vi -> !original.getVpnInterfaces().values().contains(vi)).collect(Collectors.toList()));
} else {
- shouldCreateVtep = transportZoneNotificationUtil.shouldCreateVtep(update.getVpnInterfaces());
+ shouldCreateVtep = transportZoneNotificationUtil.shouldCreateVtep(
+ new ArrayList<>(update.getVpnInterfaces().values()));
}
if (shouldCreateVtep) {
}
LOG.debug("Vpn dpn {} add detected, updating transport zones", add.getDpnId());
- boolean shouldCreateVtep = transportZoneNotificationUtil.shouldCreateVtep(add.getVpnInterfaces());
+ boolean shouldCreateVtep = transportZoneNotificationUtil.shouldCreateVtep(
+ new ArrayList<>(add.getVpnInterfaces().values()));
if (shouldCreateVtep) {
String vrfId = identifier.firstKeyOf(VpnInstanceOpDataEntry.class).getVrfId();
transportZoneNotificationUtil.updateTransportZone(vrfId, add.getDpnId());
*/
package org.opendaylight.netvirt.elan.l2gw.ha;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.base.Strings;
import java.nio.charset.StandardCharsets;
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.concurrent.ExecutionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.ManagersBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.ManagersKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Switches;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.SwitchesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.managers.ManagerOtherConfigs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.managers.ManagerOtherConfigsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.managers.ManagerOtherConfigsKey;
}
HwvtepGlobalAugmentation globalAugmentation = node.augmentation(HwvtepGlobalAugmentation.class);
if (globalAugmentation != null) {
- List<Managers> managers = globalAugmentation.getManagers();
+ List<Managers> managers = new ArrayList<Managers>(globalAugmentation.getManagers().values());
if (managers != null && !managers.isEmpty() && managers.get(0).getManagerOtherConfigs() != null) {
- for (ManagerOtherConfigs configs : managers.get(0).getManagerOtherConfigs()) {
+ for (ManagerOtherConfigs configs : managers.get(0).getManagerOtherConfigs().values()) {
if (HA_ID.equals(configs.getOtherConfigKey())) {
return configs.getOtherConfigValue();
}
haGlobalConfigNodeOptional.get().augmentation(HwvtepGlobalAugmentation.class);
if (augmentation != null && augmentation.getManagers() != null
&& augmentation.getManagers().size() > 0) {
- Managers managers = augmentation.getManagers().get(0);
+ Managers managers = new ArrayList<Managers>(augmentation.getManagers().values()).get(0);
if (null == managers.getManagerOtherConfigs()) {
return childNodeIds;
}
- for (ManagerOtherConfigs otherConfigs : managers.getManagerOtherConfigs()) {
+ for (ManagerOtherConfigs otherConfigs : managers.getManagerOtherConfigs().values()) {
if (HA_CHILDREN.equals(otherConfigs.getOtherConfigKey())) {
String nodeIdsVal = otherConfigs.getOtherConfigValue();
if (nodeIdsVal != null) {
if (!switchesAlreadyPresent) {
HwvtepGlobalAugmentation augmentation = childNode.augmentation(HwvtepGlobalAugmentation.class);
if (augmentation != null && augmentation.getSwitches() != null) {
- List<Switches> src = augmentation.getSwitches();
+ List<Switches> src = new ArrayList<Switches>(augmentation.getSwitches().values());
if (src != null && src.size() > 0) {
psList.add(new SwitchesCmd().transform(haNodePath, src.get(0)));
}
nodeBuilder.setNodeId(haNodePath.firstKeyOf(Node.class).getNodeId());
nodeBuilder.addAugmentation(HwvtepGlobalAugmentation.class, hwvtepGlobalBuilder.build());
Node configHANode = nodeBuilder.build();
- tx.merge(haNodePath, configHANode, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(haNodePath, configHANode);
}
public static <D extends Datastore> void deleteNodeIfPresent(TypedReadWriteTransaction<D> tx,
return;
}
HashMap<InstanceIdentifier<Node>,Boolean> deleted = new HashMap<>();
- List<Switches> switches = globalAugmentation.getSwitches();
+ Map<SwitchesKey, Switches> switches = globalAugmentation.getSwitches();
if (switches != null) {
- for (Switches switche : switches) {
+ for (Switches switche : switches.values()) {
InstanceIdentifier<Node> psId = (InstanceIdentifier<Node>)switche.getSwitchRef().getValue();
deleteNodeIfPresent(tx, psId);
deleted.put(psId, Boolean.TRUE);
if (topologyOptional.isPresent()) {
Topology topology = topologyOptional.get();
if (topology.getNode() != null) {
- for (Node psNode : topology.getNode()) {
+ for (Node psNode : topology.getNode().values()) {
PhysicalSwitchAugmentation ps = psNode.augmentation(PhysicalSwitchAugmentation.class);
if (ps != null) {
InstanceIdentifier<Node> iid = (InstanceIdentifier<Node>)ps.getManagedBy().getValue();
@Override
@Nullable
public List<LocalMcastMacs> getData(HwvtepGlobalAugmentation node) {
- if (node != null) {
- return node.getLocalMcastMacs();
+ if (node != null && node.getLocalMcastMacs() != null) {
+ return new ArrayList<LocalMcastMacs>(node.getLocalMcastMacs().values());
}
return null;
}
*/
package org.opendaylight.netvirt.elan.l2gw.ha.commands;
+import java.util.ArrayList;
import java.util.List;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
@Override
@Nullable
public List<LocalUcastMacs> getData(HwvtepGlobalAugmentation node) {
- if (node != null) {
- return node.getLocalUcastMacs();
+ if (node != null && node.getLocalUcastMacs() != null) {
+ return new ArrayList<LocalUcastMacs>(node.getLocalUcastMacs().values());
}
return null;
}
*/
package org.opendaylight.netvirt.elan.l2gw.ha.commands;
+import java.util.ArrayList;
import java.util.List;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
@Override
@Nullable
public List<LogicalSwitches> getData(HwvtepGlobalAugmentation node) {
- if (node != null) {
- return node.getLogicalSwitches();
+ if (node != null && node.getLogicalSwitches() != null) {
+ return new ArrayList<LogicalSwitches>(node.getLogicalSwitches().values());
}
return null;
}
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
-import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.locator.set.attributes.LocatorSet;
T transformedItem = transform(nodePath, addedItem);
String nodeId = transformedId.firstKeyOf(Node.class).getNodeId().getValue();
LOG.trace("adding {} {} {}", getDescription(), nodeId, getKey(transformedItem));
- tx.put(datastoreType, transformedId, transformedItem, WriteTransaction.CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(datastoreType, transformedId, transformedItem);
}
}
List<T> removed = new ArrayList<>(orig);
*/
package org.opendaylight.netvirt.elan.l2gw.ha.commands;
+import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import org.eclipse.jdt.annotation.Nullable;
@Override
@Nullable
public List<TerminationPoint> getData(Node node) {
- if (node != null) {
- return node.getTerminationPoint();
+ if (node != null && node.getTerminationPoint() != null) {
+ return new ArrayList<TerminationPoint>(node.getTerminationPoint().values());
}
return null;
}
@Override
@Nullable
public List<RemoteMcastMacs> getData(HwvtepGlobalAugmentation augmentation) {
- if (augmentation != null) {
- return augmentation.getRemoteMcastMacs();
+ if (augmentation != null && augmentation.getRemoteMcastMacs() != null) {
+ return new ArrayList<RemoteMcastMacs>(augmentation.getRemoteMcastMacs().values());
}
return null;
}
*/
package org.opendaylight.netvirt.elan.l2gw.ha.commands;
+import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import org.eclipse.jdt.annotation.Nullable;
@Override
@Nullable
public List<RemoteUcastMacs> getData(HwvtepGlobalAugmentation node) {
- if (node != null) {
- return node.getRemoteUcastMacs();
+ if (node != null && node.getRemoteUcastMacs() != null) {
+ return new ArrayList<RemoteUcastMacs>(node.getRemoteUcastMacs().values());
}
return null;
}
*/
package org.opendaylight.netvirt.elan.l2gw.ha.commands;
+import java.util.ArrayList;
import java.util.List;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
@Override
@Nullable
public List<Switches> getData(HwvtepGlobalAugmentation node) {
- if (node != null) {
- return node.getSwitches();
+ if (node != null && node.getSwitches() != null) {
+ return new ArrayList<Switches>(node.getSwitches().values());
}
return null;
}
package org.opendaylight.netvirt.elan.l2gw.ha.commands;
import java.io.Serializable;
+import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
@Override
@Nullable
public List<TerminationPoint> getData(Node node) {
- if (node != null) {
- return node.getTerminationPoint();
+ if (node != null && node.getTerminationPoint() != null) {
+ return new ArrayList<TerminationPoint>(node.getTerminationPoint().values());
}
return null;
}
new HwvtepPhysicalPortAugmentationBuilder(augmentation);
if (augmentation.getVlanBindings() != null && augmentation.getVlanBindings().size() > 0) {
- tpAugmentationBuilder.setVlanBindings(augmentation.getVlanBindings().stream().map(
+ tpAugmentationBuilder.setVlanBindings(augmentation.getVlanBindings().values().stream().map(
vlanBindings -> {
VlanBindingsBuilder vlanBindingsBuilder = new VlanBindingsBuilder(vlanBindings);
vlanBindingsBuilder.setLogicalSwitchRef(
.augmentation(HwvtepPhysicalPortAugmentation.class);
HwvtepPhysicalPortAugmentation origAugmentation = orig.augmentation(HwvtepPhysicalPortAugmentation.class);
- List<VlanBindings> up = updatedAugmentation != null ? updatedAugmentation.getVlanBindings() : null;
- List<VlanBindings> or = origAugmentation != null ? origAugmentation.getVlanBindings() : null;
+ List<VlanBindings> up
+ = updatedAugmentation != null ? new ArrayList<>(updatedAugmentation.getVlanBindings().values()) : null;
+ List<VlanBindings> or
+ = origAugmentation != null ? new ArrayList<>(origAugmentation.getVlanBindings().values()) : null;
if (!areSameSize(up, or)) {
return false;
}
*/
package org.opendaylight.netvirt.elan.l2gw.ha.commands;
+import java.util.ArrayList;
import java.util.List;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
@Override
@Nullable
public List<Tunnels> getData(PhysicalSwitchAugmentation node) {
- if (node != null) {
- return node.getTunnels();
+ if (node != null && node.getTunnels() != null) {
+ return new ArrayList<Tunnels>(node.getTunnels().values());
}
return null;
}
*/
package org.opendaylight.netvirt.elan.l2gw.ha.commands;
+import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import org.eclipse.jdt.annotation.Nullable;
@Override
@Nullable
public List<TunnelIps> getData(PhysicalSwitchAugmentation node) {
- if (node != null) {
- return node.getTunnelIps();
+ if (node != null && node.getTunnelIps() != null) {
+ return new ArrayList<TunnelIps>(node.getTunnelIps().values());
}
return null;
}
package org.opendaylight.netvirt.elan.l2gw.ha.handlers;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Switches;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.SwitchesKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
LOG.info("HA ps node not present cleanup child {}" , childNode);
HwvtepGlobalAugmentation augmentation = childNode.augmentation(HwvtepGlobalAugmentation.class);
if (augmentation != null) {
- List<Switches> switches = augmentation.getSwitches();
+ Map<SwitchesKey, Switches> switches = augmentation.getSwitches();
if (switches != null) {
- for (Switches ps : switches) {
+ for (Switches ps : switches.values()) {
HwvtepHAUtil.deleteNodeIfPresent(tx, ps.getSwitchRef().getValue());
}
}
if (childGlobalNode == null || childGlobalNode.augmentation(HwvtepGlobalAugmentation.class) == null) {
return;
}
- List<Switches> switches = childGlobalNode.augmentation(HwvtepGlobalAugmentation.class).getSwitches();
- if (switches == null) {
+ Map<SwitchesKey, Switches> keySwitchesMap
+ = childGlobalNode.augmentation(HwvtepGlobalAugmentation.class).getSwitches();
+ if (keySwitchesMap == null) {
return;
}
- for (Switches ps : switches) {
- Node childPsNode = tx.read((InstanceIdentifier<Node>) ps.getSwitchRef().getValue()).get().orElse(null);
+ for (Switches ps : keySwitchesMap.values()) {
+ Node childPsNode = tx.read((InstanceIdentifier<Node>) ps.getSwitchRef().getValue()).get()
+ .orElse(null);
if (childPsNode != null) {
InstanceIdentifier<Node> haPsPath = HwvtepHAUtil.convertPsPath(childPsNode, haNodePath);
copyChildPSOpToHAPS(childPsNode, haNodePath, haPsPath, tx);
globalNodeMerger.mergeConfigData(nodeBuilder, srcNode, childPath);
nodeBuilder.addAugmentation(HwvtepGlobalAugmentation.class, dstBuilder.build());
Node dstNode = nodeBuilder.build();
- tx.put(childPath, dstNode, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(childPath, dstNode);
}
/**
haBuilder.setDbVersion(childData.getDbVersion());
haNodeBuilder.addAugmentation(HwvtepGlobalAugmentation.class, haBuilder.build());
Node haNode = haNodeBuilder.build();
- tx.merge(haNodePath, haNode, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(haNodePath, haNode);
}
/**
childPsBuilder.addAugmentation(PhysicalSwitchAugmentation.class, dstBuilder.build());
Node childPSNode = childPsBuilder.build();
- tx.put(childPsPath, childPSNode, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(childPsPath, childPSNode);
}
/**
haPSNodeBuilder.addAugmentation(PhysicalSwitchAugmentation.class, dstBuilder.build());
Node haPsNode = haPSNodeBuilder.build();
- tx.merge(haPspath, haPsNode, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(haPspath, haPsNode);
}
}
package org.opendaylight.netvirt.elan.l2gw.ha.handlers;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
//Also update the manager section in config which helps in cluster reboot scenarios
LoggingFutures.addErrorLogging(
txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- confTx -> haBuilder.getManagers().forEach(manager -> {
+ confTx -> haBuilder.getManagers().values().forEach(manager -> {
InstanceIdentifier<Managers> managerIid =
dstPath.augmentation(HwvtepGlobalAugmentation.class).child(Managers.class, manager.key());
- confTx.put(managerIid, manager, CREATE_MISSING_PARENTS);
+ confTx.mergeParentStructurePut(managerIid, manager);
})), LOG, "Error updating the manager section in config");
} else {
haNodeBuilder.addAugmentation(HwvtepGlobalAugmentation.class, haBuilder.build());
Node haNode = haNodeBuilder.build();
if (Operational.class.equals(datastoreType)) {
- tx.merge(dstPath, haNode, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(dstPath, haNode);
} else {
- tx.put(dstPath, haNode, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(dstPath, haNode);
}
}
dstPsNodeBuilder.addAugmentation(PhysicalSwitchAugmentation.class, dstPsAugmentationBuilder.build());
Node dstPsNode = dstPsNodeBuilder.build();
- tx.merge(dstPsPath, dstPsNode, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(dstPsPath, dstPsNode);
LOG.debug("Copied {} physical switch node from {} to {}", datastoreType, srcPsPath, dstPsPath);
}
String childGlobalNodeId = childNode.getNodeId().getValue();
List<InstanceIdentifier> childPsIids = new ArrayList<>();
HwvtepGlobalAugmentation hwvtepGlobalAugmentation = childNode.augmentation(HwvtepGlobalAugmentation.class);
- if (hwvtepGlobalAugmentation == null || HwvtepHAUtil.isEmpty(hwvtepGlobalAugmentation.getSwitches())) {
+ if (hwvtepGlobalAugmentation == null || HwvtepHAUtil.isEmpty(hwvtepGlobalAugmentation.getSwitches().values())) {
haOpClusteredListener.getConnectedNodes()
.stream()
.filter((connectedIid) -> IS_PS_CHILD_TO_GLOBAL_NODE.test(childGlobalNodeId, connectedIid))
.forEach(childPsIids::add);
} else {
- hwvtepGlobalAugmentation.getSwitches().forEach(
+ hwvtepGlobalAugmentation.getSwitches().values().forEach(
(switches) -> childPsIids.add(switches.getSwitchRef().getValue()));
}
if (childPsIids.isEmpty()) {
package org.opendaylight.netvirt.elan.l2gw.ha.listeners;
import com.google.common.collect.ImmutableMap;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
List<Managers> up = null;
List<Managers> be = null;
if (updatedAugmentaion != null) {
- up = updatedAugmentaion.getManagers();
+ up = new ArrayList<Managers>(updatedAugmentaion.getManagers().values());
}
if (beforeAugmentaion != null) {
- be = beforeAugmentaion.getManagers();
+ be = new ArrayList<Managers>(beforeAugmentaion.getManagers().values());
}
if (up != null) {
InstanceIdentifier<Node> parent = key.firstIdentifierOf(Node.class);
if (managers.key().getTarget().getValue().contains(HwvtepHAUtil.MANAGER_KEY)
&& managers.getManagerOtherConfigs() != null) {
- managers.getManagerOtherConfigs().stream()
+ managers.getManagerOtherConfigs().values().stream()
.filter(otherConfig -> otherConfig.key().getOtherConfigKey().contains(HwvtepHAUtil.HA_CHILDREN))
.flatMap(otherConfig -> Arrays.stream(otherConfig.getOtherConfigValue().split(",")))
.map(HwvtepHAUtil::convertToInstanceIdentifier)
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import java.util.Collection;
import java.util.HashMap;
if (create) {
if (isDataUpdated(existingDataOptional, transformedItem)) {
LOG.debug("Copy to {} {} {}", destination, datastoreType, transformedId);
- tx.put(transformedId, transformedItem, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(transformedId, transformedItem);
} else {
LOG.debug("Data not updated skip copy to {}", transformedId);
}
package org.opendaylight.netvirt.elan.l2gw.jobs;
import com.google.common.util.concurrent.ListenableFuture;
-
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.Callable;
-
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanRefUtil;
import org.opendaylight.netvirt.elan.utils.ElanDmacUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
-
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
package org.opendaylight.netvirt.elan.l2gw.jobs;
import com.google.common.util.concurrent.ListenableFuture;
-
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
-
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
import org.opendaylight.netvirt.elan.utils.ElanClusterUtils;
import org.opendaylight.netvirt.elan.utils.ElanItmUtils;
import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
import static org.opendaylight.netvirt.elan.utils.ElanConstants.ELAN_EOS_DELAY;
-import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ScheduledFuture;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfacesKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
elanDpnInterfacesInstanceIdentifier);
if (optional.isPresent() && optional.get().getElanDpnInterfacesList() != null) {
LOG.debug("Found elan dpn interfaces list");
- optional.get().getElanDpnInterfacesList().forEach(elanDpnInterfacesList -> {
- List<DpnInterfaces> dpnInterfaces = elanDpnInterfacesList.getDpnInterfaces();
+ optional.get().getElanDpnInterfacesList().values().forEach(elanDpnInterfacesList -> {
+ Map<DpnInterfacesKey, DpnInterfaces> dpnInterfaces
+ = elanDpnInterfacesList.getDpnInterfaces();
InstanceIdentifier<ElanDpnInterfacesList> parentIid = InstanceIdentifier
.builder(ElanDpnInterfaces.class).child(ElanDpnInterfacesList.class,
new ElanDpnInterfacesListKey(elanDpnInterfacesList
.getElanInstanceName())).build();
- for (DpnInterfaces dpnInterface : dpnInterfaces) {
+ for (DpnInterfaces dpnInterface : dpnInterfaces.values()) {
LOG.debug("Found elan dpn interfaces");
elanDpnInterfaceClusteredListener.add(parentIid
.child(DpnInterfaces.class, dpnInterface.key()),
import java.util.Collections;
import java.util.HashSet;
-import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelIpsKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
globalIid.firstKeyOf(Node.class).getNodeId().getValue());
private static final Predicate<PhysicalSwitchAugmentation> TUNNEL_IP_AVAILABLE =
- phySwitch -> !HwvtepHAUtil.isEmpty(phySwitch.getTunnelIps());
+ phySwitch -> !HwvtepHAUtil.isEmpty(phySwitch.getTunnelIps().values());
private static final Predicate<PhysicalSwitchAugmentation> TUNNEL_IP_NOT_AVAILABLE = TUNNEL_IP_AVAILABLE.negate();
l2GwDevice.setConnected(true);
l2GwDevice.setHwvtepNodeId(globalNodeId);
- List<TunnelIps> tunnelIps = phySwitchAdded.getTunnelIps();
+ Map<TunnelIpsKey, TunnelIps> tunnelIps = phySwitchAdded.getTunnelIps();
if (tunnelIps != null) {
- for (TunnelIps tunnelIp : tunnelIps) {
+ for (TunnelIps tunnelIp : tunnelIps.values()) {
IpAddress tunnelIpAddr = tunnelIp.getTunnelIpsKey();
l2GwDevice.addTunnelIp(tunnelIpAddr);
}
psBuilder = new PhysicalSwitchAugmentationBuilder(existingSwitch.get());
}
psBuilder.setTunnelIps(phySwitchAdded.getTunnelIps());
- tx.put(identifier, psBuilder.build(), true);
+ tx.mergeParentStructurePut(identifier, psBuilder.build());
LOG.trace("Updating config tunnel ips {}", identifier);
}), LOG, "Failed to update the config tunnel ips {}", identifier);
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayCache;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.Devices;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.DevicesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.devices.Interfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.connections.attributes.l2gatewayconnections.L2gatewayConnection;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateways.attributes.l2gateways.L2gateway;
} else {
String logicalSwitchName = ElanL2GatewayUtils.getLogicalSwitchFromElan(
l2GwConn.getNetworkId().getValue());
- List<Devices> l2Devices = l2Gateway.nonnullDevices();
- for (Devices l2Device : l2Devices) {
+ Map<DevicesKey, Devices> l2Devices = l2Gateway.nonnullDevices();
+ for (Devices l2Device : l2Devices.values()) {
String l2DeviceName = l2Device.getDeviceName();
if (l2DeviceName != null && l2DeviceName.equals(psName)) {
- for (Interfaces deviceInterface : l2Device.nonnullInterfaces()) {
+ for (Interfaces deviceInterface : l2Device.nonnullInterfaces().values()) {
if (Objects.equals(deviceInterface.getInterfaceName(), newPortId)) {
if (deviceInterface.getSegmentationIds() != null
&& !deviceInterface.getSegmentationIds().isEmpty()) {
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
private static final Predicate<Node> IS_HA_PARENT_NODE = (node) -> {
HwvtepGlobalAugmentation augmentation = node.augmentation(HwvtepGlobalAugmentation.class);
if (augmentation != null && augmentation.getManagers() != null) {
- return augmentation.getManagers().stream().anyMatch(
+ return augmentation.getManagers().values().stream().anyMatch(
manager -> manager.key().getTarget().getValue().equals(HwvtepHAUtil.MANAGER_KEY));
}
return false;
@Override
public void onSuccess(Optional<Topology> topologyOptional) {
if (topologyOptional != null && topologyOptional.isPresent()) {
- loadL2GwDeviceCache(topologyOptional.get().getNode());
+ loadL2GwDeviceCache(new ArrayList<Node>(topologyOptional.get().getNode().values()));
}
registerListener();
}
}
if (optional.isPresent() && optional.get().getL2gatewayConnection() != null) {
LOG.trace("Found some connections to fill in l2gw connection cache");
- optional.get().getL2gatewayConnection()
+ new ArrayList<>(optional.get().getL2gatewayConnection().values())
.forEach(connection -> {
add(parentIid.child(L2gatewayConnection.class, connection.key()), connection);
});
l2GwDevice.setHwvtepNodeId(globalNode.getNodeId().getValue());
List<TunnelIps> tunnelIps = psNode.augmentation(PhysicalSwitchAugmentation.class) != null
- ? psNode.augmentation(PhysicalSwitchAugmentation.class).getTunnelIps() : null;
+ ? new ArrayList<>(psNode.augmentation(PhysicalSwitchAugmentation.class).getTunnelIps().values()) : null;
if (tunnelIps != null) {
for (TunnelIps tunnelIp : tunnelIps) {
IpAddress tunnelIpAddr = tunnelIp.getTunnelIpsKey();
public void add(final InstanceIdentifier<L2gateway> identifier, final L2gateway input) {
LOG.info("Adding L2gateway with ID: {}", input.getUuid());
- for (Devices l2Device : input.nonnullDevices()) {
+ for (Devices l2Device : input.nonnullDevices().values()) {
LOG.trace("Adding L2gateway device: {}", l2Device);
addL2Device(l2Device, input);
}
}), new FutureCallback<Void>() {
@Override
public void onSuccess(Void result) {
- for (Devices l2Device : input.nonnullDevices()) {
+ for (Devices l2Device : input.nonnullDevices().values()) {
LOG.trace("Removing L2gateway device: {}", l2Device);
removeL2Device(l2Device, input);
}
jobCoordinator.enqueueJob("l2gw.update", () -> {
ListenableFuture<Void> future = txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
DeviceInterfaces updatedDeviceInterfaces = new DeviceInterfaces(update);
- original.getDevices()
+ original.getDevices().values()
.stream()
.filter((originalDevice) -> originalDevice.getInterfaces() != null)
.forEach((originalDevice) -> {
L2GatewayDevice l2GwDevice = l2GatewayCache.get(deviceName);
NodeId physicalSwitchNodeId = HwvtepSouthboundUtils.createManagedNodeId(
new NodeId(l2GwDevice.getHwvtepNodeId()), deviceName);
- originalDevice.getInterfaces()
+ originalDevice.getInterfaces().values()
.stream()
.filter((intf) -> !updatedDeviceInterfaces.containsInterface(
deviceName, intf.getInterfaceName()))
DeviceInterfaces(L2gateway l2gateway) {
if (l2gateway.getDevices() != null) {
- l2gateway.getDevices().forEach((device) -> {
+ l2gateway.getDevices().values().forEach((device) -> {
deviceInterfacesMap.putIfAbsent(device.getDeviceName(), new HashMap<>());
if (device.getInterfaces() != null) {
- device.getInterfaces().forEach((intf) ->
+ device.getInterfaces().values().forEach((intf) ->
deviceInterfacesMap.get(device.getDeviceName()).put(intf.getInterfaceName(), intf));
}
});
if (node != null) {
HwvtepGlobalAugmentation augmentation = node.augmentation(HwvtepGlobalAugmentation.class);
if (augmentation != null && augmentation.getLocalUcastMacs() != null) {
- return new HashSet<>(augmentation.getLocalUcastMacs());
+ return new HashSet<>(augmentation.getLocalUcastMacs().values());
}
}
return Collections.emptySet();
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
@Nullable
private static DpnInterfaces getDpnInterfaces(ElanDpnInterfacesList elanDpns, Uint64 dpnId) {
if (elanDpns != null) {
- for (DpnInterfaces dpnInterface : elanDpns.nonnullDpnInterfaces()) {
+ for (DpnInterfaces dpnInterface : elanDpns.nonnullDpnInterfaces().values()) {
if (Objects.equals(dpnInterface.getDpId(), dpnId)) {
return dpnInterface;
}
if (operElanInstance == null) {
return emptyList();
}
- List<ExternalTeps> teps = operElanInstance.getExternalTeps();
+ Map<ExternalTepsKey, ExternalTeps> teps = operElanInstance.getExternalTeps();
if (teps == null || teps.isEmpty()) {
return emptyList();
}
List<Bucket> listBucketInfo = new ArrayList<>();
- for (ExternalTeps tep : teps) {
+ for (ExternalTeps tep : teps.values()) {
String externalTep = tep.getNodeid() != null ? tep.getNodeid() : tep.getTepIp().toString();
String interfaceName = elanItmUtils.getExternalTunnelInterfaceName(String.valueOf(dpnId),
externalTep);
long elanTagOrVni) {
List<Bucket> listBucketInfo = new ArrayList<>();
if (elanDpns != null) {
- for (DpnInterfaces dpnInterface : elanDpns.nonnullDpnInterfaces()) {
+ for (DpnInterfaces dpnInterface : elanDpns.nonnullDpnInterfaces().values()) {
if (!Objects.equals(dpnInterface.getDpId(), dpnId) && dpnInterface.getInterfaces() != null
&& !dpnInterface.getInterfaces().isEmpty()) {
try {
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.locator.set.attributes.LocatorSet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindings;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
for (String interfaceName : lstElanInterfaceNames) {
ElanInterfaceMac elanInterfaceMac = ElanUtils.getElanInterfaceMacByInterfaceName(broker, interfaceName);
if (elanInterfaceMac != null && elanInterfaceMac.getMacEntry() != null) {
- for (MacEntry macEntry : elanInterfaceMac.getMacEntry()) {
+ for (MacEntry macEntry : new ArrayList<MacEntry>(elanInterfaceMac.getMacEntry().values())) {
result.add(macEntry.getMacAddress());
}
}
HwvtepGlobalAugmentation augmentation = configNode.get().augmentation(
HwvtepGlobalAugmentation.class);
if (augmentation != null && augmentation.getLocalUcastMacs() != null) {
- macs.addAll(augmentation.getLocalUcastMacs().stream()
+ macs.addAll(new ArrayList<LocalUcastMacs>(augmentation
+ .getLocalUcastMacs().values()).stream()
.filter(mac -> getLogicalSwitchName(mac).equals(elanName))
.map(HwvtepMacTableGenericAttributes::getMacEntryKey)
.collect(Collectors.toSet()));
return Collections.emptyList();
}
if (hwvtepNode != null) {
- List<RemoteUcastMacs> remoteUcastMacs = hwvtepNode.augmentation(HwvtepGlobalAugmentation.class)
+ Map<RemoteUcastMacsKey, RemoteUcastMacs> keyRemoteUcastMacsMap
+ = hwvtepNode.augmentation(HwvtepGlobalAugmentation.class)
.getRemoteUcastMacs();
- if (remoteUcastMacs != null && !remoteUcastMacs.isEmpty()) {
- // Filtering remoteUcastMacs based on the logical switch and
+ if (keyRemoteUcastMacsMap != null && !keyRemoteUcastMacsMap.isEmpty()) {
+ // Filtering keyRemoteUcastMacsMap based on the logical switch and
// forming a list of MacAddress
- lstMacs = remoteUcastMacs.stream()
+ lstMacs = keyRemoteUcastMacsMap.values().stream()
.filter(mac -> logicalSwitch.equals(mac.getLogicalSwitchRef().getValue()
.firstKeyOf(LogicalSwitches.class).getHwvtepNodeName().getValue()))
.map(HwvtepMacTableGenericAttributes::getMacEntryKey).collect(Collectors.toList());
return lstRemoteUcastMacs;
}
- for (MacEntry macEntry : macTable.getMacEntry()) {
+ for (MacEntry macEntry : new ArrayList<MacEntry>(macTable.getMacEntry().values())) {
Uint64 dpnId = getDpidFromInterface(macEntry.getInterface());
if (dpnId == null) {
LOG.error("DPN ID not found for interface {}", macEntry.getInterface());
return txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
for (org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712
- .l2gateway.attributes.devices.Interfaces deviceInterface : hwVtepDevice.getInterfaces()) {
+ .l2gateway.attributes.devices.Interfaces deviceInterface : new ArrayList<>(hwVtepDevice
+ .getInterfaces().values())) {
//Removed the check for checking terminationPoint present in OP or not
//for coniguring vlan bindings
//As we are not any more dependent on it , plugin takes care of this
return txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
for (org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712
- .l2gateway.attributes.devices.Interfaces deviceInterface : hwVtepDevice.getInterfaces()) {
+ .l2gateway.attributes.devices.Interfaces deviceInterface : new ArrayList<>(hwVtepDevice
+ .getInterfaces().values())) {
String phyPortName = deviceInterface.getInterfaceName();
if (deviceInterface.getSegmentationIds() != null && !deviceInterface.getSegmentationIds().isEmpty()) {
for (Integer vlanId : deviceInterface.getSegmentationIds()) {
String psNodeId = globalNodeId + HwvtepHAUtil.PHYSICALSWITCH + psName;
tzonesoptional.get().nonnullTransportZone().stream()
.filter(zone -> zone.getDeviceVteps() != null)
- .flatMap(zone -> zone.getDeviceVteps().stream())
+ .flatMap(zone -> new ArrayList<DeviceVteps>(zone.getDeviceVteps().values()).stream())
.filter(deviceVteps -> Objects.equals(getPsName(deviceVteps), psName)) //get device with same ps name
.filter(deviceVteps -> !Objects.equals(psNodeId, deviceVteps.getNodeId())
|| !Objects.equals(tunnelIp, deviceVteps.getIpAddress()))//node id or tunnel ip is changed
}
LoggingFutures.addErrorLogging(
new ManagedNewTransactionRunnerImpl(dataBroker).callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
- tx -> optionalElan.get().nonnullElanInstance().stream()
- .flatMap(elan -> elan.nonnullExternalTeps().stream()
+ tx -> optionalElan.get().nonnullElanInstance().values().stream()
+ .flatMap(elan -> elan.nonnullExternalTeps().values().stream()
.map(externalTep -> ElanL2GatewayMulticastUtils.buildExternalTepPath(
elan.getElanInstanceName(), externalTep.getTepIp())))
.filter(externalTepIid -> Objects.equals(
if (configNode.isPresent()) {
HwvtepGlobalAugmentation augmentation = configNode.get().augmentation(HwvtepGlobalAugmentation.class);
if (augmentation != null && augmentation.getLocalUcastMacs() != null) {
- macs.addAll(augmentation.getLocalUcastMacs().stream()
+ macs.addAll(augmentation.getLocalUcastMacs().values().stream()
.filter(mac -> getLogicalSwitchName(mac).equals(elanName))
.map(HwvtepMacTableGenericAttributes::getMacEntryKey)
.collect(Collectors.toSet()));
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.cache.ConfigMcastCache;
package org.opendaylight.netvirt.elan.l2gw.utils;
-import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
import static org.opendaylight.netvirt.elan.utils.ElanUtils.isVxlanNetworkOrVxlanSegment;
import com.google.common.collect.Lists;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.Devices;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.DevicesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.connections.attributes.L2gatewayConnections;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.connections.attributes.l2gatewayconnections.L2gatewayConnection;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateways.attributes.L2gateways;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
public static List<L2gateway> getL2gatewayList(DataBroker broker) {
InstanceIdentifier<L2gateways> inst = InstanceIdentifier.create(Neutron.class).child(L2gateways.class);
try {
- return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION, inst).map(
- L2gateways::getL2gateway).orElse(emptyList());
+ return new ArrayList<>((SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, inst).map(L2gateways::getL2gateway)
+ .orElse(emptyMap())).values());
} catch (ExecutionException | InterruptedException e) {
LOG.error("getNeutronL2gateway: Exception while reading L2gateway DS", e);
}
InstanceIdentifier<L2gatewayConnections> inst = InstanceIdentifier.create(Neutron.class)
.child(L2gatewayConnections.class);
try {
- return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION, inst).map(
- L2gatewayConnections::getL2gatewayConnection).orElse(emptyList());
+ return new ArrayList<>((SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, inst).map(L2gatewayConnections::getL2gatewayConnection)
+ .orElse(emptyMap())).values());
} catch (ExecutionException | InterruptedException e) {
LOG.error("getNeutronL2gateway: Exception while reading L2gateway DS", e);
}
LOG.error("Failed to find the l2gateway for the connection {}", input.getUuid());
return;
} else if (l2Gateway.getDevices() != null) {
- l2gwDevicesToBeDeleted.addAll(l2Gateway.getDevices());
+ l2gwDevicesToBeDeleted.addAll(l2Gateway.getDevices().values());
}
}
for (Devices l2Device : l2gwDevicesToBeDeleted) {
String elanName = elanInstance.getElanInstanceName();
Integer defaultVlan = input.getSegmentId();
Uuid l2GwConnId = input.key().getUuid();
- List<Devices> l2Devices = l2Gateway.getDevices();
+ Map<DevicesKey, Devices> l2Devices = l2Gateway.getDevices();
LOG.trace("Associating ELAN {} with L2Gw Conn Id {} having below L2Gw devices {}", elanName, l2GwConnId,
l2Devices);
return;
}
- for (Devices l2Device : l2Devices) {
+ for (Devices l2Device : l2Devices.values()) {
String l2DeviceName = l2Device.getDeviceName();
// L2gateway can have more than one L2 Gw devices. Configure Logical Switch, VLAN mappings,...
// only on the switch which has come up just now and exclude all other devices from
if (nodeOptional.isPresent()) {
Node node = nodeOptional.get();
if (node.augmentation(HwvtepGlobalAugmentation.class) != null) {
- List<LocalUcastMacs> localUcastMacs =
+ Map<LocalUcastMacsKey, LocalUcastMacs> localUcastMacs =
node.augmentation(HwvtepGlobalAugmentation.class).getLocalUcastMacs();
if (localUcastMacs == null) {
return;
new LocalUcastMacListener(broker, haOpClusteredListener,
elanL2GatewayUtils, jobCoordinator, elanInstanceCache, hwvtepNodeHACache,
l2GatewayServiceRecoveryHandler, serviceRecoveryRegistry);
- localUcastMacs.stream()
+ localUcastMacs.values().stream()
.filter((mac) -> macBelongsToLogicalSwitch(mac, elanName))
.forEach((mac) -> {
InstanceIdentifier<LocalUcastMacs> macIid = getMacIid(nodeIid, mac);
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static Map<String, List<InstanceIdentifier<VlanBindings>>> getVlansByLogicalSwitchOnDevice(
final Node configPsNode) {
- List<TerminationPoint> ports = configPsNode.getTerminationPoint();
+ Map<TerminationPointKey, TerminationPoint> ports = configPsNode.getTerminationPoint();
if (ports == null) {
return Collections.emptyMap();
}
Map<String, List<InstanceIdentifier<VlanBindings>>> vlans = new HashMap<>();
- ports.stream()
+ ports.values().stream()
.filter(CONTAINS_VLANBINDINGS)
.forEach((port) -> port.augmentation(HwvtepPhysicalPortAugmentation.class)
- .getVlanBindings()
+ .getVlanBindings().values()
.forEach((binding) -> putVlanBindingVsLogicalSwitch(configPsNode, vlans, port, binding)));
return vlans;
}
return Collections.emptyList();
}
return augmentation
- .getLogicalSwitches()
+ .getLogicalSwitches().values()
.stream()
.map((ls) -> ls.getHwvtepNodeName().getValue())
.collect(Collectors.toList());
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
-import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeLeafTagName;
Long vni, String dstMacAddress, String displayName) {
List<MatchInfo> mkMatches =
ElanUtils.buildMatchesForElanTagShFlagAndDstMac(elanTag, /* shFlag */ false, dstMacAddress);
- List<Instruction> mkInstructions = new ArrayList<>();
+ Map<InstructionKey, Instruction> mkInstructionsMap = new HashMap<>();
try {
List<Action> actions =
elanItmUtils.getExternalTunnelItmEgressAction(dpId, new NodeId(extDeviceNodeId), vni);
- mkInstructions.add(MDSALUtil.buildApplyActionsInstruction(actions));
+ mkInstructionsMap.put(new InstructionKey(0), MDSALUtil.buildApplyActionsInstruction(actions));
} catch (Exception e) {
LOG.error("Could not get Egress Actions for DpId {} externalNode {}", dpId, extDeviceNodeId, e);
}
displayName, 0, /* idleTimeout */
0, /* hardTimeout */
Uint64.valueOf(ElanConstants.COOKIE_ELAN_KNOWN_DMAC.toJava().add(BigInteger.valueOf(elanTag))),
- mkMatches, mkInstructions);
+ mkMatches, mkInstructionsMap);
}
/**
List<MatchInfo> mkMatches =
ElanUtils.buildMatchesForElanTagShFlagAndDstMac(elanTag, SH_FLAG_SET, dstMacAddress);
List<Instruction> mkInstructions = MDSALUtil.buildInstructionsDrop();
+ Map<InstructionKey, Instruction> mkInstructionsMap = new HashMap<InstructionKey, Instruction>();
+ int instructionKey = 0;
+ for (Instruction instructionObj : mkInstructions) {
+ mkInstructionsMap.put(new InstructionKey(++instructionKey), instructionObj);
+ }
String flowId =
ElanUtils.getKnownDynamicmacFlowRef(NwConstants.ELAN_DMAC_TABLE, dpnId, extDeviceNodeId, dstMacAddress,
elanTag, true);
"Drop", 0, /* idleTimeout */
0, /* hardTimeout */
Uint64.valueOf(ElanConstants.COOKIE_ELAN_KNOWN_DMAC.toJava().add(BigInteger.valueOf(elanTag))),
- mkMatches, mkInstructions);
+ mkMatches, mkInstructionsMap);
}
private ListenableFuture<Void> buildEtreeDmacFlowForExternalRemoteMacWithBatch(
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
MacEntry macEntry = new MacEntryBuilder().setMacAddress(mac.getMacAddress()).setIpPrefix(mac.getIpPrefix())
.setInterface(interfaceName)
.setIsStaticAddress(true).withKey(new MacEntryKey(mac.getMacAddress())).build();
- tx.put(existingMacEntryId, macEntry, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(existingMacEntryId, macEntry);
}
}
macEntry.getMacAddress());
Optional<MacEntry> existingMacEntry = tx.read(macEntryId).get();
if (!existingMacEntry.isPresent() && elanUtils.getElanMacTable(elanName) != null) {
- tx.put(macEntryId, macEntry, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(macEntryId, macEntry);
}
}
*/
package org.opendaylight.netvirt.elan.utils;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
Future<RpcResult<GetEgressActionsForTunnelOutput>> egressActionsOutputItm =
itmRpcService.getEgressActionsForTunnel(getEgressActInputItm);
if (egressActionsOutputItm.get().isSuccessful()) {
- return egressActionsOutputItm.get().getResult().getAction();
+ return new ArrayList<Action>(egressActionsOutputItm.get().getResult().getAction().values());
}
} else {
GetEgressActionsForInterfaceInput getEgressActInput = new GetEgressActionsForInterfaceInputBuilder()
Future<RpcResult<GetEgressActionsForInterfaceOutput>> egressActionsOutputFuture =
interfaceManagerRpcService.getEgressActionsForInterface(getEgressActInput);
if (egressActionsOutputFuture.get().isSuccessful()) {
- return egressActionsOutputFuture.get().getResult().getAction();
+ return new ArrayList<Action>(egressActionsOutputFuture.get().getResult().getAction().values());
}
}
} catch (Exception e) {
package org.opendaylight.netvirt.elan.utils;
import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.elan.instance.ElanSegments;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.elan.instance.ElanSegmentsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.elan._interface.StaticMacEntries;
if (!existingElanDpnInterfaces.isPresent()) {
return dpIds;
}
- List<DpnInterfaces> dpnInterfaces = existingElanDpnInterfaces.get().nonnullDpnInterfaces();
- for (DpnInterfaces dpnInterface : dpnInterfaces) {
+ Map<DpnInterfacesKey, DpnInterfaces> dpnInterfaces = existingElanDpnInterfaces.get().nonnullDpnInterfaces();
+ for (DpnInterfaces dpnInterface : dpnInterfaces.values()) {
dpIds.add(dpnInterface.getDpId());
}
return dpIds;
* external)
* @return the Instruction
*/
- public List<Instruction> getInstructionsInPortForOutGroup(String ifName) {
- List<Instruction> mkInstructions = new ArrayList<>();
+ public Map<InstructionKey, Instruction> getInstructionsInPortForOutGroup(String ifName) {
+ int instructionsKey = 0;
+ Map<InstructionKey, Instruction> mkInstructions = new HashMap<>();
List<Action> actions = getEgressActionsForInterface(ifName, /* tunnelKey */ null);
- mkInstructions.add(MDSALUtil.buildApplyActionsInstruction(actions));
+ mkInstructions.put(new InstructionKey(++instructionsKey), MDSALUtil.buildApplyActionsInstruction(actions));
return mkInstructions;
}
LOG.debug("RPC Call to Get egress actions for interface {} returned with Errors {}", ifName,
rpcResult.getErrors());
} else {
- listAction = rpcResult.getResult().nonnullAction();
+ listAction = new ArrayList<Action>(rpcResult.getResult().nonnullAction().values());
}
} catch (Exception e) {
LOG.warn("Exception when egress actions for interface {}", ifName, e);
public List<DpnInterfaces> getElanDPNByName(String elanInstanceName) {
InstanceIdentifier<ElanDpnInterfacesList> elanIdentifier = getElanDpnOperationDataPath(elanInstanceName);
try {
- return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.OPERATIONAL,
- elanIdentifier).map(ElanDpnInterfacesList::getDpnInterfaces).orElse(emptyList());
+ return new ArrayList<DpnInterfaces>((SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.OPERATIONAL, elanIdentifier).map(ElanDpnInterfacesList::getDpnInterfaces)
+ .orElse(emptyMap())).values());
} catch (ExecutionException | InterruptedException e) {
LOG.error("getElanDPNByName: Exception while reading elanDpnInterfaceList DS for the elan "
+ "instance {}", elanInstanceName, e);
MetaDataUtil.METADATA_MASK_SERVICE));
mkMatches.add(new MatchEthernetDestination(new MacAddress(macAddress)));
- List<Instruction> mkInstructions = new ArrayList<>();
+ Map<InstructionKey, Instruction> mkInstructions = new HashMap<>();
List<Action> actions = getEgressActionsForInterface(ifName, /* tunnelKey */ null);
- mkInstructions.add(MDSALUtil.buildApplyActionsInstruction(actions));
+ mkInstructions.put(new InstructionKey(0), MDSALUtil.buildApplyActionsInstruction(actions));
Flow flow = MDSALUtil.buildFlowNew(NwConstants.ELAN_DMAC_TABLE,
getKnownDynamicmacFlowRef(elanTag, macAddress), 20,
elanInfo.getElanInstanceName(), 0, 0,
MetaDataUtil.METADATA_MASK_SERVICE));
mkMatches.add(new MatchEthernetDestination(new MacAddress(macAddress)));
- List<Instruction> mkInstructions = new ArrayList<>();
+ Map<InstructionKey, Instruction> mkInstructions = new HashMap<>();
// List of Action for the provided Source and Destination DPIDs
try {
}
actions = getEgressActionsForInterface(interfaceName, null);
}
- mkInstructions.add(MDSALUtil.buildApplyActionsInstruction(actions));
+ mkInstructions.put(new InstructionKey(0), MDSALUtil.buildApplyActionsInstruction(actions));
} catch (Exception e) {
LOG.error("Could not get egress actions to add to flow for srcDpId {}, destDpId {}, lportTag/VNI {}",
srcDpId, destDpId, lportTagOrVni, e);
.withKey(new ElanKey(elanInstanceName)).build();
// Add the ElanState in the elan-state operational data-store
- operTx.put(getElanInstanceOperationalDataPath(elanInstanceName), elanInfo, CREATE_MISSING_PARENTS);
+ operTx.mergeParentStructurePut(getElanInstanceOperationalDataPath(elanInstanceName), elanInfo);
// Add the ElanMacTable in the elan-mac-table operational data-store
MacTable elanMacTable = new MacTableBuilder().withKey(new MacTableKey(elanInstanceName)).build();
- operTx.put(getElanMacTableOperationalDataPath(elanInstanceName), elanMacTable, CREATE_MISSING_PARENTS);
+ operTx.mergeParentStructurePut(getElanMacTableOperationalDataPath(elanInstanceName), elanMacTable);
ElanTagNameBuilder elanTagNameBuilder = new ElanTagNameBuilder().setElanTag(elanTag)
.withKey(new ElanTagNameKey(elanTag)).setName(elanInstanceName);
ElanInstance elanInstanceWithTag = elanInstanceBuilder.build();
LOG.trace("Updated elan Operational DS for elan: {} with elanTag: {} and interfaces: {}", elanInstanceName,
elanTag, elanInterfaces);
- confTx.merge(ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName), elanInstanceWithTag,
- CREATE_MISSING_PARENTS);
+ confTx.mergeParentStructureMerge(ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName),
+ elanInstanceWithTag);
return elanInstanceWithTag;
}
*/
public List<ExternalTunnel> getAllExternalTunnels(LogicalDatastoreType datastoreType) {
InstanceIdentifier<ExternalTunnelList> iid = InstanceIdentifier.builder(ExternalTunnelList.class).build();
- return read(broker, datastoreType, iid).map(ExternalTunnelList::getExternalTunnel).orElse(
- emptyList());
+ return new ArrayList<ExternalTunnel>(read(broker, datastoreType, iid).map(ExternalTunnelList
+ ::getExternalTunnel).orElse(Collections.emptyMap()).values());
}
public static List<MatchInfo> buildMatchesForElanTagShFlagAndDstMac(long elanTag, boolean shFlag, String macAddr) {
private static boolean isVxlanSegment(@Nullable ElanInstance elanInstance) {
if (elanInstance != null) {
- List<ElanSegments> elanSegments = elanInstance.getElanSegments();
+ Map<ElanSegmentsKey, ElanSegments> elanSegments = elanInstance.getElanSegments();
if (elanSegments != null) {
- for (ElanSegments segment : elanSegments) {
+ for (ElanSegments segment : elanSegments.values()) {
if (segment != null && segment.getSegmentType().isAssignableFrom(SegmentTypeVxlan.class)
&& segment.getSegmentationId() != null
&& segment.getSegmentationId().longValue() != 0) {
&& elanInstance.getSegmentationId() != null && elanInstance.getSegmentationId().longValue() != 0) {
segmentationId = elanInstance.getSegmentationId();
} else {
- for (ElanSegments segment: elanInstance.getElanSegments()) {
+ for (ElanSegments segment: elanInstance.getElanSegments().values()) {
if (segment != null && segment.getSegmentType().isAssignableFrom(SegmentTypeVxlan.class)
&& segment.getSegmentationId() != null
&& segment.getSegmentationId().longValue() != 0) {
if (macTable == null) {
return emptyList();
}
- return macTable.getMacEntry();
+ return new ArrayList<MacEntry>(macTable.getMacEntry().values());
}
public boolean isTunnelInLogicalGroup(String interfaceName) {
Optional<Subnetmaps> subnetMapsData =
read(dataBroker, LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
if (subnetMapsData.isPresent()) {
- List<Subnetmap> subnetMapList = subnetMapsData.get().getSubnetmap();
+ List<Subnetmap> subnetMapList = new ArrayList<>(subnetMapsData.get().getSubnetmap().values());
if (subnetMapList != null && !subnetMapList.isEmpty()) {
for (Subnetmap subnet : subnetMapList) {
if (subnet.getNetworkId().getValue().equals(elanInstanceName)) {
LOG.debug("Buckets are not sent for group {}. Skipping merge operation", groupIdInfo);
return;
}
- List<Bucket> newBuckets = newGroup.getBuckets().getBucket();
- List<Bucket> existingBuckets = existingGroup.getBucket();
+ List<Bucket> newBuckets = new ArrayList<Bucket>(newGroup.getBuckets().getBucket().values());
+ List<Bucket> existingBuckets = new ArrayList<Bucket>(existingGroup.getBucket().values());
Set<Bucket> toMergeBucketsWithoutId = new LinkedHashSet<>();
existingBuckets.stream()
package org.opendaylight.netvirt.elan.utils;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
-
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import com.google.common.collect.MapDifference;
import com.google.common.collect.MapDifference.ValueDifference;
import com.google.common.collect.Maps;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.ovsdb.utils.mdsal.utils.ControllerMdsalUtils;
import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.BridgeRefInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Vteps;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.config.rev150710.ElanConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
}
private List<String> getTepTransportZoneNames(TunnelEndPoints tep) {
- List<TzMembership> tzMembershipList = tep.getTzMembership();
+ List<TzMembership> tzMembershipList = new ArrayList<TzMembership>(tep.getTzMembership().values());
if (tzMembershipList == null) {
LOG.debug("No TZ membership exist for TEP ip {}", tep.getIpAddress().stringValue());
return Collections.emptyList();
* @return Whether a vtep was added or not.
*/
private boolean addVtep(TransportZone zone, String subnetIp, Uint64 dpnId, @Nullable String localIp) {
- for (Vteps existingVtep : zone.nonnullVteps()) {
+ for (Vteps existingVtep : new ArrayList<Vteps>(zone.nonnullVteps().values())) {
if (Objects.equals(existingVtep.getDpnId(), dpnId)) {
return false;
}
}
if (localIp != null) {
- IpAddress nodeIp = IpAddressBuilder.getDefaultInstance(localIp);
+ //This seems to be a unused code, creating unused objects
+ //Check if any assignment needed here.
+ /*IpAddress nodeIp = IpAddressBuilder.getDefaultInstance(localIp);
VtepsBuilder vtepsBuilder = new VtepsBuilder().setDpnId(dpnId).setIpAddress(nodeIp)
.setOptionOfTunnel(elanConfig.isUseOfTunnels());
- zone.getVteps().add(vtepsBuilder.build());
+ zone.getVteps().add(vtepsBuilder.build());*/
return true;
}
originalData = getData(new LogicalSwitches[]{logicalSwitches[0], logicalSwitches[1]});
updatedData = getData(new LogicalSwitches[]{logicalSwitches[0], logicalSwitches[1], logicalSwitches[2]});
cmd.mergeOpUpdate(existingData, updatedData, originalData, haNodePath, tx);
- Mockito.verify(tx).put(LogicalDatastoreType.OPERATIONAL, ids[2], logicalSwitches[2],
- WriteTransaction.CREATE_MISSING_PARENTS);
+ Mockito.verify(tx).put(LogicalDatastoreType.OPERATIONAL, ids[2], logicalSwitches[2]);
}
@Test
updatedData = getData(new LogicalSwitches[]{logicalSwitches[0],
logicalSwitches[1], logicalSwitches[2], logicalSwitches[3]});
cmd.mergeOpUpdate(existingData, updatedData, originalData, haNodePath, tx);
- Mockito.verify(tx).put(LogicalDatastoreType.OPERATIONAL, ids[2], logicalSwitches[2],
- WriteTransaction.CREATE_MISSING_PARENTS);
- Mockito.verify(tx).put(LogicalDatastoreType.OPERATIONAL, ids[3], logicalSwitches[3],
- WriteTransaction.CREATE_MISSING_PARENTS);
+ Mockito.verify(tx).put(LogicalDatastoreType.OPERATIONAL, ids[2], logicalSwitches[2]);
+ Mockito.verify(tx).put(LogicalDatastoreType.OPERATIONAL, ids[3], logicalSwitches[3]);
}
@Test
originalData = getData(new LogicalSwitches[]{logicalSwitches[0], logicalSwitches[1]});
updatedData = getData(new LogicalSwitches[]{logicalSwitches[2], logicalSwitches[3]});
cmd.mergeOpUpdate(existingData, updatedData, originalData, haNodePath, tx);
- Mockito.verify(tx).put(LogicalDatastoreType.OPERATIONAL, ids[2], logicalSwitches[2],
- WriteTransaction.CREATE_MISSING_PARENTS);
- Mockito.verify(tx).put(LogicalDatastoreType.OPERATIONAL, ids[3], logicalSwitches[3],
- WriteTransaction.CREATE_MISSING_PARENTS);
+ Mockito.verify(tx).put(LogicalDatastoreType.OPERATIONAL, ids[2], logicalSwitches[2]);
+ Mockito.verify(tx).put(LogicalDatastoreType.OPERATIONAL, ids[3], logicalSwitches[3]);
Mockito.verify(tx).delete(LogicalDatastoreType.OPERATIONAL, ids[0]);
Mockito.verify(tx).delete(LogicalDatastoreType.OPERATIONAL, ids[1]);
}
package org.opendaylight.netvirt.elan.l2gw.nodehandlertest;
import com.google.common.collect.ImmutableList;
-
import java.util.ArrayList;
import java.util.List;
*/
package org.opendaylight.netvirt.elan.l2gw.nodehandlertest;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import java.util.ArrayList;
import java.util.Arrays;
nodeBuilder.setTerminationPoint(PhysicalSwitchHelper
.addPhysicalSwitchTerminationPoints(path, portNameList));
- tx.put(path, nodeBuilder.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(path, nodeBuilder.build());
}
private static NodeBuilder prepareOperationalNode(InstanceIdentifier<Node> iid) {
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Switches;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelIps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindings;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
}
public static void verifySwitches(Node globalOpNode, Node psOpNode) {
- for (Switches switches : globalOpNode.augmentation(HwvtepGlobalAugmentation.class).getSwitches()) {
+ for (Switches switches : globalOpNode.augmentation(HwvtepGlobalAugmentation.class).getSwitches().values()) {
String switchValue = switches.getSwitchRef().getValue().firstKeyOf(Node.class).getNodeId().getValue();
assertEquals("Switch Name should be equal", switchValue, psOpNode.getNodeId().getValue());
}
HwvtepGlobalAugmentation haAug = dst.augmentation(HwvtepGlobalAugmentation.class);
List<LogicalSwitches> d1Values =
- d1Aug.getLogicalSwitches() != null ? d1Aug.getLogicalSwitches() : new ArrayList<>();
+ d1Aug.getLogicalSwitches() != null ? new ArrayList<LogicalSwitches>(d1Aug.getLogicalSwitches().values())
+ : new ArrayList<>();
List<LogicalSwitches> result1 = cmd.transform(nodePath, d1Values);
- List<LogicalSwitches> result2 = cmd.transform(nodePath, haAug.getLogicalSwitches());
+ List<LogicalSwitches> result2 = cmd.transform(nodePath,
+ new ArrayList<LogicalSwitches>(haAug.getLogicalSwitches().values()));
Set<LogicalSwitches> set1 = Sets.newHashSet(result1);
Set<LogicalSwitches> set2 = Sets.newHashSet(result2);
HwvtepGlobalAugmentation haAug = ha.augmentation(HwvtepGlobalAugmentation.class);
List<LogicalSwitches> d1Values =
- d1Aug.getLogicalSwitches() != null ? d1Aug.getLogicalSwitches() : new ArrayList<>();
+ d1Aug.getLogicalSwitches() != null ? new ArrayList<LogicalSwitches>(d1Aug.getLogicalSwitches().values())
+ : new ArrayList<>();
List<LogicalSwitches> result1 = cmd.transform(nodePath, d1Values);
List<LogicalSwitches> d2Values =
- d2Aug.getLogicalSwitches() != null ? d2Aug.getLogicalSwitches() : new ArrayList<>();
+ d2Aug.getLogicalSwitches() != null ? new ArrayList<LogicalSwitches>(d2Aug.getLogicalSwitches().values())
+ : new ArrayList<>();
List<LogicalSwitches> result2 = cmd.transform(nodePath, d2Values);
//Merge data of both d1 and d2 logical switch info should be same as ha
Set<LogicalSwitches> set1 = new HashSet<>();
set1.addAll(result1);
set1.addAll(result2);
- List<LogicalSwitches> result = cmd.transform(nodePath, haAug.getLogicalSwitches());
+ List<LogicalSwitches> result = cmd.transform(nodePath,
+ new ArrayList<LogicalSwitches>(haAug.getLogicalSwitches().values()));
Set<LogicalSwitches> set2 = Sets.newHashSet(result);
assertEquals("should have equal logical switches", 0, Sets.symmetricDifference(set1, set2).size());
HwvtepGlobalAugmentation d1Aug = src.augmentation(HwvtepGlobalAugmentation.class);
HwvtepGlobalAugmentation haAug = dst.augmentation(HwvtepGlobalAugmentation.class);
List<RemoteUcastMacs> d1Values =
- d1Aug.getRemoteUcastMacs() != null ? d1Aug.getRemoteUcastMacs() : new ArrayList<>();
+ d1Aug.getRemoteUcastMacs() != null ? new ArrayList<RemoteUcastMacs>(d1Aug.getRemoteUcastMacs().values())
+ : new ArrayList<>();
List<RemoteUcastMacs> result1 = cmd.transform(nodePath, d1Values);
- List<RemoteUcastMacs> result2 = cmd.transform(nodePath, haAug.getRemoteUcastMacs());
+ List<RemoteUcastMacs> result2 = cmd.transform(nodePath,
+ new ArrayList<RemoteUcastMacs>(haAug.getRemoteUcastMacs().values()));
RemoteUcastMacs mac1 = result1.get(0);
RemoteUcastMacs mac2 = result2.get(0);
HwvtepGlobalAugmentation haAug = ha.augmentation(HwvtepGlobalAugmentation.class);
List<RemoteUcastMacs> d1Values =
- d1Aug.getRemoteUcastMacs() != null ? d1Aug.getRemoteUcastMacs() : new ArrayList<>();
+ d1Aug.getRemoteUcastMacs() != null ? new ArrayList<RemoteUcastMacs>(d1Aug.getRemoteUcastMacs().values())
+ : new ArrayList<>();
List<RemoteUcastMacs> result1 = cmd.transform(nodePath, d1Values);
List<RemoteUcastMacs> d2Values =
- d2Aug.getRemoteUcastMacs() != null ? d2Aug.getRemoteUcastMacs() : new ArrayList<>();
+ d2Aug.getRemoteUcastMacs() != null ? new ArrayList<RemoteUcastMacs>(d2Aug.getRemoteUcastMacs().values())
+ : new ArrayList<>();
List<RemoteUcastMacs> result2 = cmd.transform(nodePath, d2Values);
List<RemoteUcastMacs> ruMacList = new ArrayList<>();
ruMacList.addAll(result1);
ruMacList.addAll(result2);
- List<RemoteUcastMacs> result = cmd.transform(nodePath, haAug.getRemoteUcastMacs());
+ List<RemoteUcastMacs> result = cmd.transform(nodePath,
+ new ArrayList<RemoteUcastMacs>(haAug.getRemoteUcastMacs().values()));
Set<RemoteUcastMacs> set1 = Sets.newHashSet(ruMacList);
Set<RemoteUcastMacs> set2 = Sets.newHashSet(result);
HwvtepGlobalAugmentation d1Aug = src.augmentation(HwvtepGlobalAugmentation.class);
HwvtepGlobalAugmentation haAug = dst.augmentation(HwvtepGlobalAugmentation.class);
List<RemoteMcastMacs> d1Values =
- d1Aug.getRemoteMcastMacs() != null ? d1Aug.getRemoteMcastMacs() : new ArrayList<>();
+ d1Aug.getRemoteMcastMacs() != null ? new ArrayList<RemoteMcastMacs>(d1Aug.getRemoteMcastMacs().values())
+ : new ArrayList<>();
List<RemoteMcastMacs> result1 = cmd.transform(nodePath, d1Values);
- List<RemoteMcastMacs> result2 = cmd.transform(nodePath, haAug.getRemoteMcastMacs());
+ List<RemoteMcastMacs> result2 = cmd.transform(nodePath,
+ new ArrayList<RemoteMcastMacs>(haAug.getRemoteMcastMacs().values()));
Set<RemoteMcastMacs> set1 = Sets.newHashSet(result1);
Set<RemoteMcastMacs> set2 = Sets.newHashSet(result2);
HwvtepGlobalAugmentation haAug = ha.augmentation(HwvtepGlobalAugmentation.class);
List<RemoteMcastMacs> d1Values =
- d1Aug.getRemoteMcastMacs() != null ? d1Aug.getRemoteMcastMacs() : new ArrayList<>();
+ d1Aug.getRemoteMcastMacs() != null ? new ArrayList<RemoteMcastMacs>(d1Aug.getRemoteMcastMacs().values())
+ : new ArrayList<>();
List<RemoteMcastMacs> result1 = cmd.transform(nodePath, d1Values);
List<RemoteMcastMacs> d2Values =
- d2Aug.getRemoteMcastMacs() != null ? d2Aug.getRemoteMcastMacs() : new ArrayList<>();
+ d2Aug.getRemoteMcastMacs() != null ? new ArrayList<RemoteMcastMacs>(d2Aug.getRemoteMcastMacs().values())
+ : new ArrayList<>();
List<RemoteMcastMacs> result2 = cmd.transform(nodePath, d2Values);
List<RemoteMcastMacs> rmMacList = new ArrayList<>();
rmMacList.addAll(result1);
rmMacList.addAll(result2);
- List<RemoteMcastMacs> result = cmd.transform(nodePath, haAug.getRemoteMcastMacs());
+ List<RemoteMcastMacs> result = cmd.transform(nodePath,
+ new ArrayList<RemoteMcastMacs>(haAug.getRemoteMcastMacs().values()));
Set<RemoteMcastMacs> set1 = Sets.newHashSet(rmMacList);
Set<RemoteMcastMacs> set2 = Sets.newHashSet(result);
HwvtepGlobalAugmentation d1Aug = src.augmentation(HwvtepGlobalAugmentation.class);
HwvtepGlobalAugmentation haAug = dst.augmentation(HwvtepGlobalAugmentation.class);
List<LocalUcastMacs> d1Values =
- d1Aug.getLocalUcastMacs() != null ? d1Aug.getLocalUcastMacs() : new ArrayList<>();
+ d1Aug.getLocalUcastMacs() != null ? new ArrayList<LocalUcastMacs>(d1Aug.getLocalUcastMacs().values())
+ : new ArrayList<>();
List<LocalUcastMacs> result1 = cmd.transform(nodePath, d1Values);
- List<LocalUcastMacs> result2 = cmd.transform(nodePath, haAug.getLocalUcastMacs());
+ List<LocalUcastMacs> result2 = cmd.transform(nodePath,
+ new ArrayList<LocalUcastMacs>(haAug.getLocalUcastMacs().values()));
Set<LocalUcastMacs> set1 = Sets.newHashSet(result1);
Set<LocalUcastMacs> set2 = Sets.newHashSet(result2);
HwvtepGlobalAugmentation haAug = ha.augmentation(HwvtepGlobalAugmentation.class);
List<LocalUcastMacs> d1Values =
- d1Aug.getLocalUcastMacs() != null ? d1Aug.getLocalUcastMacs() : new ArrayList<>();
+ d1Aug.getLocalUcastMacs() != null ? new ArrayList<LocalUcastMacs>(d1Aug.getLocalUcastMacs().values())
+ : new ArrayList<>();
List<LocalUcastMacs> result1 = cmd.transform(nodePath, d1Values);
List<LocalUcastMacs> d2Values =
- d2Aug.getLocalUcastMacs() != null ? d2Aug.getLocalUcastMacs() : new ArrayList<>();
+ d2Aug.getLocalUcastMacs() != null ? new ArrayList<LocalUcastMacs>(d2Aug.getLocalUcastMacs().values())
+ : new ArrayList<>();
List<LocalUcastMacs> result2 = cmd.transform(nodePath, d2Values);
- List<LocalUcastMacs> result = cmd.transform(nodePath, haAug.getLocalUcastMacs());
+ List<LocalUcastMacs> result = cmd.transform(nodePath,
+ new ArrayList<LocalUcastMacs>(haAug.getLocalUcastMacs().values()));
List<LocalUcastMacs> luMacList = new ArrayList<>();
luMacList.addAll(result1);
HwvtepGlobalAugmentation d1Aug = src.augmentation(HwvtepGlobalAugmentation.class);
HwvtepGlobalAugmentation haAug = dst.augmentation(HwvtepGlobalAugmentation.class);
List<LocalMcastMacs> d1Values =
- d1Aug.getLocalUcastMacs() != null ? d1Aug.getLocalMcastMacs() : new ArrayList<>();
+ d1Aug.getLocalUcastMacs() != null ? new ArrayList<LocalMcastMacs>(d1Aug.getLocalMcastMacs().values())
+ : new ArrayList<>();
List<LocalMcastMacs> result1 = cmd.transform(nodePath, d1Values);
- List<LocalMcastMacs> result2 = cmd.transform(nodePath, haAug.getLocalMcastMacs());
+ List<LocalMcastMacs> result2 = cmd.transform(nodePath,
+ new ArrayList<LocalMcastMacs>(haAug.getLocalMcastMacs().values()));
Set<LocalMcastMacs> set1 = Sets.newHashSet(result1);
Set<LocalMcastMacs> set2 = Sets.newHashSet(result2);
HwvtepGlobalAugmentation d2Aug = d2.augmentation(HwvtepGlobalAugmentation.class);
HwvtepGlobalAugmentation haAug = ha.augmentation(HwvtepGlobalAugmentation.class);
List<LocalMcastMacs> d1Values =
- d1Aug.getLocalUcastMacs() != null ? d1Aug.getLocalMcastMacs() : new ArrayList<>();
+ d1Aug.getLocalUcastMacs() != null ? new ArrayList<LocalMcastMacs>(d1Aug.getLocalMcastMacs().values())
+ : new ArrayList<>();
List<LocalMcastMacs> result1 = cmd.transform(nodePath, d1Values);
List<LocalMcastMacs> d2Values =
- d2Aug.getLocalUcastMacs() != null ? d2Aug.getLocalMcastMacs() : new ArrayList<>();
+ d2Aug.getLocalUcastMacs() != null ? new ArrayList<LocalMcastMacs>(d2Aug.getLocalMcastMacs().values())
+ : new ArrayList<>();
List<LocalMcastMacs> result2 = cmd.transform(nodePath, d2Values);
- List<LocalMcastMacs> result = cmd.transform(nodePath, haAug.getLocalMcastMacs());
+ List<LocalMcastMacs> result = cmd.transform(nodePath,
+ new ArrayList<LocalMcastMacs>(haAug.getLocalMcastMacs().values()));
List<LocalMcastMacs> lmMacList = new ArrayList<>();
lmMacList.addAll(result1);
d2PsAug.getTunnelIps().size(), haPsAug.getTunnelIps().size());
if (d1PsAug.getTunnelIps().size() == haPsAug.getTunnelIps().size()
&& d2PsAug.getTunnelIps().size() == haPsAug.getTunnelIps().size()) {
- assertTrue(d1PsAug.getTunnelIps().containsAll(haPsAug.getTunnelIps()));
- assertTrue(d2PsAug.getTunnelIps().containsAll(haPsAug.getTunnelIps()));
+ assertTrue(d1PsAug.getTunnelIps().values().containsAll(
+ new ArrayList<TunnelIps>(haPsAug.getTunnelIps().values())));
+ assertTrue(d2PsAug.getTunnelIps().values().containsAll(
+ new ArrayList<TunnelIps>(haPsAug.getTunnelIps().values())));
}
//Compare Termination point
assertEquals("Should have equal number TunnelIps", d1PsAug.getTunnelIps().size(),
haPsAug.getTunnelIps().size());
if (d1PsAug.getTunnelIps().size() == haPsAug.getTunnelIps().size()) {
- assertTrue(d1PsAug.getTunnelIps().containsAll(haPsAug.getTunnelIps()));
+ assertTrue(d1PsAug.getTunnelIps().values().containsAll(
+ new ArrayList<TunnelIps>(haPsAug.getTunnelIps().values())));
}
//Compare Termination point
hwvtepPhysicalPortAugmentationD.getHwvtepNodeName(),
hwvtepPhysicalPortAugmentationHa.getHwvtepNodeName());
- List<VlanBindings> vlanBindingsesD = hwvtepPhysicalPortAugmentationD.getVlanBindings();
- List<VlanBindings> vlanBindingsesHa = hwvtepPhysicalPortAugmentationHa.getVlanBindings();
+ List<VlanBindings> vlanBindingsesD
+ = new ArrayList<VlanBindings>(hwvtepPhysicalPortAugmentationD.getVlanBindings().values());
+ List<VlanBindings> vlanBindingsesHa
+ = new ArrayList<VlanBindings>(hwvtepPhysicalPortAugmentationHa.getVlanBindings().values());
assertEquals("Size of VlanBindings should be same", vlanBindingsesD.size(), vlanBindingsesHa.size());
List<Integer> vlanKeysD = new ArrayList<>();
import static org.junit.Assert.assertEquals;
+import java.util.ArrayList;
import java.util.Optional;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Managers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.managers.ManagerOtherConfigs;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
static void verifyHAconfigNode(Node haConfig, Node d1Node) {
- String haid = haConfig.augmentation(HwvtepGlobalAugmentation.class).getManagers()
- .get(0).getManagerOtherConfigs().get(0).getOtherConfigValue();
+ String haid = new ArrayList<ManagerOtherConfigs>(new ArrayList<Managers>(haConfig
+ .augmentation(HwvtepGlobalAugmentation.class).getManagers().values())
+ .get(0).getManagerOtherConfigs().values()).get(0).getOtherConfigValue();
String d1id = d1Node.getNodeId().getValue();
assertEquals("Other config should contain D1 as child manager", haid, d1id);
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint64;
awaitForData(LogicalDatastoreType.CONFIGURATION, evpnTestHelper.buildMacVrfEntryIid(EVPNRECVMAC2));
}*/
- @Test public void checkEvpnUnInstalDmacFlow() throws Exception {
+ @Test
+ @Ignore
+ public void checkEvpnUnInstalDmacFlow() throws Exception {
createElanInstanceAndInterfaceAndAttachEvpn();
addElanInterface(ExpectedObjects.ELAN1, ELAN_INTERFACES.get(ELAN1 + ":" + DPN1MAC2).getLeft(), DPN1IP2);
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Instructions;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.InstructionsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCase;
FlowBuilder flowBuilder = new FlowBuilder(flow);
Instructions instructions = flowBuilder.getInstructions();
InstructionsBuilder builder = new InstructionsBuilder();
- InstructionBuilder instructionBuilder = new InstructionBuilder(instructions.getInstruction().get(0));
+ InstructionBuilder instructionBuilder = new InstructionBuilder(
+ new ArrayList<Instruction>(instructions.getInstruction().values()).get(0));
instructionBuilder.setInstruction(sortActions(instructionBuilder.getInstruction()));
builder.setInstruction(Lists.newArrayList(instructionBuilder.build()));
return flowBuilder.setInstructions(builder.build()).build();
org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction
sortActions(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction input) {
if (input instanceof ApplyActionsCase) {
- List<Action> action = new ArrayList<>(((ApplyActionsCase)input).getApplyActions().getAction());
+ List<Action> action = new ArrayList<Action>(((ApplyActionsCase)input)
+ .getApplyActions().getAction().values());
action.sort(Comparator.comparing(Ordered::getOrder));
ApplyActions actions = new ApplyActionsBuilder().setAction(action).build();
}
}
boolean remoteMcastFoundFlag = false;
- for (RemoteMcastMacs remoteMcastMacs : augmentation.getRemoteMcastMacs()) {
+ for (RemoteMcastMacs remoteMcastMacs : augmentation.getRemoteMcastMacs().values()) {
for (LocatorSet locatorSet : remoteMcastMacs.getLocatorSet()) {
TpId tpId = locatorSet.getLocatorRef().getValue().firstKeyOf(TerminationPoint.class).getTpId();
if (tpId.getValue().contains(tepIp)) {
}
}
boolean remoteUcastFoundFlag = false;
- for (RemoteUcastMacs remoteUcastMacs : augmentation.getRemoteUcastMacs()) {
+ for (RemoteUcastMacs remoteUcastMacs : augmentation.getRemoteUcastMacs().values()) {
String mac = remoteUcastMacs.getMacEntryKey().getValue();
if (mac.equals(dpnMac)) {
remoteUcastFoundFlag = true;
.setIntfName(extnIntfs.get(dpnId + ":" + otherDpn).getInterfaceInfo().getInterfaceName())
.setTunnelKey(elanInfo.getElanTag().longValue() + ElanConstants.ELAN_TAG_ADDEND).build();
List<Action> actionsList =
- odlInterfaceRpcService.getEgressActionsForInterface(getEgressActInput).get().getResult()
- .getAction();
+ new ArrayList<Action>(odlInterfaceRpcService.getEgressActionsForInterface(getEgressActInput)
+ .get().getResult().getAction().values());
listBucketInfo.add(MDSALUtil.buildBucket(actionsList, MDSALUtil.GROUP_WEIGHT, bucketId,
MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
.setIntfName(extnIntfs.get(dpnId + ":" + otherTor).getInterfaceInfo().getInterfaceName())
.setTunnelKey(elanInfo.getSegmentationId()).build();
List<Action> actionsList =
- odlInterfaceRpcService.getEgressActionsForInterface(getEgressActInput).get().getResult()
- .getAction();
+ new ArrayList<Action>(odlInterfaceRpcService.getEgressActionsForInterface(getEgressActInput)
+ .get().getResult().getAction().values());
listBucketInfo.add(MDSALUtil.buildBucket(actionsList, MDSALUtil.GROUP_WEIGHT, bucketId,
MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
AssertDataObjects.assertEqualBeans(expected, actual);
}
- Set<Bucket> actualBuckets = modifyBucketId(actual.getBuckets().getBucket());
- Set<Bucket> expectedBuckets = modifyBucketId(expected.getBuckets().getBucket());
+ Set<Bucket> actualBuckets = modifyBucketId(new ArrayList<Bucket>(actual.getBuckets().getBucket().values()));
+ Set<Bucket> expectedBuckets = modifyBucketId(new ArrayList<Bucket>(expected.getBuckets().getBucket().values()));
Set<Bucket> diff = Sets.difference(actualBuckets, expectedBuckets);
if (diff != null && !diff.isEmpty()) {
AssertDataObjects.assertEqualBeans(expected, actual);
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<dependencies>
<dependency>
<groupId>org.opendaylight.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.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>5.0.9</version>
+ <version>6.0.0</version>
<scope>import</scope>
<type>pom</type>
</dependency>
<type>xml</type>
<classifier>features</classifier>
</dependency>
- <dependency>
+ <!--dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<artifactId>odl-mdsal-model-rfc7223</artifactId>
<type>xml</type>
<classifier>features</classifier>
- </dependency>
+ </dependency-->
<dependency>
<groupId>org.opendaylight.neutron</groupId>
<artifactId>odl-neutron-northbound-api</artifactId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<dependencies>
- <dependency>
+ <!--dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>odl-mdsal-broker</artifactId>
<version>1.11.0</version>
<type>xml</type>
<classifier>features</classifier>
- </dependency>
+ </dependency-->
<dependency>
<groupId>org.opendaylight.genius</groupId>
<artifactId>odl-genius</artifactId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
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 java.util.stream.Collectors;
}
public static List<String> getNextHopListFromRoutePaths(final VrfEntry vrfEntry) {
- List<RoutePaths> routePaths = vrfEntry.getRoutePaths();
- if (routePaths == null || routePaths.isEmpty()) {
+ Map<RoutePathsKey, RoutePaths> keyRoutePathsMap = vrfEntry.getRoutePaths();
+ if (keyRoutePathsMap == null || keyRoutePathsMap.isEmpty()) {
return new ArrayList<>();
}
- return routePaths.stream()
+ return keyRoutePathsMap.values().stream()
.map(RoutePaths::getNexthopAddress)
.collect(Collectors.toList());
}
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
@NonNull
protected List<AdjacencyResult> resolveAdjacency(final Uint64 remoteDpnId, final Uint32 vpnId,
final VrfEntry vrfEntry, String rd) {
- List<RoutePaths> routePaths = new ArrayList<>(vrfEntry.nonnullRoutePaths());
+ List<RoutePaths> routePaths = new ArrayList<RoutePaths>(vrfEntry.nonnullRoutePaths().values());
FibHelper.sortIpAddress(routePaths);
List<AdjacencyResult> adjacencyList = new ArrayList<>();
List<String> prefixIpList;
}
if (addOrRemove == NwConstants.ADD_FLOW) {
- tx.put(LogicalDatastoreType.CONFIGURATION, flowInstanceId, flow, true);
+ tx.mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, flowInstanceId, flow);
} else {
tx.delete(LogicalDatastoreType.CONFIGURATION, flowInstanceId);
}
LOG.error(
"Failed to retrieve egress action for prefix {} route-paths {} interface {}. "
+ "Aborting remote FIB entry creation.",
- vrfEntry.getDestPrefix(), vrfEntry.getRoutePaths(), egressInterface);
+ vrfEntry.getDestPrefix(), new ArrayList<RoutePaths>(vrfEntry.getRoutePaths().values()),
+ egressInterface);
return;
}
actionInfos.addAll(egressActions);
import static java.util.stream.Collectors.toList;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.vpn.extra.routes.Routes;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint32;
LOG.error("Vpn Instance not availabe {}", vrfTableKey.getRouteDistinguisher());
return;
}
- final Collection<VpnToDpnList> vpnToDpnList = vpnInstance.getVpnToDpnList();
- if (vpnToDpnList != null) {
- for (VpnToDpnList vpnDpn : vpnToDpnList) {
+ final Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap = vpnInstance.getVpnToDpnList();
+ if (keyVpnToDpnListMap != null) {
+ for (VpnToDpnList vpnDpn : keyVpnToDpnListMap.values()) {
LOG.trace("Dpnstate is {} for dpn {} in vpn {}", vpnDpn.getDpnState(), vpnDpn.getDpnId(),
vpnInstance.getVpnId());
if (vpnDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
return;
}
String vpnName = getFibUtil().getVpnNameFromId(vpnInstance.getVpnId());
- final Collection<VpnToDpnList> vpnToDpnList = vpnInstance.getVpnToDpnList();
- if (vpnToDpnList != null) {
+ final Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap = vpnInstance.getVpnToDpnList();
+ if (keyVpnToDpnListMap != null) {
List<String> usedRds = VpnExtraRouteHelper.getUsedRds(dataBroker,
vpnInstance.getVpnId(), vrfEntry.getDestPrefix());
Optional<Routes> extraRouteOptional;
} else {
extraRouteOptional = Optional.empty();
}
- for (VpnToDpnList curDpn : vpnToDpnList) {
+ for (VpnToDpnList curDpn : keyVpnToDpnListMap.values()) {
if (curDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
deleteRemoteRoute(Uint64.ZERO, curDpn.getDpnId(), vpnInstance.getVpnId(),
vrfTableKey, vrfEntry, extraRouteOptional, writeTx, subTxns);
final Uint64 dpnId, final Uint32 vpnId, final String rd,
final String remoteNextHopIp, final Optional<VrfTables> vrfTable,
WriteTransaction writeCfgTxn, List<SubTransaction> subTxns) {
- return vrfEntry -> vrfEntry.nonnullRoutePaths().stream()
+ return vrfEntry -> vrfEntry.nonnullRoutePaths().values().stream()
.filter(routes -> !routes.getNexthopAddress().isEmpty()
&& remoteNextHopIp.trim().equals(routes.getNexthopAddress().trim()))
.findFirst()
final Uint64 dpnId, final Uint32 vpnId,
final String remoteNextHopIp, final Optional<VrfTables> vrfTable,
WriteTransaction writeCfgTxn, List<SubTransaction> subTxns) {
- return vrfEntry -> vrfEntry.nonnullRoutePaths().stream()
+ return vrfEntry -> vrfEntry.nonnullRoutePaths().values().stream()
.filter(routes -> !routes.getNexthopAddress().isEmpty()
&& remoteNextHopIp.trim().equals(routes.getNexthopAddress().trim()))
.findFirst()
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.vpn.extra.routes.Routes;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint32;
+ " has null vpnId!");
if (RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.CONNECTED) {
SubnetRoute subnetRoute = vrfEntry.augmentation(SubnetRoute.class);
- final List<VpnToDpnList> vpnToDpnList = vpnInstance.getVpnToDpnList();
+ final Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap = vpnInstance.getVpnToDpnList();
final long elanTag = subnetRoute.getElantag().toJava();
LOG.trace("SubnetRoute augmented vrfentry found for rd {} prefix {} with elantag {}",
rd, vrfEntry.getDestPrefix(), elanTag);
- if (vpnToDpnList != null) {
+ if (keyVpnToDpnListMap != null) {
jobCoordinator.enqueueJob("FIB-" + rd + "-" + vrfEntry.getDestPrefix(),
() -> Collections.singletonList(
txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
- for (final VpnToDpnList curDpn : vpnToDpnList) {
+ for (final VpnToDpnList curDpn : keyVpnToDpnListMap.values()) {
if (curDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
vrfEntryListener.installSubnetRouteInFib(curDpn.getDpnId(), elanTag, rd,
vpnId, vrfEntry, tx);
List<Uint64> localDpnId, VrfTablesKey vrfTableKey, boolean isNatPrefix) {
LOG.info("Creating remote EVPN flows for prefix {} rd {} route-paths {} evi {}",
vrfEntry.getDestPrefix(), rd, vrfEntry.getRoutePaths(), vrfEntry.getL3vni());
- List<VpnToDpnList> vpnToDpnList = vpnInstance.getVpnToDpnList();
- if (vpnToDpnList != null) {
+ Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap = vpnInstance.getVpnToDpnList();
+ if (keyVpnToDpnListMap != null) {
jobCoordinator.enqueueJob("FIB" + rd + vrfEntry.getDestPrefix(),
() -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
- for (VpnToDpnList vpnDpn : vpnToDpnList) {
+ for (VpnToDpnList vpnDpn : keyVpnToDpnListMap.values()) {
if (!localDpnId.contains(vpnDpn.getDpnId())) {
if (vpnDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
createRemoteFibEntry(vpnDpn.getDpnId(), vpnInstance.getVpnId(),
@SuppressWarnings("ForbidCertainMethod")
private void deleteRemoteEvpnFlows(String rd, VrfEntry vrfEntry, VpnInstanceOpDataEntry vpnInstance,
VrfTablesKey vrfTableKey, List<Uint64> localDpnIdList) {
- List<VpnToDpnList> vpnToDpnList = vpnInstance.getVpnToDpnList();
+ Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap = vpnInstance.getVpnToDpnList();
List<SubTransaction> subTxns = new ArrayList<>();
- if (vpnToDpnList != null) {
+ if (keyVpnToDpnListMap != null) {
jobCoordinator.enqueueJob("FIB" + rd + vrfEntry.getDestPrefix(),
() -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
final Optional<Routes> extraRouteOptional = Optional.empty();
if (localDpnIdList.size() <= 0) {
- for (VpnToDpnList curDpn1 : vpnToDpnList) {
+ for (VpnToDpnList curDpn1 : keyVpnToDpnListMap.values()) {
if (RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.BGP) {
if (curDpn1.getDpnState() == VpnToDpnList.DpnState.Active) {
bgpRouteVrfEntryHandler.deleteRemoteRoute(Uint64.ZERO,
}
} else {
for (Uint64 localDpnId : localDpnIdList) {
- for (VpnToDpnList curDpn2 : vpnToDpnList) {
+ for (VpnToDpnList curDpn2 : keyVpnToDpnListMap.values()) {
if (!Objects.equals(curDpn2.getDpnId(), localDpnId)) {
if (RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.BGP) {
if (curDpn2.getDpnState() == VpnToDpnList.DpnState.Active) {
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.netvirt.vpnmanager.api.IVpnFootprintService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CleanupDpnForVpnInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CleanupDpnForVpnOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CleanupDpnForVpnOutputBuilder;
String vpnRd = getVpnRd(dataBroker, vpnName);
String ipAddress = input.getIpAddress();
LOG.info("Create custom FIB entry - {} on dpn {} for VPN {} ", ipAddress, dpnId, vpnName);
- List<Instruction> instructions = input.getInstruction();
+ Map<InstructionKey, Instruction> instructionMap = input.getInstruction();
LOG.info("ADD: Adding Custom Fib Entry rd {} prefix {} label {}", vpnRd, ipAddress, input.getServiceId());
- makeLocalFibEntry(vpnId, dpnId, ipAddress, instructions);
+ makeLocalFibEntry(vpnId, dpnId, ipAddress, new ArrayList<Instruction>(instructionMap.values()));
IpAddresses.IpAddressSource ipAddressSource = IpAddresses.IpAddressSource
.forValue(input.getIpAddressSource().getIntValue());
vpnFootprintService.updateVpnToDpnMapping(dpnId, vpnName, vpnRd, null /* interfaceName*/,
int priority = FibConstants.DEFAULT_FIB_FLOW_PRIORITY + prefixLength;
+ Map<InstructionKey, Instruction> customInstructionsMap = new HashMap<InstructionKey, Instruction>();
+ int instructionKey = 0;
+ for (Instruction instructionObj : customInstructions) {
+ customInstructionsMap.put(new InstructionKey(++instructionKey), instructionObj);
+ }
Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.L3_FIB_TABLE, flowRef,
priority, flowRef, 0, 0,
- NwConstants.COOKIE_VM_FIB_TABLE, matches, customInstructions);
+ NwConstants.COOKIE_VM_FIB_TABLE, matches, customInstructionsMap);
mdsalManager.installFlow(dpnId, flowEntity);
LOG.debug("FIB entry for route {} on dpn {} installed successfully - flow {}", ipAddress, dpnId, flowEntity);
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.base.Preconditions;
import com.google.common.net.InetAddresses;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentrybase.RoutePaths;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentrybase.RoutePathsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesOp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.L3vpnDcGws;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.L3vpnLbNexthops;
}
buildVpnEncapSpecificInfo(vrfEntryBuilder, encapType, label, l3vni, macAddress, gatewayMacAddress, nextHopList);
if (writeConfigTxn != null) {
- writeConfigTxn.merge(vrfEntryId, vrfEntryBuilder.build(), CREATE_MISSING_PARENTS);
+ writeConfigTxn.mergeParentStructureMerge(vrfEntryId, vrfEntryBuilder.build());
} else {
MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId, vrfEntryBuilder.build());
}
.addAugmentation(RouterInterface.class, routerInterface).build();
if (writeConfigTxn != null) {
- writeConfigTxn.merge(vrfEntryId, vrfEntry, CREATE_MISSING_PARENTS);
+ writeConfigTxn.mergeParentStructureMerge(vrfEntryId, vrfEntry);
} else {
MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId, vrfEntry);
}
prefix, rd, nextHopToRemove, e);
}
if (entry.isPresent()) {
- final List<RoutePaths> routePaths = entry.get().getRoutePaths();
+ final List<RoutePaths> routePaths = new ArrayList<RoutePaths>(entry.get().getRoutePaths().values());
if (routePaths == null || routePaths.isEmpty()) {
LOG.warn("routePaths is null/empty for given rd {}, prefix {}", rd, prefix);
return;
if (nextHopAdd) {
RoutePaths routePaths = FibHelper.buildRoutePath(nextHop, label);
if (writeConfigTxn != null) {
- writeConfigTxn.put(routePathId, routePaths, CREATE_MISSING_PARENTS);
+ writeConfigTxn.mergeParentStructurePut(routePathId, routePaths);
} else {
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routePathId, routePaths);
}
}
public static java.util.Optional<Uint32> getLabelFromRoutePaths(final VrfEntry vrfEntry) {
- List<RoutePaths> routePaths = vrfEntry.getRoutePaths();
- if (routePaths == null || routePaths.isEmpty() || vrfEntry.getRoutePaths().get(0).getLabel() == null) {
+ List<RoutePaths> routePaths = new ArrayList<RoutePaths>(vrfEntry.getRoutePaths().values());
+ if (routePaths == null || routePaths.isEmpty()
+ || new ArrayList<RoutePaths>(vrfEntry.getRoutePaths().values()).get(0).getLabel() == null) {
return java.util.Optional.empty();
}
- return java.util.Optional.of(vrfEntry.getRoutePaths().get(0).getLabel());
+ return java.util.Optional.of(new ArrayList<RoutePaths>(vrfEntry.getRoutePaths().values()).get(0).getLabel());
}
public static java.util.Optional<String> getFirstNextHopAddress(final VrfEntry vrfEntry) {
- List<RoutePaths> routePaths = vrfEntry.getRoutePaths();
+ List<RoutePaths> routePaths = new ArrayList<RoutePaths>(vrfEntry.getRoutePaths().values());
if (routePaths == null || routePaths.isEmpty()) {
return java.util.Optional.empty();
}
- return java.util.Optional.of(vrfEntry.getRoutePaths().get(0).getNexthopAddress());
+ return java.util.Optional.of(new ArrayList<RoutePaths>(vrfEntry.getRoutePaths().values())
+ .get(0).getNexthopAddress());
}
public static java.util.Optional<Uint32> getLabelForNextHop(final VrfEntry vrfEntry, String nextHopIp) {
- List<RoutePaths> routePaths = vrfEntry.getRoutePaths();
+ List<RoutePaths> routePaths = new ArrayList<RoutePaths>(vrfEntry.getRoutePaths().values());
if (routePaths == null || routePaths.isEmpty()) {
return java.util.Optional.empty();
}
if (!dcGwsOpt.isPresent()) {
return Collections.emptyList();
}
- return dcGwsOpt.get().getDcGateway().stream().map(DcGateway::getIpAddress).collect(toList());
+ return dcGwsOpt.get().getDcGateway().values().stream().map(DcGateway::getIpAddress).collect(toList());
}
static boolean isVxlanNetwork(NetworkType networkType) {
return false;
}
if (entry.isPresent()) {
- List<RoutePaths> paths = entry.get().getRoutePaths();
- for (RoutePaths path: paths) {
+ Map<RoutePathsKey, RoutePaths> pathsMap = entry.get().getRoutePaths();
+ for (RoutePaths path: pathsMap.values()) {
if (path.getNexthopAddress().equals(nextHopIp)) {
return true;
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.DcGatewayIpList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.dc.gateway.ip.list.DcGatewayIp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetEgressActionsForTunnelInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetEgressActionsForTunnelOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetInternalOrExternalInterfaceNameInputBuilder;
ifName, rpcResult.getErrors());
return Collections.emptyList();
} else {
- actions = rpcResult.getResult().nonnullAction();
+ actions = new ArrayList<Action>(rpcResult.getResult().nonnullAction().values());
}
} else {
RpcResult<GetEgressActionsForInterfaceOutput> rpcResult = odlInterfaceRpcService
+ "Errors {}", ifName, vpnId, destIpPrefix, rpcResult.getErrors());
return Collections.emptyList();
} else {
- actions = rpcResult.getResult().nonnullAction();
+ actions = new ArrayList<Action>(rpcResult.getResult().nonnullAction().values());
}
}
List<ActionInfo> listActionInfo = new ArrayList<>();
} else {
// Ignore adding new prefix , if it already exists
- List<IpAdjacencies> prefixesList = nexthop.getIpAdjacencies();
+ Map<IpAdjacenciesKey, IpAdjacencies> keyIpAdjacenciesMap = nexthop.getIpAdjacencies();
IpAdjacencies prefix = new IpAdjacenciesBuilder().setIpAdjacency(currDestIpPrefix).build();
- if (prefixesList != null && prefixesList.contains(prefix)) {
+ if (keyIpAdjacenciesMap != null && keyIpAdjacenciesMap.values().contains(prefix)) {
LOG.trace("Prefix {} is already present in l3nextHop {} ", currDestIpPrefix, nexthop);
} else {
IpAdjacenciesBuilder ipPrefixesBuilder =
return null;
}
if (vpnNexthops.isPresent()) {
- // get nexthops list for vpn
- List<VpnNexthop> nexthops = vpnNexthops.get().nonnullVpnNexthop();
- for (VpnNexthop nexthop : nexthops) {
+ // get keyVpnNexthopMap list for vpn
+ Map<VpnNexthopKey, VpnNexthop> keyVpnNexthopMap = vpnNexthops.get().nonnullVpnNexthop();
+ for (VpnNexthop nexthop : keyVpnNexthopMap.values()) {
if (Objects.equals(nexthop.getIpAddress(), ipAddress)) {
// return nexthop
LOG.trace("VpnNextHop : {}", nexthop);
if (FibUtil.lockCluster(lockManager, nextHopLockStr, WAIT_TIME_TO_ACQUIRE_LOCK)) {
VpnNexthop nh = getVpnNexthop(vpnId, primaryIpAddress);
if (nh != null) {
- List<IpAdjacencies> prefixesList = new ArrayList<>(nh.nonnullIpAdjacencies());
+ List<IpAdjacencies> prefixesList = new ArrayList<IpAdjacencies>(nh.nonnullIpAdjacencies().values());
IpAdjacencies prefix = new IpAdjacenciesBuilder().setIpAdjacency(currDestIpPrefix).build();
prefixesList.remove(prefix);
if (prefixesList.isEmpty()) { //remove the group only if there are no more flows using this group
if (dcGatewayIpListConfig == null) {
return Collections.emptyList();
}
- return dcGatewayIpListConfig.getDcGatewayIp()
+ return new ArrayList<DcGatewayIp>(dcGatewayIpListConfig.getDcGatewayIp().values())
.stream()
.filter(dcGwIp -> dcGwIp.getTunnnelType().equals(TunnelTypeMplsOverGre.class))
.map(dcGwIp -> dcGwIp.getIpAddress().stringValue()).sorted()
LOG.warn("RPC Call to Get egress actions for interface {} returned with Errors {}",
interfaceName, rpcResult.getErrors());
} else {
- actions = rpcResult.getResult().nonnullAction();
+ actions = new ArrayList<Action>(rpcResult.getResult().nonnullAction().values());
}
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Exception when egress actions for interface {}", interfaceName, e);
import static org.opendaylight.genius.mdsalutil.NWUtil.isIpv4Address;
import com.google.common.base.Preconditions;
-import java.util.Collection;
+import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
final ReentrantLock lock = JvmGlobalLocks.getLockForString(vpnInstance.getVpnInstanceName());
lock.lock();
try {
- final Collection<VpnToDpnList> vpnToDpnList;
+ final Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap;
if (vrfEntry.getParentVpnRd() != null
&& FibHelper.isControllerManagedNonSelfImportedRoute(RouteOrigin.value(vrfEntry.getOrigin()))) {
VpnInstanceOpDataEntry parentVpnInstance =
getFibUtil().getVpnInstance(vrfEntry.getParentVpnRd());
- vpnToDpnList = parentVpnInstance != null ? parentVpnInstance.getVpnToDpnList()
+ keyVpnToDpnListMap = parentVpnInstance != null ? parentVpnInstance.getVpnToDpnList()
: vpnInstance.getVpnToDpnList();
} else {
- vpnToDpnList = vpnInstance.getVpnToDpnList();
+ keyVpnToDpnListMap = vpnInstance.getVpnToDpnList();
}
final Uint32 vpnId = vpnInstance.getVpnId();
- if (vpnToDpnList != null) {
+ if (keyVpnToDpnListMap != null) {
String routerId = routerInterface.getUuid();
String macAddress = routerInterface.getMacAddress();
String ipValue = routerInterface.getIpAddress();
LOG.trace("createFibEntries - Router augmented vrfentry found for for router uuid:{}, ip:{}, mac:{}",
routerId, ipValue, macAddress);
- for (VpnToDpnList vpnDpn : vpnToDpnList) {
+ for (VpnToDpnList vpnDpn : keyVpnToDpnListMap.values()) {
if (vpnDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
installRouterFibEntry(vrfEntry, vpnDpn.getDpnId(), vpnId, ipValue,
new MacAddress(macAddress), addOrRemove);
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import static org.opendaylight.genius.mdsalutil.NWUtil.isIpv4Address;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collection;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.Callable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentrybase.RoutePaths;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentrybase.RoutePathsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesOp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn._interface.op.data.VpnInterfaceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.vpn.extra.routes.Routes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.Adjacency;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.AdjacencyBuilder;
}
if (RouteOrigin.value(update.getOrigin()) == RouteOrigin.STATIC) {
- List<RoutePaths> originalRoutePath = original.getRoutePaths();
- List<RoutePaths> updateRoutePath = update.getRoutePaths();
+ List<RoutePaths> originalRoutePath = new ArrayList<RoutePaths>(original.getRoutePaths().values());
+ List<RoutePaths> updateRoutePath = new ArrayList<RoutePaths>(update.getRoutePaths().values());
LOG.info("UPDATE: Original route-path {} update route-path {} ", originalRoutePath, updateRoutePath);
//Updates need to be handled for extraroute even if original vrf entry route path is null or
Preconditions.checkNotNull(vpnInstance, "Vpn Instance not available " + vrfTableKey.getRouteDistinguisher());
Preconditions.checkNotNull(vpnInstance.getVpnId(), "Vpn Instance with rd " + vpnInstance.getVrfId()
+ " has null vpnId!");
- final Collection<VpnToDpnList> vpnToDpnList;
+ final Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap;
if (vrfEntry.getParentVpnRd() != null
&& FibHelper.isControllerManagedNonSelfImportedRoute(RouteOrigin.value(vrfEntry.getOrigin()))) {
// This block MUST BE HIT only for PNF (Physical Network Function) FIB Entries.
VpnInstanceOpDataEntry parentVpnInstance = fibUtil.getVpnInstance(vrfEntry.getParentVpnRd());
- vpnToDpnList = parentVpnInstance != null ? parentVpnInstance.getVpnToDpnList() :
+ keyVpnToDpnListMap = parentVpnInstance != null ? parentVpnInstance.getVpnToDpnList() :
vpnInstance.getVpnToDpnList();
LOG.info("createFibEntries: Processing creation of PNF FIB entry with rd {} prefix {}",
vrfEntry.getParentVpnRd(), vrfEntry.getDestPrefix());
} else {
- vpnToDpnList = vpnInstance.getVpnToDpnList();
+ keyVpnToDpnListMap = vpnInstance.getVpnToDpnList();
}
final Uint32 vpnId = vpnInstance.getVpnId();
final String rd = vrfTableKey.getRouteDistinguisher();
final long elanTag = subnetRoute.getElantag().toJava();
LOG.trace("SUBNETROUTE: createFibEntries: SubnetRoute augmented vrfentry found for rd {} prefix {}"
+ " with elantag {}", rd, vrfEntry.getDestPrefix(), elanTag);
- if (vpnToDpnList != null) {
+ if (keyVpnToDpnListMap != null) {
jobCoordinator.enqueueJob(FibUtil.getJobKeyForRdPrefix(rd, vrfEntry.getDestPrefix()),
() -> Collections.singletonList(
txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
- for (final VpnToDpnList curDpn : vpnToDpnList) {
+ for (final VpnToDpnList curDpn : keyVpnToDpnListMap.values()) {
if (curDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
installSubnetRouteInFib(curDpn.getDpnId(),
elanTag, rd, vpnId, vrfEntry, tx);
final List<Uint64> localDpnIdList = createLocalFibEntry(vpnInstance.getVpnId(),
rd, vrfEntry, etherType);
- if (!localDpnIdList.isEmpty() && vpnToDpnList != null) {
+ if (!localDpnIdList.isEmpty() && keyVpnToDpnListMap != null) {
jobCoordinator.enqueueJob(FibUtil.getJobKeyForRdPrefix(rd, vrfEntry.getDestPrefix()),
() -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
final ReentrantLock lock = lockFor(vpnInstance);
lock.lock();
try {
- for (VpnToDpnList vpnDpn : vpnToDpnList) {
+ for (VpnToDpnList vpnDpn : keyVpnToDpnListMap.values()) {
if (!localDpnIdList.contains(vpnDpn.getDpnId())) {
if (vpnDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
try {
baseVrfEntryHandler.makeConnectedRoute(dpnId, vpnId, vrfEntry, rd, instructions,
NwConstants.ADD_FLOW, TransactionAdapter.toWriteTransaction(tx), null);
if (vrfEntry.getRoutePaths() != null) {
- for (RoutePaths routePath : vrfEntry.getRoutePaths()) {
+ for (RoutePaths routePath : vrfEntry.getRoutePaths().values()) {
if (RouteOrigin.value(vrfEntry.getOrigin()) != RouteOrigin.SELF_IMPORTED) {
List<ActionInfo> actionsInfos = new ArrayList<>();
// reinitialize instructions list for LFIB Table
.child(Table.class, new TableKey(flow.getTableId())).child(Flow.class, flowKey).build();
if (addOrRemove == NwConstants.ADD_FLOW) {
- tx.put(flowInstanceId,flow, true);
+ tx.mergeParentStructurePut(flowInstanceId,flow);
} else {
tx.delete(flowInstanceId);
}
Preconditions.checkArgument(vrfEntry.getRoutePaths() != null
&& vrfEntry.getRoutePaths().size() == 1);
String destination = vrfEntry.getDestPrefix();
- String nextHop = vrfEntry.getRoutePaths().get(0).getNexthopAddress();
+ String nextHop = new ArrayList<RoutePaths>(vrfEntry.getRoutePaths().values()).get(0).getNexthopAddress();
String interVpnLinkName = interVpnLink.getInterVpnLinkName();
// After having received a static route, we should check if the vpn is part of an inter-vpn-link.
.L3VPN_SERVICE_INDEX)),
MetaDataUtil.getMetaDataMaskForLPortDispatcher()).buildInstruction(0),
new InstructionGotoTable(NwConstants.L3_INTERFACE_TABLE).buildInstruction(1));
+ Map<InstructionKey, Instruction> instructionsMap = new HashMap<InstructionKey, Instruction>();
+ int instructionKey = 0;
+ for (Instruction instructionObj : instructions) {
+ instructionsMap.put(new InstructionKey(++instructionKey), instructionObj);
+ }
int priority = DEFAULT_FIB_FLOW_PRIORITY + prefixLength;
String flowRef = getInterVpnFibFlowRef(interVpnLinkName, destination, nextHop);
Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.L3_FIB_TABLE, flowRef, priority, flowRef, 0, 0,
- COOKIE_VM_FIB_TABLE, matches, instructions);
+ COOKIE_VM_FIB_TABLE, matches, instructionsMap);
LOG.trace("Installing flow in FIB table for vpn {} interVpnLink {} nextHop {} key {}",
vpnUuid, interVpnLink.getInterVpnLinkName(), nextHop, flowRef);
.child(Node.class, nodeDpn.key()).augmentation(FlowCapableNode.class)
.child(Table.class, new TableKey(terminatingServiceTableFlowEntity.getTableId()))
.child(Flow.class, flowKey).build();
- tx.put(flowInstanceId, flowbld.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(flowInstanceId, flowbld.build());
}
private void removeTunnelTableEntry(Uint64 dpId, Uint32 label, TypedWriteTransaction<Configuration> tx) {
return;
}
- @NonNull List<Adjacency> adjacencies = optAdjacencies.get().nonnullAdjacency();
+ @NonNull List<Adjacency> adjacencies
+ = new ArrayList<Adjacency>(optAdjacencies.get().nonnullAdjacency().values());
if (adjacencies.size() <= 2
&& adjacencies.stream().allMatch(adjacency ->
adjacency.getAdjacencyType() == Adjacency.AdjacencyType.PrimaryAdjacency
LOG.error("VPN Instance for rd {} is not available from VPN Op Instance Datastore", rd);
return;
}
- final Collection<VpnToDpnList> vpnToDpnList;
+ final Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap;
if (vrfEntry.getParentVpnRd() != null
&& FibHelper.isControllerManagedNonSelfImportedRoute(RouteOrigin.value(vrfEntry.getOrigin()))) {
// This block MUST BE HIT only for PNF (Physical Network Function) FIB Entries.
VpnInstanceOpDataEntry parentVpnInstance = fibUtil.getVpnInstance(vrfEntry.getParentVpnRd());
- vpnToDpnList = parentVpnInstance != null ? parentVpnInstance.getVpnToDpnList() :
+ keyVpnToDpnListMap = parentVpnInstance != null ? parentVpnInstance.getVpnToDpnList() :
vpnInstance.getVpnToDpnList();
LOG.info("deleteFibEntries: Processing deletion of PNF FIB entry with rd {} prefix {}",
vrfEntry.getParentVpnRd(), vrfEntry.getDestPrefix());
} else {
- vpnToDpnList = vpnInstance.getVpnToDpnList();
+ keyVpnToDpnListMap = vpnInstance.getVpnToDpnList();
}
SubnetRoute subnetRoute = vrfEntry.augmentation(SubnetRoute.class);
long elanTag = subnetRoute.getElantag().toJava();
LOG.trace("SUBNETROUTE: deleteFibEntries: SubnetRoute augmented vrfentry found for rd {} prefix {}"
+ " with elantag {}", rd, vrfEntry.getDestPrefix(), elanTag);
- if (vpnToDpnList != null) {
+ if (keyVpnToDpnListMap != null) {
jobCoordinator.enqueueJob(FibUtil.getJobKeyForRdPrefix(rd, vrfEntry.getDestPrefix()),
() -> Collections.singletonList(
txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
- for (final VpnToDpnList curDpn : vpnToDpnList) {
+ for (final VpnToDpnList curDpn : keyVpnToDpnListMap.values()) {
baseVrfEntryHandler.makeConnectedRoute(curDpn.getDpnId(),
vpnInstance.getVpnId(),
final List<Uint64> localDpnIdList = deleteLocalFibEntry(vpnInstance.getVpnId(),
vrfTableKey.getRouteDistinguisher(), vrfEntry);
- if (vpnToDpnList != null) {
+ if (keyVpnToDpnListMap != null) {
List<String> usedRds = VpnExtraRouteHelper.getUsedRds(dataBroker,
vpnInstance.getVpnId(), vrfEntry.getDestPrefix());
String jobKey;
jobCoordinator.enqueueJob(FibUtil.getJobKeyForRdPrefix(rd, vrfEntry.getDestPrefix()),
() -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
if (localDpnIdList.size() <= 0) {
- for (VpnToDpnList curDpn : vpnToDpnList) {
+ for (VpnToDpnList curDpn : keyVpnToDpnListMap.values()) {
baseVrfEntryHandler.deleteRemoteRoute(Uint64.ZERO, curDpn.getDpnId(),
vpnInstance.getVpnId(), vrfTableKey, vrfEntry, extraRouteOptional,
TransactionAdapter.toWriteTransaction(tx));
}
} else {
for (Uint64 localDpnId : localDpnIdList) {
- for (VpnToDpnList curDpn : vpnToDpnList) {
+ for (VpnToDpnList curDpn : keyVpnToDpnListMap.values()) {
if (!Objects.equals(curDpn.getDpnId(), localDpnId)) {
baseVrfEntryHandler.deleteRemoteRoute(localDpnId, curDpn.getDpnId(),
vpnInstance.getVpnId(), vrfTableKey, vrfEntry, extraRouteOptional,
.child(Table.class, new TableKey(flow.getTableId())).child(Flow.class, flowKey).build();
if (addOrRemove == NwConstants.ADD_FLOW) {
- tx.put(flowInstanceId, flow, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(flowInstanceId, flow);
} else {
tx.delete(flowInstanceId);
}
lock.lock();
try {
futures.add(retryingTxRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
- for (final VrfEntry vrfEntry : vrfTable.get().nonnullVrfEntry()) {
+ for (final VrfEntry vrfEntry : vrfTable.get().nonnullVrfEntry().values()) {
SubnetRoute subnetRoute = vrfEntry.augmentation(SubnetRoute.class);
if (subnetRoute != null) {
long elanTag = subnetRoute.getElantag().toJava();
final ReentrantLock lock = lockFor(vpnInstance);
lock.lock();
try {
- vrfTable.get().nonnullVrfEntry().stream()
+ vrfTable.get().nonnullVrfEntry().values().stream()
.filter(vrfEntry -> RouteOrigin.BGP == RouteOrigin.value(vrfEntry.getOrigin()))
.forEach(bgpRouteVrfEntryHandler.getConsumerForCreatingRemoteFib(dpnId, vpnId,
rd, remoteNextHopIp, vrfTable, TransactionAdapter.toWriteTransaction(tx), txnObjects));
}
LOG.trace("manageRemoteRouteOnDPN :: action {}, DpnId {}, vpnId {}, rd {}, destPfx {}",
action, localDpnId, vpnId, rd, destPrefix);
- List<RoutePaths> routePathList = vrfEntry.getRoutePaths();
+ Map<RoutePathsKey, RoutePaths> keyRoutePathsMap = vrfEntry.getRoutePaths();
VrfEntry modVrfEntry;
- if (routePathList == null || routePathList.isEmpty()) {
+ if (keyRoutePathsMap == null || keyRoutePathsMap.isEmpty()) {
modVrfEntry = FibHelper.getVrfEntryBuilder(vrfEntry, label,
Collections.singletonList(destTepIp),
RouteOrigin.value(vrfEntry.getOrigin()), null /* parentVpnRd */).build();
try {
futures.add(retryingTxRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
String vpnName = fibUtil.getVpnNameFromId(vpnInstance.getVpnId());
- for (final VrfEntry vrfEntry : vrfTable.get().nonnullVrfEntry()) {
+ for (final VrfEntry vrfEntry : vrfTable.get().nonnullVrfEntry().values()) {
/* parentRd is only filled for external PNF cases where the interface on the external
* network VPN are used to cleanup the flows. For all other cases, use "rd" for
* #fibUtil.isInterfacePresentInDpn().
+ " for vpn {}", vrfEntry.getDestPrefix(), dpnId, rd);
baseVrfEntryHandler.makeConnectedRoute(dpnId, vpnId, vrfEntry, rd, null,
NwConstants.DEL_FLOW, TransactionAdapter.toWriteTransaction(tx), null);
- List<RoutePaths> routePaths = vrfEntry.getRoutePaths();
- if (routePaths != null) {
- for (RoutePaths routePath : routePaths) {
+ Map<RoutePathsKey, RoutePaths> keyRoutePathsMap = vrfEntry.getRoutePaths();
+ if (keyRoutePathsMap != null) {
+ for (RoutePaths routePath : keyRoutePathsMap.values()) {
makeLFibTableEntry(dpnId, routePath.getLabel(), null,
DEFAULT_FIB_FLOW_PRIORITY,
NwConstants.DEL_FLOW, tx);
try {
return Collections.singletonList(
txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> vrfTable.get().nonnullVrfEntry().stream()
+ tx -> vrfTable.get().nonnullVrfEntry().values().stream()
.filter(vrfEntry -> RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.BGP)
.forEach(bgpRouteVrfEntryHandler.getConsumerForDeletingRemoteFib(dpnId, vpnId,
remoteNextHopIp, vrfTable, TransactionAdapter.toWriteTransaction(tx),
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
import java.net.UnknownHostException;
import java.util.List;
import java.util.Locale;
+import java.util.Map;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.VrfEntryBase.EncapType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentrybase.RoutePaths;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentrybase.RoutePathsKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
try {
FibEntries fibEntries = singleTxDb.syncRead(LogicalDatastoreType.CONFIGURATION, id);
- List<VrfTables> vrfTablesList = fibEntries.getVrfTables();
- if (vrfTablesList == null || vrfTablesList.isEmpty()) {
+ Map<VrfTablesKey, VrfTables> keyVrfTablesMap = fibEntries.getVrfTables();
+ if (keyVrfTablesMap == null || keyVrfTablesMap.isEmpty()) {
console.println(" No Fib entries found");
return null;
}
- for (VrfTables vrfTable : vrfTablesList) {
+ for (VrfTables vrfTable : keyVrfTablesMap.values()) {
printVrfTable(vrfTable, console);
}
} catch (ExpectedDataObjectNotFoundException e404) {
try {
FibEntries fibEntries = singleTxDb.syncRead(LogicalDatastoreType.CONFIGURATION, id);
- List<VrfTables> vrfTablesList = fibEntries.getVrfTables();
- if (vrfTablesList == null || vrfTablesList.isEmpty()) {
+ Map<VrfTablesKey, VrfTables> keyVrfTablesMap = fibEntries.getVrfTables();
+ if (keyVrfTablesMap == null || keyVrfTablesMap.isEmpty()) {
console.println(" No Fib entries found");
return null;
}
- for (VrfTables vrfTable : vrfTablesList) {
+ for (VrfTables vrfTable : keyVrfTablesMap.values()) {
printVrfTable(vrfTable, console, isIpv4, isIpv6, isL2vpn, prefixOrSubnet);
}
} catch (ExpectedDataObjectNotFoundException e404) {
private void printVrfTable(VrfTables vrfTable, PrintStream console, boolean isIpv4, boolean isIpv6,
boolean isL2vpn, @Nullable String inputPrefixOrSubnet) {
- List<VrfEntry> vrfEntries = vrfTable.getVrfEntry();
- if (vrfEntries == null) {
- LOG.warn("Null vrfEntries found for VPN with rd={}", vrfTable.getRouteDistinguisher());
+ Map<VrfEntryKey, VrfEntry> keyVrfEntryMap = vrfTable.getVrfEntry();
+ if (keyVrfEntryMap == null) {
+ LOG.warn("Null keyVrfEntryMap found for VPN with rd={}", vrfTable.getRouteDistinguisher());
return;
}
- for (VrfEntry vrfEntry : vrfEntries) {
+ for (VrfEntry vrfEntry : keyVrfEntryMap.values()) {
boolean showIt = false;
if (isIpv4 && isIpv6 && isL2vpn) {
showIt = true;
if (!showIt) {
continue;
}
- List<RoutePaths> routePaths = vrfEntry.getRoutePaths();
- if (routePaths == null || routePaths.isEmpty()) {
+ Map<RoutePathsKey, RoutePaths> routePathsMap = vrfEntry.getRoutePaths();
+ if (routePathsMap == null || routePathsMap.isEmpty()) {
console.println(String.format(TABULAR_FORMAT,
vrfTable.getRouteDistinguisher(), vrfEntry.getDestPrefix(),
- "local", routePaths == null ? "<not set>" : "<empty>",
+ "local", routePathsMap == null ? "<not set>" : "<empty>",
vrfEntry.getOrigin()));
continue;
}
- for (RoutePaths routePath : routePaths) {
+ for (RoutePaths routePath : routePathsMap.values()) {
console.println(String.format(TABULAR_FORMAT,
vrfTable.getRouteDistinguisher(), vrfEntry.getDestPrefix(),
routePath.getNexthopAddress(), routePath.getLabel(),
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<!-- <dependency>
LOG.warn("RPC Call to Get egress actions for interface {} returned with Errors {}",
interfaceName, rpcResult.getErrors());
} else {
- actions = rpcResult.getResult().getAction();
+ actions = new ArrayList<Action>(rpcResult.getResult().getAction().values());
}
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Exception when egress actions for interface {}", interfaceName, e);
buf.putInt((int)pdu.getMtu().longValue());
}
- for (PrefixList prefix : pdu.nonnullPrefixList()) {
+ for (PrefixList prefix : new ArrayList<PrefixList>(pdu.nonnullPrefixList().values())) {
buf.put((byte)prefix.getOptionType().shortValue());
buf.put((byte)prefix.getOptionLength().shortValue());
buf.put((byte)prefix.getPrefixLength().shortValue());
package org.opendaylight.netvirt.ipv6service;
import com.google.common.base.Strings;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
}
LOG.debug("Add port notification handler is invoked for port {} ", port);
- for (FixedIps fixedip : port.nonnullFixedIps()) {
+ for (FixedIps fixedip : port.nonnullFixedIps().values()) {
if (fixedip.getIpAddress().getIpv4Address() != null) {
continue;
}
LOG.debug("update port notification handler is invoked for port {} ", update);
- Set<FixedIps> ipsBefore = getFixedIpSet(original.getFixedIps());
- Set<FixedIps> ipsAfter = getFixedIpSet(update.getFixedIps());
+ Set<FixedIps> ipsBefore = getFixedIpSet(new ArrayList<FixedIps>(original.getFixedIps().values()));
+ Set<FixedIps> ipsAfter = getFixedIpSet(new ArrayList<FixedIps>(update.getFixedIps().values()));
- Set<FixedIps> deletedIps = new HashSet<>(ipsBefore);
+ Set<FixedIps> deletedIps = new HashSet<FixedIps>(ipsBefore);
deletedIps.removeAll(ipsAfter);
if (!ipsBefore.equals(ipsAfter)) {
Boolean portIncludesV6Address = Boolean.FALSE;
ifMgr.clearAnyExistingSubnetInfo(update.getUuid());
- Set<FixedIps> remainingIps = new HashSet<>(ipsAfter);
+ Set<FixedIps> remainingIps = new HashSet<FixedIps>(ipsAfter);
remainingIps.removeAll(deletedIps);
for (FixedIps fixedip : remainingIps) {
if (fixedip.getIpAddress().getIpv4Address() != null) {
}
if (update.getDeviceOwner().equalsIgnoreCase(Ipv6ServiceConstants.NETWORK_ROUTER_INTERFACE)) {
- ifMgr.updateRouterIntf(update.getUuid(), new Uuid(update.getDeviceId()), update.getFixedIps(),
- deletedIps);
+ ifMgr.updateRouterIntf(update.getUuid(), new Uuid(update.getDeviceId()),
+ new ArrayList<FixedIps>(update.getFixedIps().values()), deletedIps);
} else {
ifMgr.updateHostIntf(update.getUuid(), portIncludesV6Address);
}
//Neutron Port update with proper device owner information
if ((Strings.isNullOrEmpty(original.getDeviceOwner()) || Strings.isNullOrEmpty(original.getDeviceId()))
&& !Strings.isNullOrEmpty(update.getDeviceOwner()) && !Strings.isNullOrEmpty(update.getDeviceId())) {
- for (FixedIps fixedip : update.nonnullFixedIps()) {
+ for (FixedIps fixedip : update.nonnullFixedIps().values()) {
if (fixedip.getIpAddress().getIpv4Address() != null) {
continue;
}
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;
-
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.slf4j.Logger;
<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>karaf4-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
package org.opendaylight.netvirt.natservice.api;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.common.Uint64;
public interface NatSwitchCache {
package org.opendaylight.netvirt.natservice.api;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.common.Uint64;
public final class SwitchInfo {
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <artifactId>sal-common-util</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
ps.printf(String.format(" %-36s %-20s %-20s %n", "Router Id ", "Datapath Node Id", "Managment Ip Address"));
ps.printf("-------------------------------------------------------------------------------------------%n");
if (npatSwitches.isPresent()) {
- for (RouterToNaptSwitch routerToNaptSwitch : npatSwitches.get().nonnullRouterToNaptSwitch()) {
+ for (RouterToNaptSwitch routerToNaptSwitch : npatSwitches.get().nonnullRouterToNaptSwitch().values()) {
ps.printf(String.format(" %-36s %-20s %-20s %n", routerToNaptSwitch.getRouterName(),
routerToNaptSwitch.getPrimarySwitchId(),
getDpnLocalIp(routerToNaptSwitch.getPrimarySwitchId().toJava())));
}
if (ovsdbNode != null && ovsdbNode.getOpenvswitchOtherConfigs() != null) {
- for (OpenvswitchOtherConfigs openvswitchOtherConfigs : ovsdbNode.getOpenvswitchOtherConfigs()) {
+ for (OpenvswitchOtherConfigs openvswitchOtherConfigs : ovsdbNode.getOpenvswitchOtherConfigs().values()) {
if (key.equals(openvswitchOtherConfigs.getOtherConfigKey())) {
return openvswitchOtherConfigs.getOtherConfigValue();
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.NaptSwitches;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitchKey;
RouterToNaptSwitch routerToNaptSwitch = SingleTransactionDataBroker.syncRead(dataBroker,
LogicalDatastoreType.CONFIGURATION, id);
boolean isSnatEnabled = newRouter.isEnableSnat();
- List<ExternalIps> updateExternalIps = newRouter.getExternalIps();
- if (updateExternalIps == null || updateExternalIps.isEmpty()) {
+ Map<ExternalIpsKey, ExternalIps> updateExternalIpsMap = newRouter.getExternalIps();
+ if (updateExternalIpsMap == null || updateExternalIpsMap.isEmpty()) {
isSnatEnabled = false;
}
if (isSnatEnabled != routerToNaptSwitch.isEnableSnat()) {
if (optRouters.isPresent()) {
// Get the list of routers and verify if any routers do not have primarySwitch allocated.
- for (Routers router : optRouters.get().getRouters()) {
- List<ExternalIps> externalIps = router.getExternalIps();
- if (router.isEnableSnat() && externalIps != null && !externalIps.isEmpty()) {
+ for (Routers router : optRouters.get().getRouters().values()) {
+ Map<ExternalIpsKey, ExternalIps> keyExternalIpsMap = router.getExternalIps();
+ if (router.isEnableSnat() && keyExternalIpsMap != null && !keyExternalIpsMap.isEmpty()) {
// Check if the primarySwitch is allocated for the router.
if (!isPrimarySwitchAllocatedForRouter(router.getRouterName())) {
scheduleCentralizedSwitch(router);
if (natMode == NatserviceConfig.NatMode.Conntrack
&& !INITIAL_SWITCH_WEIGHT.equals(switchWeightMap.get(dpnId))) {
NaptSwitches naptSwitches = getNaptSwitches();
- for (RouterToNaptSwitch routerToNaptSwitch : naptSwitches.getRouterToNaptSwitch()) {
+ for (RouterToNaptSwitch routerToNaptSwitch : naptSwitches.getRouterToNaptSwitch().values()) {
if (dpnId.equals(routerToNaptSwitch.getPrimarySwitchId())) {
Routers router = NatUtil.getRoutersFromConfigDS(dataBroker, routerToNaptSwitch.getRouterName());
releaseCentralizedSwitch(router);
String routerName = routers.getRouterName();
Uint32 routerId = NatUtil.getVpnId(dataBroker, routerName);
addDefaultFibRouteForSNAT(confTx, dpnId, routerId);
- for (ExternalIps externalIp : routers.nonnullExternalIps()) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps().values()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
String routerName = routers.getRouterName();
Uint32 routerId = NatUtil.getVpnId(dataBroker, routerName);
removeDefaultFibRouteForSNAT(confTx, dpnId, routerId);
- for (ExternalIps externalIp : routers.nonnullExternalIps()) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps().values()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
String routerName = routers.getRouterName();
Uint32 routerId = NatUtil.getVpnId(dataBroker, routerName);
String externalGwMac = routers.getExtGwMacAddress();
- for (ExternalIps externalIp : routers.nonnullExternalIps()) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps().values()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
Routers routers, Uint64 dpnId) throws ExecutionException, InterruptedException {
String routerName = routers.getRouterName();
Uint32 routerId = NatUtil.getVpnId(confTx, routerName);
- for (ExternalIps externalIp : routers.nonnullExternalIps()) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps().values()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
private void removeMipAdjacencies(Routers routers) {
LOG.info("removeMipAdjacencies for router {}", routers.getRouterName());
String externalSubNetId = null;
- for (ExternalIps externalIp : routers.nonnullExternalIps()) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps().values()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
VpnInterfaces vpnInterfaces = SingleTransactionDataBroker.syncRead(dataBroker,
LogicalDatastoreType.CONFIGURATION, vpnInterfacesId);
List<VpnInterface> updatedVpnInterface = new ArrayList<>();
- for (VpnInterface vpnInterface : vpnInterfaces.nonnullVpnInterface()) {
+ for (VpnInterface vpnInterface : vpnInterfaces.nonnullVpnInterface().values()) {
List<Adjacency> updatedAdjacencies = new ArrayList<>();
Adjacencies adjacencies = vpnInterface.augmentation(Adjacencies.class);
if (null != adjacencies) {
- for (Adjacency adjacency : adjacencies.nonnullAdjacency()) {
+ for (Adjacency adjacency : adjacencies.nonnullAdjacency().values()) {
if (!adjacency.getSubnetId().getValue().equals(externalSubNetId)) {
updatedAdjacencies.add(adjacency);
}
}
LearntVpnVipToPortDataBuilder learntVpnVipToPortDataBuilder = new LearntVpnVipToPortDataBuilder();
List<LearntVpnVipToPort> learntVpnVipToPortList = new ArrayList<>();
- for (LearntVpnVipToPort learntVpnVipToPort : learntVpnVipToPortData.nonnullLearntVpnVipToPort()) {
+ for (LearntVpnVipToPort learntVpnVipToPort : learntVpnVipToPortData.nonnullLearntVpnVipToPort().values()) {
if (!networkId.equals(learntVpnVipToPort.getVpnName())) {
LOG.info("The learned port belongs to Vpn {} hence not removing", learntVpnVipToPort.getVpnName());
learntVpnVipToPortList.add(learntVpnVipToPort);
} else {
String externalSubNetId = null;
- for (ExternalIps externalIp : routers.nonnullExternalIps()) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps().values()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
String extGwMacAddress = NatUtil.getExtGwMacAddFromRouterName(confTx, routerName);
addOutboundTblTrackEntry(confTx, dpnId, routerId, extGwMacAddress);
- for (ExternalIps externalIp : routers.nonnullExternalIps()) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps().values()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
removeSnatMissEntryForPrimrySwch(confTx, dpnId, routerId);
removeOutboundTblTrackEntry(confTx, dpnId, routerId);
- for (ExternalIps externalIp : routers.nonnullExternalIps()) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps().values()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn._interface.op.data.VpnInterfaceOpDataEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.Adjacencies;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.Adjacency;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.AdjacencyKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterfaceBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.vpn._interface.VpnInstanceNames;
LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
if (optionalVpnInterface.isPresent()) {
ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
- for (VpnInstanceNames vpnInstance : optionalVpnInterface.get().nonnullVpnInstanceNames()) {
+ for (VpnInstanceNames vpnInstance : optionalVpnInterface.get().nonnullVpnInstanceNames().values()) {
if (!vpnName.equals(vpnInstance.getVpnName())) {
continue;
}
VpnInterfaceOpDataEntryBuilder vpnIfOpDataEntryBuilder = new VpnInterfaceOpDataEntryBuilder();
vpnIfOpDataEntryBuilder.withKey(new VpnInterfaceOpDataEntryKey(interfaceName, vpnName));
- List<Adjacency> adjacencyList =
- adjs != null && adjs.getAdjacency() != null ? adjs.getAdjacency() : new ArrayList<>();
+ Map<AdjacencyKey, Adjacency> keyAdjacencyMap =
+ adjs != null && adjs.getAdjacency() != null ? adjs.getAdjacency()
+ : new HashMap<AdjacencyKey, Adjacency>();
List<Adjacency> adjacencyListToImport = new ArrayList<>();
- for (Adjacency adj : adjacencyList) {
+ for (Adjacency adj : keyAdjacencyMap.values()) {
Subnetmap sn = VpnHelper.getSubnetmapFromItsUuid(dataBroker, adj.getSubnetId());
if (!VpnHelper.isSubnetPartOfVpn(sn, vpnName)) {
continue;
floatingIpInterface);
InstanceIdentifier<VpnInterfaceOpDataEntry> vpnIfIdentifierOpDataEntry =
NatUtil.getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnName);
- tx.put(vpnIfIdentifierOpDataEntry, vpnIfOpDataEntryBuilder.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(vpnIfIdentifierOpDataEntry, vpnIfOpDataEntryBuilder.build());
break;
}
}), LOG, "onAddFloatingIp : Could not write Interface {}, vpnName {}", interfaceName, vpnName);
LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
if (optionalVpnInterface.isPresent()) {
ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
- for (VpnInstanceNames vpnInstance : optionalVpnInterface.get().nonnullVpnInstanceNames()) {
+ for (VpnInstanceNames vpnInstance : optionalVpnInterface.get().nonnullVpnInstanceNames().values()) {
if (!vpnName.equals(vpnInstance.getVpnName())) {
continue;
}
dpnId, l3Vni);
List<MatchInfo> mkMatches = new ArrayList<>();
mkMatches.add(new MatchTunnelId(Uint64.valueOf(l3Vni)));
+ Map<InstructionKey, Instruction> customInstructionsMap = new HashMap<InstructionKey, Instruction>();
+ int instructionKey = 0;
+ for (Instruction instructionObj : customInstructions) {
+ customInstructionsMap.put(new InstructionKey(++instructionKey), instructionObj);
+ }
Flow terminatingServiceTableFlowEntity = MDSALUtil.buildFlowNew(NwConstants.INTERNAL_TUNNEL_TABLE,
NatEvpnUtil.getFlowRef(dpnId, NwConstants.INTERNAL_TUNNEL_TABLE, l3Vni, NatConstants.DNAT_FLOW_NAME),
NatConstants.DEFAULT_VPN_INTERNAL_TUNNEL_TABLE_PRIORITY + 1,
String.format("%s:%s", "TST Flow Entry ", l3Vni),
0, 0,
Uint64.valueOf(COOKIE_TUNNEL.toJava().add(BigInteger.valueOf(l3Vni.longValue()))),
- mkMatches, customInstructions);
+ mkMatches, customInstructionsMap);
mdsalManager.addFlow(confTx, dpnId, terminatingServiceTableFlowEntity);
LOG.debug("makeTunnelTableEntry : Successfully installed terminating service table flow {} on DpnId {}",
terminatingServiceTableFlowEntity, dpnId);
import com.google.common.util.concurrent.MoreExecutors;
import java.math.BigInteger;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutput;
List<MatchInfo> mkMatches = new ArrayList<>();
mkMatches.add(new MatchTunnelId(Uint64.valueOf(l3Vni)));
+ Map<InstructionKey, Instruction> customInstructionsMap = new HashMap<InstructionKey, Instruction>();
+ int instructionKey = 0;
+ for (Instruction instructionObj : customInstructions) {
+ customInstructionsMap.put(new InstructionKey(++instructionKey), instructionObj);
+ }
+
Flow terminatingServiceTableFlowEntity = MDSALUtil.buildFlowNew(NwConstants.INTERNAL_TUNNEL_TABLE,
NatEvpnUtil.getFlowRef(dpnId, NwConstants.INTERNAL_TUNNEL_TABLE, l3Vni, NatConstants.SNAT_FLOW_NAME),
NatConstants.DEFAULT_VPN_INTERNAL_TUNNEL_TABLE_PRIORITY,
String.format("%s:%s", "TST Flow Entry ", l3Vni),
0, 0, Uint64.valueOf(COOKIE_TUNNEL.toJava().add(BigInteger.valueOf(l3Vni.longValue()))),
- mkMatches, customInstructions);
+ mkMatches, customInstructionsMap);
mdsalManager.addFlow(confTx, dpnId, terminatingServiceTableFlowEntity);
LOG.debug("makeTunnelTableEntry : Successfully installed terminating service table flow {} on DpnId {}",
terminatingServiceTableFlowEntity, dpnId);
continue;
}
RouterPorts routerPorts = optRouterPorts.get();
- for (Ports port : routerPorts.nonnullPorts()) {
+ for (Ports port : routerPorts.nonnullPorts().values()) {
String portName = port.getPortName();
Uint64 dpnId = NatUtil.getDpnForInterface(interfaceManager, portName);
if (dpnId.equals(Uint64.ZERO)) {
+ "skip handling of ext nw {} association", portName, network.getId());
continue;
}
- for (InternalToExternalPortMap ipMap : port.nonnullInternalToExternalPortMap()) {
+ for (InternalToExternalPortMap ipMap : port.nonnullInternalToExternalPortMap().values()) {
// remove all VPN related entries
coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + ipMap.key(),
() -> Collections.singletonList(
.intext.ip.map.IpMapping> ipMapping = MDSALUtil.read(dataBroker,
LogicalDatastoreType.OPERATIONAL, id);
if (ipMapping.isPresent()) {
- for (IpMap ipMap : ipMapping.get().nonnullIpMap()) {
+ for (IpMap ipMap : ipMapping.get().nonnullIpMap().values()) {
String externalIp = ipMap.getExternalIp();
LOG.debug(
"associateExternalNetworkWithVPN : Calling advToBgpAndInstallFibAndTsFlows "
continue;
}
RouterPorts routerPorts = optRouterPorts.get();
- for (Ports port : routerPorts.nonnullPorts()) {
+ for (Ports port : routerPorts.nonnullPorts().values()) {
String portName = port.getPortName();
Uint64 dpnId = NatUtil.getDpnForInterface(interfaceManager, portName);
if (dpnId.equals(Uint64.ZERO)) {
+ "skip handling of ext nw {} disassociation", portName, network.getId());
continue;
}
- for (InternalToExternalPortMap intExtPortMap : port.nonnullInternalToExternalPortMap()) {
+ for (InternalToExternalPortMap intExtPortMap : port.nonnullInternalToExternalPortMap().values()) {
coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + intExtPortMap.key(),
() -> Collections.singletonList(
txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
package org.opendaylight.netvirt.natservice.internal;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeGre;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.RouterIdName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.ips.counter.ExternalCounters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.ips.counter.external.counters.ExternalIpCounter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.Subnets;
protected void subnetRegisterMapping(Routers routerEntry, Uint32 segmentId) {
LOG.debug("subnetRegisterMapping : Fetching values from extRouters model");
- List<String> externalIps = NatUtil.getIpsListFromExternalIps(routerEntry.getExternalIps());
+ List<String> externalIps = NatUtil.getIpsListFromExternalIps(
+ new ArrayList<ExternalIps>(routerEntry.getExternalIps().values()));
int counter = 0;
int extIpCounter = externalIps.size();
LOG.debug("subnetRegisterMapping : counter values before looping counter {} and extIpCounter {}",
bgpVpnId, bgpVpnName);
RouterIds rtrs = new RouterIdsBuilder().withKey(new RouterIdsKey(bgpVpnId))
.setRouterId(bgpVpnId).setRouterName(bgpVpnName).build();
- confTx.put(getRoutersIdentifier(bgpVpnId), rtrs, CREATE_MISSING_PARENTS);
+ confTx.mergeParentStructurePut(getRoutersIdentifier(bgpVpnId), rtrs);
}
if (create) {
addDefaultFibRouteForSnatWithBgpVpn(routerName, routerId, bgpVpnId, confTx);
LOG.error("handleSnatReverseTraffic : networkId is null for the router ID {}", routerId);
return;
}
- Collection<Uuid> externalSubnetList = NatUtil.getExternalSubnetIdsFromExternalIps(router.getExternalIps());
+ Collection<Uuid> externalSubnetList = NatUtil.getExternalSubnetIdsFromExternalIps(
+ new ArrayList<ExternalIps>(router.getExternalIps().values()));
// FLAT/VLAN case having external-subnet as VPN
String externalSubnetVpn = null;
if (externalSubnetList != null && !externalSubnetList.isEmpty()) {
matches.add(MatchEthernetType.MPLS_UNICAST);
matches.add(new MatchMplsLabel(serviceId.longValue()));
- List<Instruction> instructions = new ArrayList<>();
+ Map<InstructionKey, Instruction> instructionsMap = new HashMap<InstructionKey, Instruction>();
+ int instructionKey = 0;
List<ActionInfo> actionsInfos = new ArrayList<>();
//NAT is required for IPv4 only. Hence always etherType will be IPv4
actionsInfos.add(new ActionPopMpls(NwConstants.ETHTYPE_IPV4));
Instruction writeInstruction = new InstructionApplyActions(actionsInfos).buildInstruction(0);
- instructions.add(writeInstruction);
- instructions.add(new InstructionGotoTable(tableId).buildInstruction(1));
+ instructionsMap.put(new InstructionKey(++instructionKey), writeInstruction);
+ instructionsMap.put(new InstructionKey(++instructionKey),
+ new InstructionGotoTable(tableId).buildInstruction(1));
// Install the flow entry in L3_LFIB_TABLE
String flowRef = getFlowRef(dpId, NwConstants.L3_LFIB_TABLE, serviceId, "");
Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.L3_LFIB_TABLE, flowRef,
10, flowRef, 0, 0,
- COOKIE_VM_LFIB_TABLE, matches, instructions);
+ COOKIE_VM_LFIB_TABLE, matches, instructionsMap);
mdsalManager.addFlow(confTx, dpId, flowEntity);
} else {
mkMatches.add(new MatchTunnelId(Uint64.valueOf(serviceId)));
}
-
+ Map<InstructionKey, Instruction> customInstructionsMap = new HashMap<InstructionKey, Instruction>();
+ int instructionKey = 0;
+ for (Instruction instructionObj : customInstructions) {
+ customInstructionsMap.put(new InstructionKey(++instructionKey), instructionObj);
+ }
Flow terminatingServiceTableFlowEntity = MDSALUtil.buildFlowNew(NwConstants.INTERNAL_TUNNEL_TABLE,
getFlowRef(dpnId, NwConstants.INTERNAL_TUNNEL_TABLE, serviceId, ""),
NatConstants.DEFAULT_VPN_INTERNAL_TUNNEL_TABLE_PRIORITY,
String.format("%s:%s", "TST Flow Entry ", serviceId), 0, 0,
Uint64.valueOf(COOKIE_TUNNEL.toJava().add(BigInteger.valueOf(serviceId.longValue()))),
- mkMatches, customInstructions);
+ mkMatches, customInstructionsMap);
mdsalManager.addFlow(confTx, dpnId, terminatingServiceTableFlowEntity);
}
}
//Check if the Update is on External IPs
LOG.debug("update : Checking if this is update on External IPs for router {}", routerName);
- List<String> originalExternalIps = NatUtil.getIpsListFromExternalIps(original.getExternalIps());
- List<String> updatedExternalIps = NatUtil.getIpsListFromExternalIps(update.getExternalIps());
+ List<String> originalExternalIps = NatUtil.getIpsListFromExternalIps(
+ new ArrayList<ExternalIps>(original.getExternalIps().values()));
+ List<String> updatedExternalIps = NatUtil.getIpsListFromExternalIps(
+ new ArrayList<ExternalIps>(update.getExternalIps().values()));
//Check if the External IPs are removed during the update.
Set<String> removedExternalIps = new HashSet<>(originalExternalIps);
if (ipPortMapping.isPresent()) {
for (IntextIpProtocolType intextIpProtocolType :
- ipPortMapping.get().nonnullIntextIpProtocolType()) {
+ ipPortMapping.get().nonnullIntextIpProtocolType().values()) {
ProtocolTypes protoType = intextIpProtocolType.getProtocol();
- for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap()) {
+ for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap().values()) {
IpPortExternal ipPortExternal = ipPortMap.getIpPortExternal();
if (ipPortExternal.getIpAddress().equals(externalIp)) {
List<String> removedInternalIpPorts =
}
if (externalCountersData.isPresent()) {
ExternalIpsCounter externalIpsCounters = externalCountersData.get();
- for (ExternalCounters ext : externalIpsCounters.nonnullExternalCounters()) {
- for (ExternalIpCounter externalIpCount : ext.nonnullExternalIpCounter()) {
+ for (ExternalCounters ext : externalIpsCounters.nonnullExternalCounters().values()) {
+ for (ExternalIpCounter externalIpCount : ext.nonnullExternalIpCounter().values()) {
if (externalIpCount.getExternalIp().equals(externalIp)) {
if (externalIpCount.getCounter().toJava() != 0) {
return true;
LOG.error("handleDisableSnat : External Network Provider Type missing");
return;
}
- Collection<Uuid> externalSubnetList = NatUtil.getExternalSubnetIdsFromExternalIps(router.getExternalIps());
+ Collection<Uuid> externalSubnetList = NatUtil.getExternalSubnetIdsFromExternalIps(
+ new ArrayList<ExternalIps>(router.getExternalIps().values()));
removeNaptFlowsFromActiveSwitch(routerId, routerName, naptSwitchDpnId, networkUuid, vpnName, externalIps,
externalSubnetList, removeFlowInvTx, extNwProvType);
removeFlowsFromNonActiveSwitches(routerId, routerName, naptSwitchDpnId, removeFlowInvTx);
return;
}
- for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
+ for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType().values()) {
String protocol = intextIpProtocolType.getProtocol().name();
- for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap()) {
+ for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap().values()) {
String ipPortInternal = ipPortMap.getIpPortInternal();
String[] ipPortParts = ipPortInternal.split(":");
if (ipPortParts.length != 2) {
LOG.error("removeNaptFlowsFromActiveSwitchInternetVpn : Unable to retrieve the IpPortMapping");
return;
}
- for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
+ for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType().values()) {
String protocol = intextIpProtocolType.getProtocol().name();
- for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap()) {
+ for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap().values()) {
String ipPortInternal = ipPortMap.getIpPortInternal();
String[] ipPortParts = ipPortInternal.split(":");
if (ipPortParts.length != 2) {
routerId);
return;
}
- for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
- for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap()) {
+ for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType().values()) {
+ for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap().values()) {
String ipPortInternal = ipPortMap.getIpPortInternal();
String[] ipPortParts = ipPortInternal.split(":");
if (ipPortParts.length != 2) {
}
protected boolean routerHasIpv6ExtSubnet(Routers routers) {
- for (ExternalIps externalIp : routers.getExternalIps()) {
+ for (ExternalIps externalIp : routers.getExternalIps().values()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
LOG.debug("router {}, has an external IPv6 subnet {}",
routers.getRouterName(), externalIp.getIpAddress());
public void addSubnetSpecificFlows(TypedReadWriteTransaction<Configuration> confTx, Uint64 dpnId,
Uint32 routerId, Routers routers, Uint64 routerMetadata) {
String extGwMacAddress = NatUtil.getExtGwMacAddFromRouterName(dataBroker, routers.getRouterName());
- for (ExternalIps externalIp : routers.getExternalIps()) {
+ for (ExternalIps externalIp : routers.getExternalIps().values()) {
if (NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// Skip ipv4 subnets in the external network
continue;
public void removeSubnetSpecificFlows(TypedReadWriteTransaction<Configuration> confTx, Uint64 dpnId,
Uint32 routerId, Routers routers)
throws ExecutionException, InterruptedException {
- for (ExternalIps externalIp : routers.getExternalIps()) {
+ for (ExternalIps externalIp : routers.getExternalIps().values()) {
if (NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// Skip ipv4 subnets in the external network
continue;
if (optNaptSwitches.isPresent()) {
NaptSwitches naptSwitches = optNaptSwitches.get();
- for (RouterToNaptSwitch naptSwitch : naptSwitches.nonnullRouterToNaptSwitch()) {
+ for (RouterToNaptSwitch naptSwitch : naptSwitches.nonnullRouterToNaptSwitch().values()) {
Uint64 primarySwitch = naptSwitch.getPrimarySwitchId();
//update weight
Integer weight = switchWeights.get(primarySwitch);
@NonNull
public static List<IpMap> getIpMapList(DataBroker broker, Uint32 routerId) {
InstanceIdentifier<IpMapping> id = getIpMapList(routerId);
- return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+ return new ArrayList<IpMap>(SingleTransactionDataBroker
+ .syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
LogicalDatastoreType.OPERATIONAL, id).map(IpMapping::getIpMap).orElse(
- Collections.emptyList());
+ Collections.emptyMap()).values());
}
protected static InstanceIdentifier<IpMapping> getIpMapList(Uint32 routerId) {
segmentId, internalIp, e);
}
if (ipMapping.isPresent()) {
- for (IpMap ipMap : ipMapping.get().nonnullIpMap()) {
+ for (IpMap ipMap : ipMapping.get().nonnullIpMap().values()) {
if (Objects.equals(ipMap.getInternalIp(), internalIp)) {
LOG.debug("checkIpMap : IpMap : {}", ipMap);
externalIp = ipMap.getExternalIp();
segmentId, e);
}
if (ipMapping.isPresent()) {
- for (IpMap ipMap : ipMapping.get().nonnullIpMap()) {
+ for (IpMap ipMap : ipMapping.get().nonnullIpMap().values()) {
String externalIp = ipMap.getExternalIp();
LOG.debug("removeIpMappingForRouterID : externalIP is {}", externalIp);
if (externalIp != null) {
LOG.debug("initialiseExternalCounter : Initialise External IPs counter");
//update the new counter value for this externalIp
- for (ExternalIps externalIp : routers.nonnullExternalIps()) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps().values()) {
String[] ipSplit = externalIp.getIpAddress().split("/");
String extIp = ipSplit[0];
String extPrefix = Short.toString(NatConstants.DEFAULT_PREFIX);
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.NetworksKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.IpPortMapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.IntextIpProtocolType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.IntextIpProtocolTypeKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.intext.ip.protocol.type.IpPortMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.intext.ip.protocol.type.IpPortMapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.intext.ip.protocol.type.ip.port.map.IpPortExternal;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitchBuilder;
return;
}
Uint64 cookieSnatFlow = NatUtil.getCookieNaptFlow(routerId);
- List<IntextIpProtocolType> intextIpProtocolTypes = ipPortMapping.getIntextIpProtocolType();
- for (IntextIpProtocolType intextIpProtocolType : intextIpProtocolTypes) {
+ Map<IntextIpProtocolTypeKey, IntextIpProtocolType> keyIntextIpProtocolTypeMap
+ = ipPortMapping.getIntextIpProtocolType();
+ for (IntextIpProtocolType intextIpProtocolType : keyIntextIpProtocolTypeMap.values()) {
if (intextIpProtocolType.getIpPortMap() == null || intextIpProtocolType.getIpPortMap().isEmpty()) {
LOG.debug("removeSnatFlowsInOldNaptSwitch : No {} session associated to router {},"
+ "no flows need to be removed in oldNaptSwitch {}",
continue;
}
String protocol = intextIpProtocolType.getProtocol().name();
- List<IpPortMap> ipPortMaps = intextIpProtocolType.getIpPortMap();
- for (IpPortMap ipPortMap : ipPortMaps) {
+ Map<IpPortMapKey, IpPortMap> keyIpPortMapMap = intextIpProtocolType.getIpPortMap();
+ for (IpPortMap ipPortMap : keyIpPortMapMap.values()) {
String ipPortInternal = ipPortMap.getIpPortInternal();
String[] ipPortParts = ipPortInternal.split(":");
if (ipPortParts.length != 2) {
routerId);
return false;
}
- for (IntextIpProtocolType protocolType : ipPortMapping.getIntextIpProtocolType()) {
+ for (IntextIpProtocolType protocolType : ipPortMapping.getIntextIpProtocolType().values()) {
if (protocolType.getIpPortMap() == null || protocolType.getIpPortMap().isEmpty()) {
LOG.debug("handleNatFlowsInNewNaptSwitch : No {} session associated to router {}",
protocolType.getProtocol(), routerId);
return true;
}
- for (IpPortMap intIpPortMap : protocolType.getIpPortMap()) {
+ for (IpPortMap intIpPortMap : protocolType.getIpPortMap().values()) {
String internalIpAddress = intIpPortMap.getIpPortInternal().split(":")[0];
String intportnum = intIpPortMap.getIpPortInternal().split(":")[1];
LOG.debug("handleNatFlowsInNewNaptSwitch : Found Internal IP Address {} and Port Number {}",
*/
package org.opendaylight.netvirt.natservice.internal;
-import java.util.List;
+import java.util.Map;
import java.util.Objects;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.elan._interface.StaticMacEntries;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.elan._interface.StaticMacEntriesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.neutron.vip.states.VipState;
import org.slf4j.Logger;
return false;
}
- List<StaticMacEntries> staticMacEntries = elanInterface.getStaticMacEntries();
- if (null == staticMacEntries) {
+ Map<StaticMacEntriesKey, StaticMacEntries> keyStaticMacEntriesMap = elanInterface.getStaticMacEntries();
+ if (null == keyStaticMacEntriesMap) {
return false;
}
- for (StaticMacEntries staticMacEntry : staticMacEntries) {
+ for (StaticMacEntries staticMacEntry : keyStaticMacEntriesMap.values()) {
if (Objects.equals(staticMacEntry.getIpPrefix(), ip)) {
return true;
}
import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
NwConstants.L3_GW_MAC_TABLE, NwConstants.INBOUND_NAPT_TABLE, vpnId, macAddress, dpnId);
// Install the flow entry in L3_GW_MAC_TABLE
String flowRef = NatUtil.getFlowRef(dpnId, NwConstants.L3_GW_MAC_TABLE, vpnId, macAddress);
+ Map<InstructionKey, Instruction> customInstructionsMap = new HashMap<InstructionKey, Instruction>();
+ int instructionKey = 0;
+ for (Instruction instructionObj : customInstructions) {
+ customInstructionsMap.put(new InstructionKey(++instructionKey), instructionObj);
+ }
Flow l3GwMacTableFlowEntity = MDSALUtil.buildFlowNew(NwConstants.L3_GW_MAC_TABLE,
flowRef, 21, flowRef, 0, 0,
- NwConstants.COOKIE_L3_GW_MAC_TABLE, matchInfo, customInstructions);
+ NwConstants.COOKIE_L3_GW_MAC_TABLE, matchInfo, customInstructionsMap);
mdsalManager.addFlow(confTx, dpnId, l3GwMacTableFlowEntity);
LOG.debug("makeL3GwMacTableEntry : Successfully created flow entity {} on DPN = {}",
LOG.warn("remove : Interface {} is not a VPN Interface, ignoring.", interfaceName);
return;
}
- for (VpnInstanceNames vpnInterfaceVpnInstance : cfgVpnInterface.get().nonnullVpnInstanceNames()) {
+ for (VpnInstanceNames vpnInterfaceVpnInstance : cfgVpnInterface.get().nonnullVpnInstanceNames().values()) {
String vpnName = vpnInterfaceVpnInstance.getVpnName();
InstanceIdentifier<VpnInterfaceOpDataEntry> idOper = NatUtil
.getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnName);
LOG.warn("update : Interface {} is not a VPN Interface, ignoring.", interfaceName);
return;
}
- for (VpnInstanceNames vpnInterfaceVpnInstance : cfgVpnInterface.get().nonnullVpnInstanceNames()) {
+ for (VpnInstanceNames vpnInterfaceVpnInstance : cfgVpnInterface.get().nonnullVpnInstanceNames().values()) {
String vpnName = vpnInterfaceVpnInstance.getVpnName();
InstanceIdentifier<VpnInterfaceOpDataEntry> idOper = NatUtil
.getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnName);
.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, dpnRoutersListIdentifier);
if (optionalDpnRoutersList.isPresent()) {
- List<RoutersList> routersListFromDs = optionalDpnRoutersList.get()
- .getRoutersList();
+ List<RoutersList> routersListFromDs = new ArrayList<RoutersList>(optionalDpnRoutersList.get()
+ .getRoutersList().values());
routersListFromDs.forEach(router -> {
String routerName = router.getRouter();
Routers extRouters = NatUtil.getRoutersFromConfigDS(dataBroker, routerName);
+ "and port name {}", routerId, portName);
return Collections.emptyList();
}
- return port.get().nonnullInternalToExternalPortMap();
+ return new ArrayList<InternalToExternalPortMap>(port.get().nonnullInternalToExternalPortMap().values());
}
@SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
public void switchAddedToCache(SwitchInfo switchInfo) {
ExternalSubnets externalSubnets = NatUtil.getExternalSubnets(dataBroker);
if (externalSubnets != null) {
- for (Subnets externalSubnet : externalSubnets.getSubnets()) {
+ for (Subnets externalSubnet : externalSubnets.getSubnets().values()) {
Uuid externalNetworkUuid = externalSubnet.getExternalNetworkId();
String providerNet = NatUtil.getElanInstancePhysicalNetwok(externalNetworkUuid.getValue(),
dataBroker);
import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.annotation.PreDestroy;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.RouterPorts;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.router.ports.Ports;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.router.ports.PortsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.router.ports.ports.InternalToExternalPortMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.router.ports.ports.InternalToExternalPortMapKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.Uint32;
.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, dpnRoutersListId);
if (optionalRouterDpnList.isPresent()) {
- routersList = optionalRouterDpnList.get().getRoutersList();
+ routersList = new ArrayList<RoutersList>(optionalRouterDpnList.get().getRoutersList().values());
} else {
LOG.debug(
"NAT Service : RouterDpnList is empty for DPN {}. Hence ignoring TEP DEL event",
l3Vni = natOverVxlanUtil.getInternetVpnVni(vpnName, routerId);
}
}
- List<Ports> interfaces = routerPorts.getPorts();
- for (Ports port : interfaces) {
+ Map<PortsKey, Ports> interfacesMap = routerPorts.getPorts();
+ for (Ports port : interfacesMap.values()) {
//Get the DPN on which this interface resides
String interfaceName = port.getPortName();
Uint64 fipCfgdDpnId = NatUtil.getDpnForInterface(interfaceService, interfaceName);
continue;
}
isFipExists = Boolean.TRUE;
- List<InternalToExternalPortMap> intExtPortMapList = port.getInternalToExternalPortMap();
- for (InternalToExternalPortMap intExtPortMap : intExtPortMapList) {
+ Map<InternalToExternalPortMapKey, InternalToExternalPortMap> keyInternalToExternalPortMapMap
+ = port.getInternalToExternalPortMap();
+ for (InternalToExternalPortMap intExtPortMap : keyInternalToExternalPortMapMap.values()) {
String internalIp = intExtPortMap.getInternalIp();
String externalIp = intExtPortMap.getExternalIp();
externalIp = NatUtil.validateAndAddNetworkMask(externalIp);
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.annotation.PreDestroy;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.FibRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.dpn.routers.DpnRoutersList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.dpn.routers.dpn.routers.list.RoutersList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.dpn.routers.dpn.routers.list.RoutersListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig.NatMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
return false;
}
- List<RoutersList> routersList = optionalRouterDpnList.get().getRoutersList();
- if (routersList == null) {
+ Map<RoutersListKey, RoutersList> keyRoutersListMap = optionalRouterDpnList.get().getRoutersList();
+ if (keyRoutersListMap == null) {
LOG.debug("hndlTepAddForAllRtrs : Ignoring TEP add for the DPN {} since no routers are associated"
+ " for the DPN having the TUNNEL TYPE {} b/w SRC IP {} and DST IP {} and"
+ "TUNNEL NAME {} ", srcDpnId, tunnelType, srcTepIp, destTepIp, tunnelName);
}
String nextHopIp = NatUtil.getEndpointIpAddressForDPN(dataBroker, srcDpnId);
- for (RoutersList router : routersList) {
+ for (RoutersList router : keyRoutersListMap.values()) {
String routerName = router.getRouter();
Uint32 routerId = NatUtil.getVpnId(dataBroker, routerName);
if (routerId == NatConstants.INVALID_ID) {
l3Vni = natOverVxlanUtil.getInternetVpnVni(vpnName, routerId);
}
}
- for (Ports port : routerPorts.nonnullPorts()) {
+ for (Ports port : routerPorts.nonnullPorts().values()) {
//Get the DPN on which this interface resides
final String interfaceName = port.getPortName();
final Uint64 fipCfgdDpnId = NatUtil.getDpnForInterface(interfaceService, interfaceName);
tepAddedDpnId, fipCfgdDpnId, interfaceName);
continue;
}
- for (InternalToExternalPortMap intExtPortMap : port.nonnullInternalToExternalPortMap()) {
+ for (InternalToExternalPortMap intExtPortMap : port.nonnullInternalToExternalPortMap().values()) {
final String internalIp = intExtPortMap.getInternalIp();
final String externalIp = intExtPortMap.getExternalIp();
LOG.debug("hndlTepAddForDnatInEachRtr : DNAT -> Advertising the FIB route to the floating IP {} "
import static java.util.Collections.emptyList;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddresses;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddressesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExtRouters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalIpsCounter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalNetworks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.ips.counter.ExternalCounters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.ips.counter.ExternalCountersKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.ips.counter.external.counters.ExternalIpCounter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPortKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.router.interfaces.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.router.interfaces.InterfacesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMap;
LOG.error("getRouterIdfromVpnInstance : Router not found for vpn : {}", vpnName);
return null;
}
- List<Uuid> routerIdsList = NeutronUtils.getVpnMapRouterIdsListUuid(optionalVpnMap.get().getRouterIds());
+ List<Uuid> routerIdsList = NeutronUtils.getVpnMapRouterIdsListUuid(
+ new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602
+ .vpnmaps.vpnmap.RouterIds>(optionalVpnMap.get().getRouterIds().values()));
if (routerIdsList != null && !routerIdsList.isEmpty()) {
for (Uuid routerUuid : routerIdsList) {
InstanceIdentifier<Routers> id = buildRouterIdentifier(routerUuid.getValue());
SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
LogicalDatastoreType.CONFIGURATION, vpnMapsIdentifier);
if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().getVpnMap() != null) {
- for (VpnMap vpnMap : optionalVpnMaps.get().nonnullVpnMap()) {
+ for (VpnMap vpnMap : optionalVpnMaps.get().nonnullVpnMap().values()) {
if (routerId.equals(vpnMap.getVpnId().getValue())) {
continue;
}
- List<Uuid> routerIdsList = NeutronUtils.getVpnMapRouterIdsListUuid(vpnMap.getRouterIds());
+ List<Uuid> routerIdsList = NeutronUtils.getVpnMapRouterIdsListUuid(
+ new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602
+ .vpnmaps.vpnmap.RouterIds>(vpnMap.getRouterIds().values()));
if (routerIdsList.isEmpty()) {
continue;
}
// Ensure there are no duplicates
Collection<String> externalIps = new HashSet<>();
if (ipMappingOptional.isPresent()) {
- for (IpMap ipMap : ipMappingOptional.get().nonnullIpMap()) {
+ for (IpMap ipMap : ipMappingOptional.get().nonnullIpMap().values()) {
externalIps.add(ipMap.getExternalIp());
}
}
public static List<String> getExternalIpsForRouter(DataBroker dataBroker, String routerName) {
Routers routerData = NatUtil.getRoutersFromConfigDS(dataBroker, routerName);
if (routerData != null) {
- return NatUtil.getIpsListFromExternalIps(routerData.getExternalIps());
+ return NatUtil.getIpsListFromExternalIps(
+ new ArrayList<ExternalIps>(routerData.getExternalIps().values()));
}
return emptyList();
LogicalDatastoreType.OPERATIONAL, getIpMappingBuilder(routerId));
Map<String, Uint32> externalIpsLabel = new HashMap<>();
if (ipMappingOptional.isPresent()) {
- for (IpMap ipMap : ipMappingOptional.get().nonnullIpMap()) {
+ for (IpMap ipMap : ipMappingOptional.get().nonnullIpMap().values()) {
externalIpsLabel.put(ipMap.getExternalIp(), ipMap.getLabel());
}
}
if (externalCountersData.isPresent()) {
ExternalCounters externalCounter = externalCountersData.get();
short countOfLstLoadExtIp = 32767;
- for (ExternalIpCounter externalIpCounter : externalCounter.nonnullExternalIpCounter()) {
+ for (ExternalIpCounter externalIpCounter : externalCounter.nonnullExternalIpCounter().values()) {
String curExternalIp = externalIpCounter.getExternalIp();
short countOfCurExtIp = externalIpCounter.getCounter().toJava();
if (countOfCurExtIp < countOfLstLoadExtIp) {
LogicalDatastoreType.OPERATIONAL, id);
List<Uint64> dpns = new ArrayList<>();
if (routerDpnListData.isPresent()) {
- for (DpnVpninterfacesList dpnVpnInterface : routerDpnListData.get().nonnullDpnVpninterfacesList()) {
+ for (DpnVpninterfacesList dpnVpnInterface
+ : routerDpnListData.get().nonnullDpnVpninterfacesList().values()) {
dpns.add(dpnVpnInterface.getDpnId());
}
}
if (optionalDpnVpninterfacesList.isPresent()) {
LOG.debug("addToNeutronRouterDpnsMap : RouterDpnList already present for the Router {} and DPN {} for the "
+ "Interface {} in the ODL-L3VPN : NeutronRouterDpn map", routerName, dpId, interfaceName);
- operTx.merge(dpnVpnInterfacesListIdentifier
+ operTx.mergeParentStructureMerge(dpnVpnInterfacesListIdentifier
.child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router
.dpns.router.dpn.list.dpn.vpninterfaces.list.RouterInterfaces.class,
- new RouterInterfacesKey(interfaceName)), routerInterface, CREATE_MISSING_PARENTS);
+ new RouterInterfacesKey(interfaceName)), routerInterface);
} else {
LOG.debug("addToNeutronRouterDpnsMap : Building new RouterDpnList for the Router {} and DPN {} for the "
+ "Interface {} in the ODL-L3VPN : NeutronRouterDpn map", routerName, dpId, interfaceName);
routerInterfaces.add(routerInterface);
dpnVpnList.setRouterInterfaces(routerInterfaces);
routerDpnListBuilder.setDpnVpninterfacesList(Collections.singletonList(dpnVpnList.build()));
- operTx.merge(getRouterId(routerName), routerDpnListBuilder.build(), CREATE_MISSING_PARENTS);
+ operTx.mergeParentStructureMerge(getRouterId(routerName), routerDpnListBuilder.build());
}
}
if (optionalDpnRoutersList.isPresent()) {
RoutersList routersList = new RoutersListBuilder().withKey(new RoutersListKey(routerName))
.setRouter(routerName).build();
- List<RoutersList> routersListFromDs = optionalDpnRoutersList.get().nonnullRoutersList();
- if (!routersListFromDs.contains(routersList)) {
+ Map<RoutersListKey, RoutersList> keyroutersMapFromDs = optionalDpnRoutersList.get().nonnullRoutersList();
+ if (!keyroutersMapFromDs.values().contains(routersList)) {
LOG.debug("addToDpnRoutersMap : Router {} not present for the DPN {}"
+ " in the ODL-L3VPN : DPNRouters map", routerName, dpId);
- operTx.merge(dpnRoutersListIdentifier
- .child(RoutersList.class, new RoutersListKey(routerName)), routersList, CREATE_MISSING_PARENTS);
+ operTx.mergeParentStructureMerge(dpnRoutersListIdentifier
+ .child(RoutersList.class, new RoutersListKey(routerName)), routersList);
} else {
LOG.debug("addToDpnRoutersMap : Router {} already mapped to the DPN {} in the ODL-L3VPN : "
+ "DPNRouters map", routerName, dpId);
RoutersListBuilder routersListBuilder = new RoutersListBuilder();
routersListBuilder.setRouter(routerName);
dpnRoutersListBuilder.setRoutersList(Collections.singletonList(routersListBuilder.build()));
- operTx.merge(getDpnRoutersId(dpId), dpnRoutersListBuilder.build(), CREATE_MISSING_PARENTS);
+ operTx.mergeParentStructureMerge(getDpnRoutersId(dpId), dpnRoutersListBuilder.build());
}
}
if (optionalRouterDpnList.isPresent()) {
List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns
.router.dpn.list.dpn.vpninterfaces.list.RouterInterfaces> routerInterfaces =
- new ArrayList<>(optionalRouterDpnList.get().nonnullRouterInterfaces());
+ new ArrayList<>(optionalRouterDpnList.get().nonnullRouterInterfaces().values());
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns.router.dpn
.list.dpn.vpninterfaces.list.RouterInterfaces routerInterface =
new RouterInterfacesBuilder().withKey(new RouterInterfacesKey(vpnInterfaceName))
}
//Get the VM interfaces for the router on the current DPN only.
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces
- .map.router.interfaces.Interfaces> vmInterfaces = routerInterfacesData.get().getInterfaces();
- if (vmInterfaces == null) {
+ Map<InterfacesKey, Interfaces> vmInterfacesMap
+ = routerInterfacesData.get().getInterfaces();
+ if (vmInterfacesMap == null) {
LOG.debug("removeFromDpnRoutersMap : VM interfaces are not present for the router {} in the "
+ "NeutronVPN - router-interfaces-map", routerName);
return;
// If the removed VPN interface is the only interface through which the router is connected to the DPN,
// then remove RouterList.
for (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map
- .router.interfaces.Interfaces vmInterface : vmInterfaces) {
+ .router.interfaces.Interfaces vmInterface : vmInterfacesMap.values()) {
String vmInterfaceName = vmInterface.getInterfaceId();
Uint64 vmDpnId = getDpnForInterface(ifaceMgrRpcService, vmInterfaceName);
if (vmDpnId.equals(Uint64.ZERO) || !vmDpnId.equals(curDpnId)) {
LOG.error("getEgressActionsForTunnels : RPC Call to Get egress actions for Tunnels {} "
+ "returned with Errors {}", ifName, rpcResult.getErrors());
} else {
- actions = rpcResult.getResult().nonnullAction();
+ actions = new ArrayList<Action>(rpcResult.getResult().nonnullAction().values());
}
} else {
RpcResult<GetEgressActionsForInterfaceOutput> rpcResult =
LOG.error("getEgressActionsForInterface : RPC Call to Get egress actions for interface {} "
+ "returned with Errors {}", ifName, rpcResult.getErrors());
} else {
- actions = rpcResult.getResult().nonnullAction();
+ actions = new ArrayList<Action>(rpcResult.getResult().nonnullAction().values());
}
}
List<ActionInfo> listActionInfo = new ArrayList<>();
return emptyList();
}
- return portsOptional.get().getPort();
+ return new ArrayList<Port>(portsOptional.get().getPort().values());
}
@Nullable
for (Port port : ports) {
if (deviceType.equals(port.getDeviceOwner()) && port.getFixedIps() != null) {
- for (FixedIps ip : port.getFixedIps()) {
+ for (FixedIps ip : port.getFixedIps().values()) {
if (Objects.equals(ip.getIpAddress(), targetIP)) {
return port;
}
LOG.error("getSubnetIdForFloatingIp : port is null");
return null;
}
- for (FixedIps ip : port.nonnullFixedIps()) {
+ for (FixedIps ip : port.nonnullFixedIps().values()) {
if (Objects.equals(ip.getIpAddress(), targetIP)) {
return ip.getSubnetId();
}
@NonNull
public static List<Ports> getFloatingIpPortsForRouter(DataBroker broker, Uuid routerUuid) {
InstanceIdentifier<RouterPorts> routerPortsIdentifier = getRouterPortsId(routerUuid.getValue());
- List<Ports> portsList = SingleTransactionDataBroker
+ List<Ports> portsList = new ArrayList<Ports>(SingleTransactionDataBroker
.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, LogicalDatastoreType.CONFIGURATION,
- routerPortsIdentifier).map(RouterPorts::getPorts).orElse(emptyList());
+ routerPortsIdentifier).map(RouterPorts::getPorts).orElse(Collections.emptyMap()).values());
+
if (!portsList.isEmpty()) {
portsList = new ArrayList<>(portsList);
}
SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
LogicalDatastoreType.CONFIGURATION, externalNwIdentifier);
if (externalNwData.isPresent()) {
- for (Networks externalNw : externalNwData.get().nonnullNetworks()) {
+ for (Networks externalNw : externalNwData.get().nonnullNetworks().values()) {
if (externalNw.getVpnid() != null && externalNw.getVpnid().equals(vpnUuid)) {
@Nullable List<Uuid> routerIds = externalNw.getRouterIds();
return routerIds != null ? new ArrayList<>(routerIds) : emptyList();
SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, id);
if (routerData.isPresent()) {
- return NatUtil.getExternalSubnetIdsFromExternalIps(routerData.get().getExternalIps());
+ return NatUtil.getExternalSubnetIdsFromExternalIps(
+ new ArrayList<ExternalIps>(routerData.get().getExternalIps().values()));
} else {
LOG.warn("getExternalSubnetIdsForRouter : No external router data for router {}", routerName);
return Collections.emptySet();
@Nullable
protected static Uuid getExternalSubnetForRouterExternalIp(String externalIpAddress, Routers router) {
externalIpAddress = validateAndAddNetworkMask(externalIpAddress);
- for (ExternalIps extIp : router.nonnullExternalIps()) {
+ for (ExternalIps extIp : router.nonnullExternalIps().values()) {
String extIpString = validateAndAddNetworkMask(extIp.getIpAddress());
if (extIpString.equals(externalIpAddress)) {
return extIp.getSubnetId();
LOG.debug("makePreDnatToSnatTableEntry : Create Pre-DNAT table {} --> table {} flow on NAPT DpnId {} ",
NwConstants.PDNAT_TABLE, tableId, naptDpnId);
- List<Instruction> preDnatToSnatInstructions = new ArrayList<>();
- preDnatToSnatInstructions.add(new InstructionGotoTable(tableId).buildInstruction(0));
+ Map<InstructionKey, Instruction> preDnatToSnatInstructionsMap = new HashMap<InstructionKey, Instruction>();
+ preDnatToSnatInstructionsMap.put(new InstructionKey(0),
+ new InstructionGotoTable(tableId).buildInstruction(0));
List<MatchInfo> matches = new ArrayList<>();
matches.add(MatchEthernetType.IPV4);
String flowRef = getFlowRefPreDnatToSnat(naptDpnId, NwConstants.PDNAT_TABLE, "PreDNATToSNAT");
Flow preDnatToSnatTableFlowEntity = MDSALUtil.buildFlowNew(NwConstants.PDNAT_TABLE,flowRef,
5, flowRef, 0, 0, NwConstants.COOKIE_DNAT_TABLE,
- matches, preDnatToSnatInstructions);
+ matches, preDnatToSnatInstructionsMap);
mdsalManager.addFlow(confTx, naptDpnId, preDnatToSnatTableFlowEntity);
LOG.debug("makePreDnatToSnatTableEntry : Successfully installed Pre-DNAT flow {} on NAPT DpnId {} ",
LOG.debug("isFloatingIpPresentForDpn : vpn-to-dpn-list is not empty for vpnName {}, dpn id {}, "
+ "rd {} and floatingIp {}", vpnName, dpnId, rd, externalIp);
try {
- List<IpAddresses> ipAddressList = dpnInVpn.get().getIpAddresses();
- if (ipAddressList != null && !ipAddressList.isEmpty()) {
+ Map<IpAddressesKey, IpAddresses> keyIpAddressesMap = dpnInVpn.get().getIpAddresses();
+ if (keyIpAddressesMap != null && !keyIpAddressesMap.isEmpty()) {
int floatingIpPresentCount = 0;
- for (IpAddresses ipAddress: ipAddressList) {
+ for (IpAddresses ipAddress: keyIpAddressesMap.values()) {
if (!Objects.equals(ipAddress.getIpAddress(), externalIp)
&& IpAddresses.IpAddressSource.FloatingIP.equals(ipAddress.getIpAddressSource())) {
floatingIpPresentCount++;
public static void installRouterGwFlows(ManagedNewTransactionRunner txRunner, IVpnManager vpnManager,
Routers router, Uint64 primarySwitchId, int addOrRemove) {
ListenableFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
- List<ExternalIps> externalIps = router.getExternalIps();
+ Map<ExternalIpsKey, ExternalIps> keyExternalIpsMap = router.getExternalIps();
List<String> externalIpsSting = new ArrayList<>();
- if (externalIps == null || externalIps.isEmpty()) {
+ if (keyExternalIpsMap == null || keyExternalIpsMap.isEmpty()) {
LOG.error("installRouterGwFlows: setupRouterGwFlows no externalIP present");
return;
}
- for (ExternalIps externalIp : externalIps) {
+ for (ExternalIps externalIp : keyExternalIpsMap.values()) {
externalIpsSting.add(externalIp.getIpAddress());
}
- Uuid subnetVpnName = externalIps.get(0).getSubnetId();
+ Uuid subnetVpnName = keyExternalIpsMap.get(0).getSubnetId();
if (addOrRemove == NwConstants.ADD_FLOW) {
vpnManager.addRouterGwMacFlow(router.getRouterName(), router.getExtGwMacAddress(), primarySwitchId,
router.getNetworkId(), subnetVpnName.getValue(), tx);
}
if (ovsdbNode != null && ovsdbNode.getOpenvswitchOtherConfigs() != null) {
- for (OpenvswitchOtherConfigs openvswitchOtherConfigs : ovsdbNode.getOpenvswitchOtherConfigs()) {
+ for (OpenvswitchOtherConfigs openvswitchOtherConfigs : ovsdbNode.getOpenvswitchOtherConfigs().values()) {
if (Objects.equals(openvswitchOtherConfigs.getOtherConfigKey(), key)) {
return openvswitchOtherConfigs.getOtherConfigValue();
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
Uuid vpnUuid = vpnMap.getVpnId();
String vpnName = vpnUuid.getValue();
if (vpnMap.getRouterIds() != null) {
- vpnMap.getRouterIds().stream()
+ vpnMap.getRouterIds().values().stream()
.filter(router -> !(Objects.equals(router.getRouterId(), vpnUuid)))
.forEach(router -> {
String routerName = router.getRouterId().getValue();
Uuid vpnUuid = vpnMap.getVpnId();
String vpnName = vpnUuid.getValue();
if (vpnMap.getRouterIds() != null) {
- vpnMap.getRouterIds().stream()
+ vpnMap.getRouterIds().values().stream()
.filter(router -> !(Objects.equals(router.getRouterId(), vpnUuid)))
.forEach(router -> {
String routerName = router.getRouterId().getValue();
Uuid vpnUuid = updated.getVpnId();
String vpnName = vpnUuid.getValue();
- List<RouterIds> updatedRouterIdList = updated.getRouterIds();
- List<RouterIds> originalRouterIdList = original.getRouterIds();
+ List<RouterIds> updatedRouterIdList = new ArrayList<RouterIds>(updated.getRouterIds().values());
+ List<RouterIds> originalRouterIdList = new ArrayList<RouterIds>(original.getRouterIds().values());
List<RouterIds> routersAddedList = null;
List<RouterIds> routersRemovedList = null;
return;
}
Uuid networkId = Uuid.getDefaultInstance(externalNetwork);
- for (Ports port : optRouterPorts.get().nonnullPorts()) {
+ for (Ports port : optRouterPorts.get().nonnullPorts().values()) {
String portName = port.getPortName();
Uint64 dpnId = NatUtil.getDpnForInterface(interfaceManager, portName);
if (dpnId.equals(Uint64.ZERO)) {
continue;
}
- for (InternalToExternalPortMap intExtPortMap : port.nonnullInternalToExternalPortMap()) {
+ for (InternalToExternalPortMap intExtPortMap : port.nonnullInternalToExternalPortMap().values()) {
//remove all NAT related entries with routerName
//floatingIpListener.removeNATOnlyFlowEntries(dpnId, portName, routerName, null,
// intExtPortMap.getInternalIp(), externalIp);
return;
}
Uuid networkId = Uuid.getDefaultInstance(externalNetwork);
- for (Ports port : optRouterPorts.get().nonnullPorts()) {
+ for (Ports port : optRouterPorts.get().nonnullPorts().values()) {
String portName = port.getPortName();
Uint64 dpnId = NatUtil.getDpnForInterface(interfaceManager, portName);
if (dpnId.equals(Uint64.ZERO)) {
+ "skip handling of router {} association with vpn {}", portName, routerName, vpnName);
continue;
}
- for (InternalToExternalPortMap intExtPortMap : port.nonnullInternalToExternalPortMap()) {
+ for (InternalToExternalPortMap intExtPortMap : port.nonnullInternalToExternalPortMap().values()) {
//remove all NAT related entries with routerName
//floatingIpListener.removeNATOnlyFlowEntries(dpnId, portName, routerName, vpnName,
// intExtPortMap.getInternalIp(), externalIp);
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Optional;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig.NatMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + networkId, () -> {
extNetGroupInstaller.installExtNetGroupEntries(networkId, dpnId);
installDefaultNatRouteForRouterExternalSubnets(dpnId,
- NatUtil.getExternalSubnetIdsFromExternalIps(router.getExternalIps()));
+ NatUtil.getExternalSubnetIdsFromExternalIps(
+ new ArrayList<ExternalIps>(router.getExternalIps().values())));
return Collections.emptyList();
});
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import java.util.Collections;
-import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.serviceutils.upgrade.rev180702.UpgradeConfig;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
if (original.isUpgradeInProgress() && !updated.isUpgradeInProgress()) {
Optional<NaptSwitches> npatSwitches = NatUtil.getAllPrimaryNaptSwitches(dataBroker);
if (npatSwitches.isPresent()) {
- for (RouterToNaptSwitch routerToNaptSwitch : npatSwitches.get().nonnullRouterToNaptSwitch()) {
+ for (RouterToNaptSwitch routerToNaptSwitch
+ : npatSwitches.get().nonnullRouterToNaptSwitch().values()) {
Uint64 primaryNaptDpnId = routerToNaptSwitch.getPrimarySwitchId();
if (!NatUtil.getSwitchStatus(dataBroker, routerToNaptSwitch.getPrimarySwitchId())) {
String routerUuid = routerToNaptSwitch.getRouterName();
return;
}
- for (Routers router : routers.nonnullRouters()) {
- List<ExternalIps> externalIps = router.getExternalIps();
- if (router.isEnableSnat() && externalIps != null && !externalIps.isEmpty()) {
+ for (Routers router : routers.nonnullRouters().values()) {
+ Map<ExternalIpsKey, ExternalIps> keyExternalIpsMap = router.getExternalIps();
+ if (router.isEnableSnat() && keyExternalIpsMap != null && !keyExternalIpsMap.isEmpty()) {
centralizedSwitchScheduler.scheduleCentralizedSwitch(router);
}
}
public FluentFuture<Void> writeVipState(VipState vipState) {
return txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
- tx.put(InstanceIdentifier.builder(NeutronVipStates.class)
+ tx.mergeParentStructurePut(InstanceIdentifier.builder(NeutronVipStates.class)
.child(VipState.class, vipState.key()).build(),
- vipState, true);
+ vipState);
});
}
}
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInputBuilder;
} else {
mkMatches.add(new MatchTunnelId(Uint64.valueOf(serviceId)));
}
-
+ Map<InstructionKey, Instruction> customInstructionsMap = new HashMap<InstructionKey, Instruction>();
+ int instructionKey = 0;
+ for (Instruction instructionObj : customInstructions) {
+ customInstructionsMap.put(new InstructionKey(++instructionKey), instructionObj);
+ }
Flow terminatingServiceTableFlowEntity = MDSALUtil.buildFlowNew(NwConstants.INTERNAL_TUNNEL_TABLE,
getFlowRef(dpnId, NwConstants.INTERNAL_TUNNEL_TABLE, serviceId, ""), flowPriority,
String.format("%s:%s", "TST Flow Entry ", serviceId),
0, 0, Uint64.valueOf(COOKIE_TUNNEL.add(BigInteger.valueOf(serviceId.longValue()))),
- mkMatches, customInstructions);
+ mkMatches, customInstructionsMap);
mdsalManager.addFlow(confTx, dpnId, terminatingServiceTableFlowEntity);
}
matches.add(MatchEthernetType.MPLS_UNICAST);
matches.add(new MatchMplsLabel(serviceId.longValue()));
- List<Instruction> instructions = new ArrayList<>();
+ Map<InstructionKey, Instruction> instructionMap = new HashMap<InstructionKey, Instruction>();
+ int instructionKey = 0;
List<ActionInfo> actionsInfos = new ArrayList<>();
//NAT is required for IPv4 only. Hence always etherType will be IPv4
actionsInfos.add(new ActionPopMpls(NwConstants.ETHTYPE_IPV4));
actionsInfos.add(new ActionSetFieldEthernetDestination(new MacAddress(floatingIpPortMacAddress)));
Instruction writeInstruction = new InstructionApplyActions(actionsInfos).buildInstruction(0);
- instructions.add(writeInstruction);
- instructions.add(new InstructionGotoTable(tableId).buildInstruction(1));
+ instructionMap.put(new InstructionKey(++instructionKey), writeInstruction);
+ instructionMap.put(new InstructionKey(++instructionKey),
+ new InstructionGotoTable(tableId).buildInstruction(1));
// Install the flow entry in L3_LFIB_TABLE
String flowRef = getFlowRef(dpId, NwConstants.L3_LFIB_TABLE, serviceId, "");
Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.L3_LFIB_TABLE, flowRef,
10, flowRef, 0, 0,
- NwConstants.COOKIE_VM_LFIB_TABLE, matches, instructions);
+ NwConstants.COOKIE_VM_LFIB_TABLE, matches, instructionMap);
mdsalManager.addFlow(confTx, dpId, flowEntity);
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.types.rev160517.IpPrefixOrAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.action.rev140421.NxActionNatFlags;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.action.rev140421.NxActionNatRangePresent;
Uint32 extNetVpnId = NatUtil.getVpnId(dataBroker, vpnUuid.getValue());
LOG.info("installSnatSpecificEntriesForNaptSwitch: external network vpn_id {} for router {}",
extNetVpnId, routers.getRouterName());
- List<ExternalIps> externalIps = routers.getExternalIps();
+ Map<ExternalIpsKey, ExternalIps> keyExternalIpsMap = routers.getExternalIps();
addOutboundTblTrackEntryForVxlanGre(confTx, dpnId, routerId, extNetVpnId);
- addOutboundTblEntryForVxlanGre(confTx, dpnId, routerId, extNetVpnId, externalIps, elanId);
+ addOutboundTblEntryForVxlanGre(confTx, dpnId, routerId, extNetVpnId,
+ new ArrayList<ExternalIps>(keyExternalIpsMap.values()), elanId);
addNaptPfibFlowForVxlanGre(confTx, routers, dpnId, extNetVpnId);
addNaptPfibEntry(confTx, dpnId, routerId);
//Install Inbound NAT entries
- addInboundEntryForVxlanGre(confTx, dpnId, routerId, extNetVpnId, externalIps, elanId);
- if (externalIps.isEmpty()) {
+ addInboundEntryForVxlanGre(confTx, dpnId, routerId, extNetVpnId,
+ new ArrayList<ExternalIps>(keyExternalIpsMap.values()), elanId);
+ if (keyExternalIpsMap.isEmpty()) {
LOG.error("installSnatSpecificEntriesForNaptSwitch: No externalIP present for router {}",
routerName);
return;
}
//The logic now handle only one external IP per router, others if present will be ignored.
- String externalIp = NatUtil.validateAndAddNetworkMask(externalIps.get(0).getIpAddress());
+ String externalIp = NatUtil.validateAndAddNetworkMask(
+ new ArrayList<ExternalIps>(keyExternalIpsMap.values()).get(0).getIpAddress());
externalRouterListener.handleSnatReverseTraffic(confTx, dpnId, routers, routerId, routerName, externalIp);
}
Uint32 extNetVpnId = NatUtil.getVpnId(dataBroker, vpnUuid.getValue());
LOG.info("installSnatSpecificEntriesForNaptSwitch: external network vpn_id {} for router {}",
extNetVpnId, routers.getRouterName());
- List<ExternalIps> externalIps = routers.getExternalIps();
+ Map<ExternalIpsKey, ExternalIps> keyExternalIpsMap = routers.getExternalIps();
removeOutboundTblTrackEntryForVxlanGre(confTx, dpnId, routerId);
- removeOutboundTblEntryForVxlanGre(confTx, dpnId, routerId, externalIps);
+ removeOutboundTblEntryForVxlanGre(confTx, dpnId, routerId,
+ new ArrayList<ExternalIps>(keyExternalIpsMap.values()));
removeNaptPfibFlowForVxlanGre(confTx, routers, dpnId, extNetVpnId);
removeNaptPfibEntry(confTx, dpnId, routerId);
//Install Inbound NAT entries
- removeInboundEntryForVxlanGre(confTx, dpnId, routerId, externalIps);
- if (externalIps.isEmpty()) {
+ removeInboundEntryForVxlanGre(confTx, dpnId, routerId, new ArrayList<ExternalIps>(keyExternalIpsMap.values()));
+ if (keyExternalIpsMap.isEmpty()) {
LOG.error("installSnatSpecificEntriesForNaptSwitch: No externalIP present for router {}",
routerName);
return;
}
//The logic now handle only one external IP per router, others if present will be ignored.
- String externalIp = NatUtil.validateAndAddNetworkMask(externalIps.get(0).getIpAddress());
+ String externalIp = NatUtil.validateAndAddNetworkMask(
+ new ArrayList<ExternalIps>(keyExternalIpsMap.values()).get(0).getIpAddress());
externalRouterListener.clearFibTsAndReverseTraffic(dpnId, routerId, routers.getNetworkId(),
Collections.singletonList(externalIp), null, routers.getExtGwMacAddress(), confTx);
}
outerloop:
for (Uuid subnetUuid: subnetUuidList) {
subNet = nvpnManager.getNeutronSubnet(subnetUuid);
- for (AllocationPools allocationPool : subNet.nonnullAllocationPools()) {
+ for (AllocationPools allocationPool : subNet.nonnullAllocationPools().values()) {
if (NatUtil.isIpInSubnet(ipAddress,
allocationPool.getStart().stringValue(),
allocationPool.getEnd().stringValue())) {
LOG.warn("getNatTranslationsForNetworkAndIpaddress : No DNAT IP Mapping found for IP {}", ipAddress);
} else {
for (Ports fipPort : fipPorts) {
- for (InternalToExternalPortMap fipMap : fipPort.nonnullInternalToExternalPortMap()) {
+ for (InternalToExternalPortMap fipMap : fipPort.nonnullInternalToExternalPortMap().values()) {
if (fipMap.getInternalIp().equals(ipAddress)) {
output = new GetNatTranslationsForNetworkAndIpaddressOutputBuilder()
.setExternalIp(fipMap.getExternalIp())
if (ipPortMapping == null) {
LOG.warn("getNatTranslationsForNetworkAndIpaddress : No SNAT IP Mapping found for IP {}", ipAddress);
} else {
- for (IntextIpProtocolType protocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
- for (IpPortMap ipPortMap : protocolType.nonnullIpPortMap()) {
+ for (IntextIpProtocolType protocolType : ipPortMapping.nonnullIntextIpProtocolType().values()) {
+ for (IpPortMap ipPortMap : protocolType.nonnullIpPortMap().values()) {
String[] internalIpPort = ipPortMap.getIpPortInternal().split(NwConstants.MACADDR_SEP);
if (ipAddress.equals(internalIpPort[0])) {
// Capturing SNAT information
List<SnatIpMapping> snatIpMapping = new ArrayList<>();
- for (IntextIpProtocolType protocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
- for (IpPortMap ipPortMap : protocolType.nonnullIpPortMap()) {
+ for (IntextIpProtocolType protocolType : ipPortMapping.nonnullIntextIpProtocolType().values()) {
+ for (IpPortMap ipPortMap : protocolType.nonnullIpPortMap().values()) {
String[] internalPortMap = ipPortMap.getIpPortInternal().split(NwConstants.MACADDR_SEP);
SnatIpMappingBuilder natIpMappingBuilder = new SnatIpMappingBuilder()
.setInternalIp(internalPortMap[0]).setInternalPort(internalPortMap[1])
LOG.warn("constructNatInformation : No DNAT IP Mapping found for router-uuid {}", routerUuid.getValue());
} else {
for (Ports fipPort : fipPorts) {
- for (InternalToExternalPortMap fipMap : fipPort.nonnullInternalToExternalPortMap()) {
+ for (InternalToExternalPortMap fipMap : fipPort.nonnullInternalToExternalPortMap().values()) {
DnatIpMappingBuilder natIpMappingBuilder = new DnatIpMappingBuilder()
.setExternalIp(fipMap.getExternalIp()).setInternalIp(fipMap.getInternalIp());
dnatIpMapping.add(natIpMappingBuilder.build());
import org.junit.Test;
import org.opendaylight.genius.mdsalutil.FlowEntityBuilder;
import org.opendaylight.netvirt.natservice.internal.NatUtil;
-
import org.opendaylight.yangtools.yang.common.Uint64;
public class NatUtilTest {
<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.concurrent.ConcurrentMap;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelIps;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
+import java.util.Map;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.provider.ext.rev150712.NetworkProviderExtension;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.provider.ext.rev150712.neutron.networks.network.Segments;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.provider.ext.rev150712.neutron.networks.network.SegmentsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
if (providerExtension != null) {
segmentationId = providerExtension.getSegmentationId();
if (segmentationId == null) {
- List<Segments> providerSegments = providerExtension.getSegments();
- if (providerSegments != null && providerSegments.size() > 0) {
- for (Segments providerSegment: providerSegments) {
+ Map<SegmentsKey, Segments> providerSegmentsMap = providerExtension.getSegments();
+ if (providerSegmentsMap != null && providerSegmentsMap.size() > 0) {
+ for (Segments providerSegment: providerSegmentsMap.values()) {
if (isNetworkSegmentType(providerSegment, networkType)) {
segmentationId = providerSegment.getSegmentationId();
break;
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
import edu.umd.cs.findbugs.annotations.CheckReturnValue;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
}
if (fixedNeutronPortName != null) {
List<Ports> portsList = routerPortsBuilder.getPorts() != null
- ? new ArrayList<>(routerPortsBuilder.getPorts()) : new ArrayList<>();
+ ? new ArrayList<Ports>(routerPortsBuilder.getPorts().values()) : new ArrayList<Ports>();
PortsBuilder fixedNeutronPortBuilder = null;
for (Ports neutronPort : portsList) {
if (neutronPort.getPortName().equals(fixedNeutronPortName)) {
.setPortName(fixedNeutronPortName);
}
if (fixedIpAddress != null) {
- List<InternalToExternalPortMap> intExtPortMapList = fixedNeutronPortBuilder
- .getInternalToExternalPortMap();
+ List<InternalToExternalPortMap> intExtPortMapList
+ = new ArrayList<InternalToExternalPortMap>(fixedNeutronPortBuilder
+ .getInternalToExternalPortMap().values());
if (intExtPortMapList == null) {
intExtPortMapList = new ArrayList<>();
}
routerPortsIdentifierBuilder.build());
if (optionalRouterPorts.isPresent()) {
RouterPorts routerPorts = optionalRouterPorts.get();
- List<Ports> portsList = routerPorts.nonnullPorts();
- List<InternalToExternalPortMap> intExtPortMap = new ArrayList<>();
- for (Ports ports : portsList) {
+ Map<PortsKey, Ports> keyPortsMap = routerPorts.nonnullPorts();
+ Map<InternalToExternalPortMapKey, InternalToExternalPortMap> keyInternalToExternalPortMapMap
+ = new HashMap<InternalToExternalPortMapKey, InternalToExternalPortMap>();
+ for (Ports ports : keyPortsMap.values()) {
if (Objects.equals(ports.getPortName(), fixedNeutronPortName)) {
- intExtPortMap = ports.nonnullInternalToExternalPortMap();
+ keyInternalToExternalPortMapMap = ports.nonnullInternalToExternalPortMap();
break;
}
}
- if (intExtPortMap.size() == 1) {
- removeRouterPortsOrPortsNode(routerName, routerPortsIdentifierBuilder, portsList,
- fixedNeutronPortName);
+ if (keyInternalToExternalPortMapMap.size() == 1) {
+ removeRouterPortsOrPortsNode(routerName, routerPortsIdentifierBuilder,
+ new ArrayList<Ports>(keyPortsMap.values()), fixedNeutronPortName);
} else {
- for (InternalToExternalPortMap intToExtMap : intExtPortMap) {
+ for (InternalToExternalPortMap intToExtMap : keyInternalToExternalPortMapMap.values()) {
if (Objects.equals(intToExtMap.getInternalIp(), fixedIpAddress)) {
InstanceIdentifier<InternalToExternalPortMap> intExtPortMapIdentifier =
routerPortsIdentifierBuilder.child(Ports
}
// remove particular internal-to-external-port-map
- LOG.debug("removing particular internal-to-external-port-map {}", intExtPortMap);
+ LOG.debug("removing particular internal-to-external-port-map {}",
+ keyInternalToExternalPortMapMap);
try {
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION,
intExtPortMapIdentifier);
} catch (Exception e) {
- LOG.error("Failure in deletion of internal-to-external-port-map {}", intExtPortMap,
- e);
+ LOG.error("Failure in deletion of internal-to-external-port-map {}",
+ keyInternalToExternalPortMapMap, e);
}
}
}
SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
floatingIpInfoIdentifierBuilder.build());
if (optionalFloatingIPInfo.isPresent()) {
- List<RouterPorts> routerPortsList = optionalFloatingIPInfo.get().getRouterPorts();
- if (routerPortsList != null && !routerPortsList.isEmpty()) {
- for (RouterPorts routerPorts : routerPortsList) {
- List<Ports> portsList = routerPorts.getPorts();
- if (portsList != null && !portsList.isEmpty()) {
- for (Ports ports : portsList) {
+ Map<RouterPortsKey, RouterPorts> keyRouterPortsMap = optionalFloatingIPInfo.get().getRouterPorts();
+ if (keyRouterPortsMap != null && !keyRouterPortsMap.isEmpty()) {
+ for (RouterPorts routerPorts : keyRouterPortsMap.values()) {
+ Map<PortsKey, Ports> keyPortsMap = routerPorts.getPorts();
+ if (keyPortsMap != null && !keyPortsMap.isEmpty()) {
+ for (Ports ports : keyPortsMap.values()) {
if (Objects.equals(ports.getPortName(), fixedNeutronPortName)) {
String routerName = routerPorts.getRouterId();
InstanceIdentifier.InstanceIdentifierBuilder<RouterPorts>
routerPortsIdentifierBuilder = floatingIpInfoIdentifierBuilder
.child(RouterPorts.class, new RouterPortsKey(routerName));
- removeRouterPortsOrPortsNode(routerName, routerPortsIdentifierBuilder, portsList,
- fixedNeutronPortName);
+ removeRouterPortsOrPortsNode(routerName, routerPortsIdentifierBuilder,
+ new ArrayList<Ports>(keyPortsMap.values()), fixedNeutronPortName);
LOG.debug("Deletion from FloatingIpInfo DS successful for fixedIP neutron port {} ",
fixedNeutronPortName);
break;
Map<String, String> config = new HashMap<>();
OvsdbNodeAugmentation ovsdbNode = getOvsdbNodeAugmentation(node);
if (ovsdbNode != null && ovsdbNode.getOpenvswitchExternalIds() != null) {
- for (OpenvswitchExternalIds openvswitchExternalIds : ovsdbNode.getOpenvswitchExternalIds()) {
+ for (OpenvswitchExternalIds openvswitchExternalIds : ovsdbNode.getOpenvswitchExternalIds().values()) {
if (openvswitchExternalIds.getExternalIdKey() != null && openvswitchExternalIds.getExternalIdKey()
.startsWith(OS_HOST_CONFIG_CONFIG_KEY_PREFIX)) {
// Extract the host type. Max 8 characters after
private String getExternalId(Node node, String key) {
OvsdbNodeAugmentation ovsdbNode = getOvsdbNodeAugmentation(node);
if (ovsdbNode != null && ovsdbNode.getOpenvswitchExternalIds() != null) {
- for (OpenvswitchExternalIds openvswitchExternalIds : ovsdbNode.getOpenvswitchExternalIds()) {
+ for (OpenvswitchExternalIds openvswitchExternalIds : ovsdbNode.getOpenvswitchExternalIds().values()) {
if (key.equals(openvswitchExternalIds.getExternalIdKey())) {
return openvswitchExternalIds.getExternalIdValue();
}
if (providerExtension == null || providerExtension.getSegments() == null) {
return Collections.emptyList();
}
- return providerExtension.getSegments().stream()
+ return providerExtension.getSegments().values().stream()
.map(segment -> new ElanSegmentsBuilder()
.setSegmentationIndex(segment.getSegmentationIndex())
.setSegmentationId(getSegmentationId(input, segment))
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
handleFloatingIpPortUpdated(original, update);
}
} else {
- Set<FixedIps> oldIPs = getFixedIpSet(original.getFixedIps());
- Set<FixedIps> newIPs = getFixedIpSet(update.getFixedIps());
+ Set<FixedIps> oldIPs = getFixedIpSet(new ArrayList<FixedIps>(original.getFixedIps().values()));
+ Set<FixedIps> newIPs = getFixedIpSet(new ArrayList<FixedIps>(update.getFixedIps().values()));
if (!oldIPs.equals(newIPs)) {
handleNeutronPortUpdated(original, update);
}
updatedSecurityEnabled, interfaceBuilder).build();
interfaceBuilder.addAugmentation(InterfaceAcl.class, infAcl);
} else if (isDhcpServerPort) {
- Set<FixedIps> oldIPs = getFixedIpSet(original.getFixedIps());
- Set<FixedIps> newIPs = getFixedIpSet(update.getFixedIps());
+ Set<FixedIps> oldIPs = getFixedIpSet(
+ new ArrayList<FixedIps>(original.getFixedIps().values()));
+ Set<FixedIps> newIPs = getFixedIpSet(
+ new ArrayList<FixedIps>(update.getFixedIps().values()));
if (!oldIPs.equals(newIPs)) {
InterfaceAcl infAcl = neutronvpnUtils.getDhcpInterfaceAcl(update);
interfaceBuilder.addAugmentation(InterfaceAcl.class, infAcl);
&& !NeutronConstants.FLOATING_IP_DEVICE_ID_PENDING.equals(update.getDeviceId())) {
// populate floating-ip uuid and floating-ip port attributes (uuid, mac and subnet id for the ONLY
// fixed IP) to be used by NAT, depopulated in NATService once mac is retrieved in the removal path
- addToFloatingIpPortInfo(new Uuid(update.getDeviceId()), update.getUuid(), update.getFixedIps().get(0)
+ addToFloatingIpPortInfo(new Uuid(update.getDeviceId()), update.getUuid(),
+ new ArrayList<FixedIps>(update.getFixedIps().values()).get(0)
.getSubnetId(), update.getMacAddress().getValue());
elanService.addKnownL3DmacAddress(update.getMacAddress().getValue(), update.getNetworkId().getValue());
}
Uuid internetVpnId = neutronvpnUtils.getInternetvpnUuidBoundToRouterId(routerId);
List<Subnetmap> subnetMapList = new ArrayList<>();
boolean portIsIpv6 = false;
- for (FixedIps portIP : routerPort.nonnullFixedIps()) {
+ for (FixedIps portIP : routerPort.nonnullFixedIps().values()) {
// NOTE: Please donot change the order of calls to updateSubnetNodeWithFixedIP
// and addSubnetToVpn here
if (internetVpnId != null
nvpnManager.createVpnInterface(listVpnIds, routerPort, null);
}
IpVersionChoice ipVersion = IpVersionChoice.UNDEFINED;
- for (FixedIps portIP : routerPort.nonnullFixedIps()) {
+ for (FixedIps portIP : routerPort.nonnullFixedIps().values()) {
String ipValue = portIP.getIpAddress().stringValue();
ipVersion = NeutronvpnUtils.getIpVersionFromString(ipValue);
if (ipVersion.isIpVersionChosen(IpVersionChoice.IPV4)) {
elanService.removeKnownL3DmacAddress(routerPort.getMacAddress().getValue(), infNetworkId.getValue());
Uuid vpnId = ObjectUtils.defaultIfNull(neutronvpnUtils.getVpnForRouter(routerId, true),
routerId);
- List<FixedIps> portIps = routerPort.nonnullFixedIps();
+ Map<FixedIpsKey, FixedIps> keyFixedIpsMap = routerPort.nonnullFixedIps();
boolean vpnInstanceInternetIpVersionRemoved = false;
Uuid vpnInstanceInternetUuid = null;
- for (FixedIps portIP : portIps) {
+ for (FixedIps portIP : keyFixedIpsMap.values()) {
// Internet VPN : flush InternetVPN first
Uuid subnetId = portIP.getSubnetId();
Subnetmap sn = neutronvpnUtils.getSubnetmap(subnetId);
ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
confTx -> {
IpVersionChoice ipVersion = IpVersionChoice.UNDEFINED;
- for (FixedIps portIP : portIps) {
+ for (FixedIps portIP : keyFixedIpsMap.values()) {
Subnetmap sn = neutronvpnUtils.getSubnetmap(portIP.getSubnetId());
if (null == sn) {
LOG.error("Subnetmap for subnet {} not found", portIP.getSubnetId().getValue());
final String portName = port.getUuid().getValue();
final Uuid portId = port.getUuid();
final String networkId = port.getNetworkId().getValue();
- final List<FixedIps> portIpAddrsList = port.nonnullFixedIps();
+ final Map<FixedIpsKey, FixedIps> keyFixedIpsMap = port.nonnullFixedIps();
if (NeutronConstants.IS_ODL_DHCP_PORT.test(port)) {
return;
}
if (!(NeutronUtils.isPortVnicTypeNormal(port)
|| isPortTypeSwitchdev(port)
&& isSupportedVnicTypeByHost(port, NeutronConstants.VNIC_TYPE_DIRECT))) {
- for (FixedIps ip: portIpAddrsList) {
+ for (FixedIps ip: keyFixedIpsMap.values()) {
nvpnManager.updateSubnetmapNodeWithPorts(ip.getSubnetId(), null, portId);
}
LOG.info("Port {} is not a normal and not a direct with switchdev VNIC type ;"
createElanInterface(port, portInterfaceName, tx);
Set<Uuid> vpnIdList = new HashSet<>();
Set<Uuid> routerIds = new HashSet<>();
- for (FixedIps ip: portIpAddrsList) {
+ for (FixedIps ip: keyFixedIpsMap.values()) {
Subnetmap subnetMap = nvpnManager.updateSubnetmapNodeWithPorts(ip.getSubnetId(), portId, null);
if (subnetMap != null && subnetMap.getInternetVpnId() != null) {
if (!vpnIdList.contains(subnetMap.getInternetVpnId())) {
private void handleNeutronPortDeleted(final Port port) {
final String portName = port.getUuid().getValue();
final Uuid portId = port.getUuid();
- final List<FixedIps> portIpsList = port.nonnullFixedIps();
+ final Map<FixedIpsKey, FixedIps> keyFixedIpsMap = port.nonnullFixedIps();
if (!(NeutronUtils.isPortVnicTypeNormal(port) || isPortTypeSwitchdev(port))) {
- for (FixedIps ip : portIpsList) {
+ for (FixedIps ip : keyFixedIpsMap.values()) {
// remove direct port from subnetMaps config DS
// TODO: for direct port as well, operations should be carried out per subnet based on port IP
nvpnManager.removePortsFromSubnetmapNode(ip.getSubnetId(), null, portId);
Uuid vpnId = null;
Set<Uuid> routerIds = new HashSet<>();
Uuid internetVpnId = null;
- for (FixedIps ip : portIpsList) {
+ for (FixedIps ip : keyFixedIpsMap.values()) {
Subnetmap subnetMap = nvpnManager.removePortsFromSubnetmapNode(ip.getSubnetId(), portId, null);
if (subnetMap == null) {
continue;
private void handleNeutronPortUpdated(final Port portoriginal, final Port portupdate) {
- final List<FixedIps> portoriginalIps = portoriginal.getFixedIps();
- final List<FixedIps> portupdateIps = portupdate.getFixedIps();
- if (portoriginalIps == null || portoriginalIps.isEmpty()) {
+ final Map<FixedIpsKey, FixedIps> portoriginalIpsMap = portoriginal.getFixedIps();
+ final Map<FixedIpsKey, FixedIps> portupdateIpsMap = portupdate.getFixedIps();
+ if (portoriginalIpsMap == null || portoriginalIpsMap.isEmpty()) {
handleNeutronPortCreated(portupdate);
return;
}
- if (portupdateIps == null || portupdateIps.isEmpty()) {
+ if (portupdateIpsMap == null || portupdateIpsMap.isEmpty()) {
LOG.info("Ignoring portUpdate (fixed_ip removal) for port {} as this case is handled "
+ "during subnet deletion event.", portupdate.getUuid().getValue());
return;
jobCoordinator.enqueueJob("PORT- " + portupdate.getUuid().getValue(),
() -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, confTx -> {
- final List<Uuid> originalSnMapsIds = portoriginalIps.stream().map(FixedIps::getSubnetId)
+ final List<Uuid> originalSnMapsIds = portoriginalIpsMap.values().stream().map(FixedIps::getSubnetId)
.collect(Collectors.toList());
- final List<Uuid> updateSnMapsIds = portupdateIps.stream().map(FixedIps::getSubnetId)
+ final List<Uuid> updateSnMapsIds = portupdateIpsMap.values().stream().map(FixedIps::getSubnetId)
.collect(Collectors.toList());
Set<Uuid> originalRouterIds = new HashSet<>();
Set<Uuid> oldVpnIds = new HashSet<>();
NeutronvpnUtils.getUpdatedSecurityGroups(interfaceAcl.getSecurityGroups(),
portOriginal.getSecurityGroups(), portUpdated.getSecurityGroups()));
List<AllowedAddressPairs> updatedAddressPairs = NeutronvpnUtils.getUpdatedAllowedAddressPairs(
- interfaceAcl.getAllowedAddressPairs(), portOriginal.getAllowedAddressPairs(),
- portUpdated.getAllowedAddressPairs());
+ new ArrayList<AllowedAddressPairs>(interfaceAcl.getAllowedAddressPairs().values()),
+ new ArrayList<>(portOriginal.getAllowedAddressPairs().values()),
+ new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port
+ .attributes.AllowedAddressPairs>(portUpdated.getAllowedAddressPairs().values()));
interfaceAclBuilder.setAllowedAddressPairs(NeutronvpnUtils.getAllowedAddressPairsForFixedIps(
updatedAddressPairs, portOriginal.getMacAddress(), portOriginal.getFixedIps(),
- portUpdated.getFixedIps()));
+ portUpdated.getFixedIps().values()));
if (portOriginal.getFixedIps() != null
&& !portOriginal.getFixedIps().equals(portUpdated.getFixedIps())) {
on vpn operational data to release Lport tag in case of L3VPN over VxLAN*/
if (input.getExternalGatewayInfo() != null) {
Uuid extNetId = input.getExternalGatewayInfo().getExternalNetworkId();
- List<ExternalFixedIps> externalFixedIps = input.getExternalGatewayInfo().getExternalFixedIps();
+ List<ExternalFixedIps> externalFixedIps
+ = new ArrayList<ExternalFixedIps>(input.getExternalGatewayInfo().getExternalFixedIps().values());
jobCoordinator.enqueueJob(input.getUuid().toString(), () -> {
nvpnNatManager.removeExternalNetworkFromRouter(extNetId, input, externalFixedIps);
return Collections.emptyList();
if (vpnId == null) {
vpnId = routerId;
}
- List<Routes> oldRoutes = new ArrayList<>(original.nonnullRoutes());
- List<Routes> newRoutes = new ArrayList<>(update.nonnullRoutes());
+ List<Routes> oldRoutes = new ArrayList<>(original.nonnullRoutes().values());
+ List<Routes> newRoutes = new ArrayList<>(update.nonnullRoutes().values());
if (!oldRoutes.equals(newRoutes)) {
Iterator<Routes> iterator = newRoutes.iterator();
while (iterator.hasNext()) {
package org.opendaylight.netvirt.neutronvpn;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import java.util.ArrayList;
import java.util.Collections;
-
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
Integer aclTag = neutronSecurityGroupUtils.allocateAclTag(securityGroupId);
Acl acl = toAclBuilder(securityGroup, aclTag).build();
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> tx.put(identifier, acl, CREATE_MISSING_PARENTS)));
+ tx -> tx.mergeParentStructurePut(identifier, acl)));
});
}
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
package org.opendaylight.netvirt.neutronvpn;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.collect.ImmutableBiMap;
-
import java.util.Collections;
-
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
String jobKey = securityRule.getSecurityGroupId().getValue();
jobCoordinator.enqueueJob(jobKey,
() -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> tx.put(identifier, ace, CREATE_MISSING_PARENTS))),
+ tx -> tx.mergeParentStructurePut(identifier, ace))),
NeutronSecurityGroupConstants.DJC_MAX_RETRIES);
} catch (Exception ex) {
LOG.error("Exception occured while adding acl for security rule: {}. ", securityRule, ex);
String jobKey = securityRule.getSecurityGroupId().getValue();
jobCoordinator.enqueueJob(jobKey,
() -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> tx.merge(identifier, ace, CREATE_MISSING_PARENTS))),
+ tx -> tx.mergeParentStructureMerge(identifier, ace))),
NeutronSecurityGroupConstants.DJC_MAX_RETRIES);
} catch (Exception ex) {
/*
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.ExternalGatewayInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
import org.opendaylight.yangtools.yang.common.RpcResult;
return;
}
- List<FixedIps> fixedIps = extPort.getFixedIps();
- if (fixedIps == null || fixedIps.isEmpty()) {
+ Map<FixedIpsKey, FixedIps> keyFixedIpsMap = extPort.getFixedIps();
+ if (keyFixedIpsMap == null || keyFixedIpsMap.isEmpty()) {
LOG.trace("External GW port {} for router {} has no fixed IPs", extPort.getUuid().getValue(),
router.getUuid().getValue());
return;
return;
}
- for (FixedIps fixIp : fixedIps) {
+ for (FixedIps fixIp : keyFixedIpsMap.values()) {
Uuid subnetId = fixIp.getSubnetId();
IpAddress srcIpAddress = fixIp.getIpAddress();
IpAddress dstIpAddress = getExternalGwIpAddress(subnetId);
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeVlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.trunks.rev170118.trunk.attributes.SubPorts;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.trunks.rev170118.trunk.attributes.SubPortsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.trunks.rev170118.trunks.attributes.Trunks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.trunks.rev170118.trunks.attributes.trunks.Trunk;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public void add(InstanceIdentifier<Trunk> identifier, Trunk input) {
Preconditions.checkNotNull(input.getPortId());
LOG.trace("Adding Trunk : key: {}, value={}", identifier, input);
- List<SubPorts> subPorts = input.getSubPorts();
- if (subPorts != null) {
- subPorts.forEach(subPort -> createSubPortInterface(input, subPort));
+ Map<SubPortsKey, SubPorts> keySubPortsMap = input.getSubPorts();
+ if (keySubPortsMap != null) {
+ keySubPortsMap.values().forEach(subPort -> createSubPortInterface(input, subPort));
}
}
public void remove(InstanceIdentifier<Trunk> identifier, Trunk input) {
Preconditions.checkNotNull(input.getPortId());
LOG.trace("Removing Trunk : key: {}, value={}", identifier, input);
- List<SubPorts> subPorts = input.getSubPorts();
- if (subPorts != null) {
- subPorts.forEach(this::deleteSubPortInterface);
+ Map<SubPortsKey, SubPorts> keySubPortsMap = input.getSubPorts();
+ if (keySubPortsMap != null) {
+ keySubPortsMap.values().forEach(this::deleteSubPortInterface);
}
}
@Override
public void update(InstanceIdentifier<Trunk> identifier, Trunk original, Trunk update) {
- List<SubPorts> updatedSubPorts = update.getSubPorts();
+ List<SubPorts> updatedSubPorts = new ArrayList<SubPorts>(update.getSubPorts().values());
if (updatedSubPorts == null) {
updatedSubPorts = Collections.emptyList();
}
- List<SubPorts> originalSubPorts = original.getSubPorts();
+ List<SubPorts> originalSubPorts = new ArrayList<SubPorts>(original.getSubPorts().values());
if (originalSubPorts == null) {
originalSubPorts = Collections.emptyList();
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.vpn._interface.VpnInstanceNames;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.vpn._interface.VpnInstanceNames.AssociatedSubnetType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.vpn._interface.VpnInstanceNamesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateNetworksInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateNetworksOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateNetworksOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.vpnmap.RouterIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.vpnmap.RouterIdsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.vpnmap.RouterIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.AddStaticRouteInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.AddStaticRouteInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.AddStaticRouteOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.provider.ext.rev150712.NetworkProviderExtension;
}
if (router != null) {
RouterIds vpnRouterId = new RouterIdsBuilder().setRouterId(router).build();
- List<RouterIds> rtrIds = builder.getRouterIds() != null
- ? new ArrayList<>(builder.getRouterIds()) : null;
+ List<RouterIds> rtrIds = builder.getRouterIds().values() != null
+ ? new ArrayList<>(builder.getRouterIds().values()) : null;
if (rtrIds == null) {
rtrIds = Collections.singletonList(vpnRouterId);
} else {
if (optionalVpnMap.isPresent()) {
VpnMap vpnMap = optionalVpnMap.get();
VpnMapBuilder vpnMapBuilder = new VpnMapBuilder(vpnMap);
- List<RouterIds> rtrIds = new ArrayList<>(vpnMap.nonnullRouterIds());
+ List<RouterIds> rtrIds = new ArrayList<>(vpnMap.nonnullRouterIds().values());
if (rtrIds == null) {
rtrIds = new ArrayList<>();
}
@Nullable VpnInterface vpnIface) {
List<Adjacency> adjList = new ArrayList<>();
if (vpnIface != null) {
- adjList = vpnIface.augmentation(Adjacencies.class).getAdjacency();
+ adjList = new ArrayList<Adjacency>(vpnIface.augmentation(Adjacencies.class).getAdjacency().values());
}
String infName = port.getUuid().getValue();
LOG.trace("neutronVpnManager: create config adjacencies for Port: {}", infName);
- for (FixedIps ip : port.nonnullFixedIps()) {
+ for (FixedIps ip : port.nonnullFixedIps().values()) {
String ipValue = ip.getIpAddress().stringValue();
String ipPrefix = ip.getIpAddress().getIpv4Address() != null ? ipValue + "/32" : ipValue + "/128";
Subnetmap snTemp = neutronvpnUtils.getSubnetmap(ip.getSubnetId());
if (routerId != null) {
Router rtr = neutronvpnUtils.getNeutronRouter(routerId);
if (rtr != null && rtr.getRoutes() != null) {
- List<Routes> routeList = rtr.getRoutes();
+ List<Routes> routeList = new ArrayList<Routes>(rtr.getRoutes().values());
// create extraroute Adjacence for each ipValue,
// because router can have IPv4 and IPv6 subnet ports, or can have
// more that one IPv4 subnet port or more than one IPv6 subnet port
}
LOG.trace("withdraw adjacencies for Port: {} subnet {}", port.getUuid().getValue(),
sn != null ? sn.getSubnetIp() : "null");
- List<Adjacency> vpnAdjsList = optionalVpnInterface.get().augmentation(Adjacencies.class).nonnullAdjacency();
+ Map<AdjacencyKey, Adjacency> keyAdjacencyMap
+ = optionalVpnInterface.get().augmentation(Adjacencies.class).nonnullAdjacency();
List<Adjacency> updatedAdjsList = new ArrayList<>();
boolean isIpFromAnotherSubnet = false;
- for (Adjacency adj : vpnAdjsList) {
+ for (Adjacency adj : keyAdjacencyMap.values()) {
String adjString = FibHelper.getIpFromPrefix(adj.getIpAddress());
if (sn == null || !Objects.equals(adj.getSubnetId(), sn.getId())) {
if (adj.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
Router rtr = neutronvpnUtils.getNeutronRouter(sn.getRouterId());
if (rtr != null && rtr.getRoutes() != null) {
List<Routes> extraRoutesToRemove = new ArrayList<>();
- for (Routes rt: rtr.getRoutes()) {
+ for (Routes rt: rtr.getRoutes().values()) {
if (rt.getNexthop().toString().equals(adjString)) {
extraRoutesToRemove.add(rt);
}
}
if (vpnId != null) {
VpnInterface vpnInterface = optionalVpnInterface.get();
- List<VpnInstanceNames> vpnList = vpnInterface.getVpnInstanceNames();
- if (vpnList != null
- && VpnHelper.doesVpnInterfaceBelongToVpnInstance(vpnId, vpnList)) {
- VpnHelper.removeVpnInterfaceVpnInstanceNamesFromList(vpnId, vpnList);
- if (!vpnList.isEmpty()) {
+ Map<VpnInstanceNamesKey, VpnInstanceNames> keyVpnInstanceNamesMap = vpnInterface.getVpnInstanceNames();
+ if (keyVpnInstanceNamesMap != null
+ && VpnHelper.doesVpnInterfaceBelongToVpnInstance(vpnId,
+ new ArrayList<VpnInstanceNames>(keyVpnInstanceNamesMap.values()))) {
+ VpnHelper.removeVpnInterfaceVpnInstanceNamesFromList(vpnId,
+ new ArrayList<VpnInstanceNames>(keyVpnInstanceNamesMap.values()));
+ if (!keyVpnInstanceNamesMap.isEmpty()) {
LOG.debug("Deleting vpn interface {} not immediately since vpnInstanceName "
+ "List not empty", infName);
return;
}
VpnInterfaceBuilder vpnIfBuilder = new VpnInterfaceBuilder(optionalVpnInterface.get())
- .setVpnInstanceNames(vpnList);
+ .setVpnInstanceNames(keyVpnInstanceNamesMap);
wrtConfigTxn.put(vpnIfIdentifier, vpnIfBuilder
.build());
}
.syncReadOptional(dataBroker, LogicalDatastoreType
.CONFIGURATION, vpnIfIdentifier);
if (optionalVpnInterface.isPresent()) {
- List<VpnInstanceNames> listVpn = optionalVpnInterface.get().getVpnInstanceNames();
- if (listVpn != null
- && VpnHelper.doesVpnInterfaceBelongToVpnInstance(vpnId.getValue(), listVpn)) {
- VpnHelper.removeVpnInterfaceVpnInstanceNamesFromList(vpnId.getValue(), listVpn);
+ Map<VpnInstanceNamesKey, VpnInstanceNames> keyVpnInstanceNamesMap
+ = optionalVpnInterface.get().getVpnInstanceNames();
+ if (keyVpnInstanceNamesMap != null
+ && VpnHelper.doesVpnInterfaceBelongToVpnInstance(vpnId.getValue(),
+ new ArrayList<VpnInstanceNames>(keyVpnInstanceNamesMap.values()))) {
+ VpnHelper.removeVpnInterfaceVpnInstanceNamesFromList(vpnId.getValue(),
+ new ArrayList<VpnInstanceNames>(keyVpnInstanceNamesMap.values()));
}
VpnInterfaceBuilder vpnIfBuilder = new VpnInterfaceBuilder(optionalVpnInterface.get())
- .setVpnInstanceNames(listVpn);
+ .setVpnInstanceNames(keyVpnInstanceNamesMap);
Adjacencies adjs = vpnIfBuilder.augmentation(Adjacencies.class);
LOG.debug("Updating vpn interface {}", infName);
- List<Adjacency> adjacencyList = adjs != null ? adjs.getAdjacency() : new ArrayList<>();
- Iterator<Adjacency> adjacencyIter = adjacencyList.iterator();
+ Map<AdjacencyKey, Adjacency> keyAdjacencyMap = adjs != null ? adjs.getAdjacency() : new HashMap<>();
+ Iterator<Adjacency> adjacencyIter = keyAdjacencyMap.values().iterator();
while (adjacencyIter.hasNext()) {
Adjacency adjacency = adjacencyIter.next();
if (adjacency.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
if (optionalVpnVipToPort.isPresent()) {
LOG.trace("Removing adjacencies from vpninterface {} upon dissociation of router {}",
infName, vpnId);
- if (listVpn == null || listVpn.isEmpty()) {
+ if (keyVpnInstanceNamesMap == null || keyVpnInstanceNamesMap.isEmpty()) {
adjacencyIter.remove();
}
neutronvpnUtils.removeLearntVpnVipToPort(vpnId.getValue(), mipToQuery);
mipToQuery, infName, vpnId.getValue());
}
}
- for (FixedIps ip : port.nonnullFixedIps()) {
+ for (FixedIps ip : port.nonnullFixedIps().values()) {
String ipValue = ip.getIpAddress().stringValue();
//skip IPv4 address
if (!NeutronvpnUtils.getIpVersionFromString(ipValue).isIpVersionChosen(IpVersionChoice.IPV6)) {
neutronvpnUtils.removeVpnPortFixedIpToPort(vpnId.getValue(),
ipValue, writeConfigTxn);
}
- if (listVpn == null || listVpn.isEmpty()) {
+ if (keyVpnInstanceNamesMap == null || keyVpnInstanceNamesMap.isEmpty()) {
if (sm != null && sm.getRouterId() != null) {
removeFromNeutronRouterInterfacesMap(sm.getRouterId(), port.getUuid().getValue());
}
if (optionalVpnInterface.isPresent()) {
VpnInstanceNames vpnInstance = VpnHelper
.getVpnInterfaceVpnInstanceNames(vpnId.getValue(), AssociatedSubnetType.V4AndV6Subnets);
- List<VpnInstanceNames> listVpn = new ArrayList<>(optionalVpnInterface
- .get().getVpnInstanceNames());
+ List<VpnInstanceNames> listVpn = new ArrayList<>(optionalVpnInterface.get()
+ .getVpnInstanceNames().values());
if (oldVpnId != null
&& VpnHelper.doesVpnInterfaceBelongToVpnInstance(oldVpnId.getValue(), listVpn)) {
VpnHelper.removeVpnInterfaceVpnInstanceNamesFromList(oldVpnId.getValue(), listVpn);
LOG.debug("Updating vpn interface {}", infName);
if (!isBeingAssociated) {
Adjacencies adjs = vpnIfBuilder.augmentation(Adjacencies.class);
- List<Adjacency> adjacencyList = adjs != null ? adjs.getAdjacency() : new ArrayList<>();
- Iterator<Adjacency> adjacencyIter = adjacencyList.iterator();
+ Map<AdjacencyKey, Adjacency> keyAdjacencyMap = adjs != null ? adjs.getAdjacency()
+ : new HashMap<AdjacencyKey, Adjacency>();
+ Iterator<Adjacency> adjacencyIter = keyAdjacencyMap.values().iterator();
while (adjacencyIter.hasNext()) {
Adjacency adjacency = adjacencyIter.next();
String mipToQuery = adjacency.getIpAddress().split("/")[0];
mipToQuery, infName, vpnId.getValue());
}
}
- Adjacencies adjacencies = new AdjacenciesBuilder().setAdjacency(adjacencyList).build();
+ Adjacencies adjacencies = new AdjacenciesBuilder().setAdjacency(keyAdjacencyMap).build();
vpnIfBuilder.addAugmentation(Adjacencies.class, adjacencies);
}
- for (FixedIps ip : port.nonnullFixedIps()) {
+ for (FixedIps ip : port.nonnullFixedIps().values()) {
String ipValue = ip.getIpAddress().stringValue();
if (oldVpnId != null) {
neutronvpnUtils.removeVpnPortFixedIpToPort(oldVpnId.getValue(),
continue;
}
if (vpn.getRouterIds() != null && !vpn.getRouterIds().isEmpty()) {
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpn.instance.RouterIds>
- routerIdsList = vpn.getRouterIds();
+ Map<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt
+ .neutronvpn.rev150602.vpn.instance.RouterIdsKey, org.opendaylight.yang.gen.v1.urn.opendaylight
+ .netvirt.neutronvpn.rev150602.vpn.instance.RouterIds> keyRouterIdsMap = vpn.getRouterIds();
for (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpn.instance.RouterIds
- routerId : routerIdsList) {
+ routerId : keyRouterIdsMap.values()) {
if (neutronvpnUtils.getNeutronRouter(routerId.getRouterId()) == null) {
errorList.add(RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input",
formatAndLog(LOG::warn, "Creation of L3VPN failed for VPN {} due to absense of routers"
List<Uuid> rtrIdsList = new ArrayList<>();
if (vpn.getRouterIds() != null && !vpn.getRouterIds().isEmpty()) {
for (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpn.instance.RouterIds
- rtrId : vpn.getRouterIds()) {
+ rtrId : vpn.getRouterIds().values()) {
rtrIdsList.add(rtrId.getRouterId());
}
}
SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
vpnsIdentifier);
if (optionalVpns.isPresent() && !optionalVpns.get().getVpnInstance().isEmpty()) {
- for (VpnInstance vpn : optionalVpns.get().nonnullVpnInstance()) {
+ for (VpnInstance vpn : optionalVpns.get().nonnullVpnInstance().values()) {
// eliminating implicitly created (router and VLAN provider external network specific) VPNs
// from getL3VPN output
if (vpn.getRouteDistinguisher() != null) {
List<String> irtList = new ArrayList<>();
if (vpnInstance.getVpnTargets() != null) {
- List<VpnTarget> vpnTargetList = Collections.EMPTY_LIST;
+ Map<VpnTargetKey, VpnTarget> keyVpnTargetMap = Collections.EMPTY_MAP;
if (!vpnInstance.getVpnTargets().getVpnTarget().isEmpty()) {
- vpnTargetList = vpnInstance.getVpnTargets().getVpnTarget();
+ keyVpnTargetMap = vpnInstance.getVpnTargets().getVpnTarget();
}
- if (!vpnTargetList.isEmpty()) {
- for (VpnTarget vpnTarget : vpnTargetList) {
+ if (!keyVpnTargetMap.isEmpty()) {
+ for (VpnTarget vpnTarget : keyVpnTargetMap.values()) {
if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ExportExtcommunity) {
ertList.add(vpnTarget.getVrfRTValue());
}
VpnMap vpnMap = optionalVpnMap.get();
List<Uuid> rtrIds = new ArrayList<>();
if (vpnMap.getRouterIds() != null && !vpnMap.getRouterIds().isEmpty()) {
- for (RouterIds rtrId : vpnMap.getRouterIds()) {
+ for (RouterIds rtrId : vpnMap.getRouterIds().values()) {
rtrIds.add(rtrId.getRouterId());
}
}
.setInterfaceId(interfaceName).build();
if (optRouterInterfaces.isPresent()) {
RouterInterfaces routerInterfaces = optRouterInterfaces.get();
- List<Interfaces> interfaces = new ArrayList<>(routerInterfaces.nonnullInterfaces());
+ List<Interfaces> interfaces = new ArrayList<>(routerInterfaces.nonnullInterfaces().values());
if (interfaces != null && interfaces.remove(routerInterface)) {
if (interfaces.isEmpty()) {
SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION,
// read VPNMaps
VpnMap vpnMap = neutronvpnUtils.getVpnMap(vpnId);
if (vpnMap != null) {
- List<RouterIds> routerIdsList = vpnMap.getRouterIds();
+ Map<RouterIdsKey, RouterIds> keyRouterIdsMap = vpnMap.getRouterIds();
List<Uuid> routerUuidList = new ArrayList<>();
// dissociate router
- if (routerIdsList != null && !routerIdsList.isEmpty()) {
- for (RouterIds router : routerIdsList) {
+ if (keyRouterIdsMap != null && !keyRouterIdsMap.isEmpty()) {
+ for (RouterIds router : keyRouterIdsMap.values()) {
Uuid routerId = router.getRouterId();
routerUuidList.add(routerId);
dissociateRouterFromVpn(vpnId, routerId);
LOG.debug("associateRouter {}", input);
StringBuilder returnMsg = new StringBuilder();
Uuid vpnId = input.getVpnId();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.associaterouter.input.RouterIds>
- routerIds = input.getRouterIds();
- Preconditions.checkArgument(!routerIds.isEmpty(), "associateRouter: RouterIds list is empty!");
+ Map<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.associaterouter
+ .input.RouterIdsKey, org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602
+ .associaterouter.input.RouterIds> keyRouterIdsMap = input.getRouterIds();
+ Preconditions.checkArgument(!keyRouterIdsMap.isEmpty(), "associateRouter: RouterIds list is empty!");
Preconditions.checkNotNull(vpnId, "associateRouter; VpnId not found!");
Preconditions.checkNotNull(vpnId, "associateRouter; RouterIds not found!");
for (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.associaterouter.input
- .RouterIds routerId : routerIds) {
+ .RouterIds routerId : keyRouterIdsMap.values()) {
VpnMap vpnMap = neutronvpnUtils.getVpnMap(vpnId);
Router rtr = neutronvpnUtils.getNeutronRouter(routerId.getRouterId());
if (vpnMap != null) {
List<String> fixedIPList = new ArrayList<>();
Port port = neutronvpnUtils.getNeutronPort(portId);
if (port != null) {
- for (FixedIps ip : port.nonnullFixedIps()) {
+ for (FixedIps ip : port.nonnullFixedIps().values()) {
fixedIPList.add(ip.getIpAddress().stringValue());
}
} else {
LOG.debug("dissociateRouter {}", input);
StringBuilder returnMsg = new StringBuilder();
Uuid vpnId = input.getVpnId();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.dissociaterouter.input
- .RouterIds> routerIdList = input.getRouterIds();
+ Map<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.dissociaterouter.input
+ .RouterIdsKey, org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602
+ .dissociaterouter.input.RouterIds> keyRouterIdsMap = input.getRouterIds();
String routerIdsString = "";
- Preconditions.checkArgument(!routerIdList.isEmpty(), "dissociateRouter: RouterIds list is empty!");
+ Preconditions.checkArgument(!keyRouterIdsMap.isEmpty(), "dissociateRouter: RouterIds list is empty!");
Preconditions.checkNotNull(vpnId, "dissociateRouter: vpnId not found!");
- Preconditions.checkNotNull(routerIdList, "dissociateRouter: routerIdList not found!");
+ Preconditions.checkNotNull(keyRouterIdsMap, "dissociateRouter: keyRouterIdsMap not found!");
if (neutronvpnUtils.getVpnMap(vpnId) != null) {
for (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.dissociaterouter.input
- .RouterIds routerId : routerIdList) {
+ .RouterIds routerId : keyRouterIdsMap.values()) {
try {
if (routerId != null) {
routerIdsString += routerId.getRouterId() + ", ";
Optional<Ports> ports = syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, portidentifier);
if (ports.isPresent() && ports.get().getPort() != null) {
- for (Port port : ports.get().nonnullPort()) {
- List<FixedIps> fixedIPs = port.getFixedIps();
- if (fixedIPs != null && !fixedIPs.isEmpty()) {
+ for (Port port : ports.get().nonnullPort().values()) {
+ Map<FixedIpsKey, FixedIps> keyFixedIpsMap = port.getFixedIps();
+ if (keyFixedIpsMap != null && !keyFixedIpsMap.isEmpty()) {
List<String> ipList = new ArrayList<>();
- for (FixedIps fixedIp : fixedIPs) {
+ for (FixedIps fixedIp : keyFixedIpsMap.values()) {
IpAddress ipAddress = fixedIp.getIpAddress();
if (ipAddress.getIpv4Address() != null) {
ipList.add(ipAddress.getIpv4Address().getValue());
vpnIfBuilder.addAugmentation(Adjacencies.class, adjacencies);
if (optionalVpnInterface.get().getVpnInstanceNames() != null) {
List<VpnInstanceNames> listVpnInstances = new ArrayList<>(
- optionalVpnInterface.get().getVpnInstanceNames());
+ optionalVpnInterface.get().getVpnInstanceNames().values());
if (listVpnInstances.isEmpty()
|| !VpnHelper.doesVpnInterfaceBelongToVpnInstance(vpnId.getValue(), listVpnInstances)) {
VpnInstanceNames vpnInstance = VpnHelper.getVpnInterfaceVpnInstanceNames(vpnId.getValue(),
import java.util.ArrayList;
import java.util.Collection;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.ExternalGatewayInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.external_gateway_info.ExternalFixedIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.external_gateway_info.ExternalFixedIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
}
if (extNetChanged == EXTERNAL_REMOVED) {
origExtNetId = original.getExternalGatewayInfo().getExternalNetworkId();
- origExtFixedIps = original.getExternalGatewayInfo().getExternalFixedIps();
+ origExtFixedIps = new ArrayList<ExternalFixedIps>(original.getExternalGatewayInfo()
+ .getExternalFixedIps().values());
LOG.trace("External Network removal detected for router {}", routerId.getValue());
removeExternalNetworkFromRouter(origExtNetId, update, origExtFixedIps);
//gateway mac unset handled as part of gateway clear deleting top-level routers node
}
origExtNetId = original.getExternalGatewayInfo().getExternalNetworkId();
- origExtFixedIps = original.getExternalGatewayInfo().getExternalFixedIps();
+ origExtFixedIps = new ArrayList<ExternalFixedIps>(original.getExternalGatewayInfo()
+ .getExternalFixedIps().values());
updExtNetId = update.getExternalGatewayInfo().getExternalNetworkId();
LOG.trace("External Network changed from {} to {} for router {}",
origExtNetId.getValue(), updExtNetId.getValue(), routerId.getValue());
if (origExtGw.getExternalFixedIps() != null) {
if (!origExtGw.getExternalFixedIps().isEmpty()) {
if (newExtGw.getExternalFixedIps() != null && !newExtGw.getExternalFixedIps().isEmpty()) {
- List<ExternalFixedIps> origExtFixedIps = new ArrayList<>(origExtGw.nonnullExternalFixedIps());
+ List<ExternalFixedIps> origExtFixedIps
+ = new ArrayList<>(origExtGw.nonnullExternalFixedIps().values());
HashSet<String> origFixedIpSet = new HashSet<>();
for (ExternalFixedIps fixedIps : origExtFixedIps) {
origFixedIpSet.add(fixedIps.getIpAddress().stringValue());
}
- List<ExternalFixedIps> newExtFixedIps = new ArrayList<>(newExtGw.nonnullExternalFixedIps());
+ List<ExternalFixedIps> newExtFixedIps
+ = new ArrayList<>(newExtGw.nonnullExternalFixedIps().values());
HashSet<String> updFixedIpSet = new HashSet<>();
for (ExternalFixedIps fixedIps : newExtFixedIps) {
updFixedIpSet.add(fixedIps.getIpAddress().stringValue());
private void addExternalNetworkToRouter(Router update) {
Uuid routerId = update.getUuid();
Uuid extNetId = update.getExternalGatewayInfo().getExternalNetworkId();
- List<ExternalFixedIps> externalFixedIps = update.getExternalGatewayInfo().getExternalFixedIps();
+ Map<ExternalFixedIpsKey, ExternalFixedIps> keyExternalFixedIpsMap
+ = update.getExternalGatewayInfo().getExternalFixedIps();
try {
Network input = neutronvpnUtils.getNeutronNetwork(extNetId);
addExternalRouter(update);
// Update External Subnets for this router
- updateExternalSubnetsForRouter(routerId, extNetId, externalFixedIps);
+ updateExternalSubnetsForRouter(routerId, extNetId,
+ new ArrayList<ExternalFixedIps>(keyExternalFixedIpsMap.values()));
// Create and add Networks object for this External Network to the ExternalNetworks list
InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class)
builder.setEnableSnat(update.getExternalGatewayInfo().isEnableSnat());
ArrayList<ExternalIps> externalIps = new ArrayList<>();
- for (ExternalFixedIps fixedIps : update.getExternalGatewayInfo().nonnullExternalFixedIps()) {
+ for (ExternalFixedIps fixedIps : update.getExternalGatewayInfo().nonnullExternalFixedIps().values()) {
addExternalFixedIpToExternalIpsList(externalIps, fixedIps);
}
builder.setExternalIps(externalIps);
LOG.trace(" Removing Routers node {}", routerId.getValue());
if (optionalRouters.isPresent()) {
RoutersBuilder builder = new RoutersBuilder(optionalRouters.get());
- builder.setExternalIps(null);
+ builder.setExternalIps(new HashMap<ExternalIpsKey, ExternalIps>());
builder.setSubnetIds(null);
SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION,
routersIdentifier);
(routerDpnListOptional) -> {
if (routerDpnListOptional.isPresent()) {
if (routerDpnListOptional.get().getDpnVpninterfacesList() != null) {
- routerDpnListOptional.get().getDpnVpninterfacesList().stream()
+ routerDpnListOptional.get().getDpnVpninterfacesList().values().stream()
.filter((dpnList) -> (dpnList != null))
.forEach((dpnList) -> {
LOG.warn("DPN {} presence exists while deleting router instance {}",
if (optionalRouters.isPresent()) {
RoutersBuilder builder = new RoutersBuilder(optionalRouters.get());
List<ExternalIps> externalIps = new ArrayList<>();
- for (ExternalFixedIps fixedIps : update.getExternalGatewayInfo().getExternalFixedIps()) {
+ for (ExternalFixedIps fixedIps : update.getExternalGatewayInfo().getExternalFixedIps().values()) {
addExternalFixedIpToExternalIpsList(externalIps, fixedIps);
}
builder.setExternalIps(externalIps);
updateExternalSubnetsForRouter(routerId, update.getExternalGatewayInfo().getExternalNetworkId(),
- update.getExternalGatewayInfo().getExternalFixedIps());
+ new ArrayList<ExternalFixedIps>(update.getExternalGatewayInfo()
+ .getExternalFixedIps().values()));
Routers routerss = builder.build();
LOG.trace("Updating external fixed ips for router {} with value {}", routerId.getValue(), routerss);
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routersIdentifier,
Optional<Adjacencies> optionalAdjacencies = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, adjacenciesIdentifier);
if (optionalAdjacencies.isPresent()) {
- List<Adjacency> adjacencies = optionalAdjacencies.get().getAdjacency();
- Iterator<Adjacency> adjacencyIter = adjacencies.iterator();
+ Map<AdjacencyKey, Adjacency> keyAdjacencyMap = optionalAdjacencies.get().getAdjacency();
+ Iterator<Adjacency> adjacencyIter = keyAdjacencyMap.values().iterator();
while (adjacencyIter.hasNext()) {
Adjacency adjacency = adjacencyIter.next();
if (!adjacency.getSubnetId().equals(extSubnetId)) {
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpn.instance.RouterIdsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMapKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.vpnmap.RouterIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.ext.rev150712.NetworkL3Extension;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.NetworkKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortKey;
protected Uuid getVpnForNetwork(Uuid network) {
Optional<VpnMaps> optionalVpnMaps = read(LogicalDatastoreType.CONFIGURATION, VPN_MAPS_IID);
if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().nonnullVpnMap() != null) {
- for (VpnMap vpnMap : new ArrayList<>(optionalVpnMaps.get().nonnullVpnMap())) {
+ for (VpnMap vpnMap : new ArrayList<>(optionalVpnMaps.get().nonnullVpnMap().values())) {
List<Uuid> netIds = vpnMap.getNetworkIds();
if (netIds != null && netIds.contains(network)) {
return vpnMap.getVpnId();
Optional<VpnMaps> optionalVpnMaps = read(LogicalDatastoreType.CONFIGURATION, VPN_MAPS_IID);
if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().nonnullVpnMap() != null) {
- for (VpnMap vpnMap : new ArrayList<>(optionalVpnMaps.get().nonnullVpnMap())) {
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.vpnmap
- .RouterIds> routerIdsList = vpnMap.getRouterIds();
- if (routerIdsList == null || routerIdsList.isEmpty()) {
+ for (VpnMap vpnMap : new ArrayList<>(optionalVpnMaps.get().nonnullVpnMap().values())) {
+ Map<RouterIdsKey, org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602
+ .vpnmaps.vpnmap.RouterIds> keyRouterIdsMap = vpnMap.getRouterIds();
+ if (keyRouterIdsMap == null || keyRouterIdsMap.isEmpty()) {
continue;
}
// Skip router vpnId fetching from internet BGP-VPN
continue;
}
// FIXME: NETVIRT-1503: this check can be replaced by a ReadOnlyTransaction.exists()
- if (routerIdsList.stream().anyMatch(routerIds -> routerId.equals(routerIds.getRouterId()))) {
+ if (keyRouterIdsMap.values().stream().anyMatch(routerIds -> routerId.equals(routerIds.getRouterId()))) {
if (externalVpn) {
if (!routerId.equals(vpnMap.getVpnId())) {
return vpnMap.getVpnId();
Optional<VpnMap> optionalVpnMap = read(LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier(vpnId));
if (optionalVpnMap.isPresent()) {
VpnMap vpnMap = optionalVpnMap.get();
- return NeutronUtils.getVpnMapRouterIdsListUuid(vpnMap.getRouterIds());
+ return NeutronUtils.getVpnMapRouterIdsListUuid(new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight
+ .netvirt.neutronvpn.rev150602.vpnmaps.vpnmap.RouterIds>(vpnMap.getRouterIds().values()));
}
LOG.error("getRouterIdListforVpn: Failed as VPNMaps DS is absent for VPN {}", vpnId.getValue());
return null;
// read subnetmaps
Optional<Subnetmaps> subnetmaps = read(LogicalDatastoreType.CONFIGURATION, SUBNETMAPS_IID);
if (subnetmaps.isPresent() && subnetmaps.get().getSubnetmap() != null) {
- List<Subnetmap> subnetMapList = subnetmaps.get().getSubnetmap();
- for (Subnetmap candidateSubnetMap : subnetMapList) {
+ Map<SubnetmapKey, Subnetmap> keySubnetmapMap = subnetmaps.get().getSubnetmap();
+ for (Subnetmap candidateSubnetMap : keySubnetmapMap.values()) {
if (candidateSubnetMap.getVpnId() != null && candidateSubnetMap.getVpnId().equals(vpnid)) {
subnets.add(candidateSubnetMap.getId());
}
interfaceAclBuilder.setPortSecurityEnabled(false);
interfaceAclBuilder.setInterfaceType(InterfaceAcl.InterfaceType.DhcpService);
List<AllowedAddressPairs> aclAllowedAddressPairs = NeutronvpnUtils.getAllowedAddressPairsForAclService(
- port.getMacAddress(), port.getFixedIps());
+ port.getMacAddress(), new ArrayList<FixedIps>(port.getFixedIps().values()));
interfaceAclBuilder.setAllowedAddressPairs(aclAllowedAddressPairs);
return interfaceAclBuilder.build();
}
*/
protected static List<AllowedAddressPairs> getAllowedAddressPairsForFixedIps(
List<AllowedAddressPairs> aclInterfaceAllowedAddressPairs, MacAddress portMacAddress,
- List<FixedIps> origFixedIps, List<FixedIps> newFixedIps) {
- List<FixedIps> addedFixedIps = getFixedIpsDelta(newFixedIps, origFixedIps);
- List<FixedIps> deletedFixedIps = getFixedIpsDelta(origFixedIps, newFixedIps);
+ @Nullable Map<FixedIpsKey, FixedIps> origFixedIps, Collection<FixedIps> newFixedIps) {
+ List<FixedIps> addedFixedIps = getFixedIpsDelta(new ArrayList<FixedIps>(newFixedIps),
+ new ArrayList<FixedIps>(origFixedIps.values()));
+ List<FixedIps> deletedFixedIps = getFixedIpsDelta(new ArrayList<FixedIps>(origFixedIps.values()),
+ new ArrayList<FixedIps>(newFixedIps));
List<AllowedAddressPairs> updatedAllowedAddressPairs =
aclInterfaceAllowedAddressPairs != null
? new ArrayList<>(aclInterfaceAllowedAddressPairs) : new ArrayList<>();
protected static List<AllowedAddressPairs> getUpdatedAllowedAddressPairs(
List<AllowedAddressPairs> aclInterfaceAllowedAddressPairs,
List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes
- .AllowedAddressPairs> origAllowedAddressPairs,
+ .AllowedAddressPairs> origAllowedAddressPairs,
List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes
- .AllowedAddressPairs> newAllowedAddressPairs) {
+ .AllowedAddressPairs> newAllowedAddressPairs) {
List<AllowedAddressPairs> addedAllowedAddressPairs =
- getAllowedAddressPairsDelta(newAllowedAddressPairs,origAllowedAddressPairs);
+ getAllowedAddressPairsDelta(new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports
+ .rev150712.port.attributes.AllowedAddressPairs>(newAllowedAddressPairs),
+ new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port
+ .attributes.AllowedAddressPairs>(origAllowedAddressPairs));
List<AllowedAddressPairs> deletedAllowedAddressPairs =
- getAllowedAddressPairsDelta(origAllowedAddressPairs, newAllowedAddressPairs);
+ getAllowedAddressPairsDelta(new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports
+ .rev150712.port.attributes.AllowedAddressPairs>(origAllowedAddressPairs),
+ new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port
+ .attributes.AllowedAddressPairs>(newAllowedAddressPairs));
List<AllowedAddressPairs> updatedAllowedAddressPairs =
aclInterfaceAllowedAddressPairs != null
? new ArrayList<>(aclInterfaceAllowedAddressPairs) : new ArrayList<>();
interfaceAclBuilder.setSecurityGroups(securityGroups);
}
List<AllowedAddressPairs> aclAllowedAddressPairs = NeutronvpnUtils.getAllowedAddressPairsForAclService(
- port.getMacAddress(), port.getFixedIps());
+ port.getMacAddress(), new ArrayList<FixedIps>(port.getFixedIps().values()));
// Update the allowed address pair with the IPv6 LLA that is auto configured on the port.
aclAllowedAddressPairs.add(NeutronvpnUtils.updateIPv6LinkLocalAddressForAclService(port.getMacAddress()));
List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs>
- portAllowedAddressPairs = port.getAllowedAddressPairs();
+ portAllowedAddressPairs = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports
+ .rev150712.port.attributes.AllowedAddressPairs>(port.getAllowedAddressPairs().values());
if (portAllowedAddressPairs != null) {
aclAllowedAddressPairs.addAll(NeutronvpnUtils.getAllowedAddressPairsForAclService(portAllowedAddressPairs));
}
@Nullable
protected List<SubnetInfo> getSubnetInfo(Port port) {
- List<FixedIps> portFixedIps = port.getFixedIps();
- if (portFixedIps == null) {
+ Map<FixedIpsKey, FixedIps> keyFixedIpsMap = port.getFixedIps();
+ if (keyFixedIpsMap == null) {
LOG.error("Failed to get Fixed IPs for the port {}", port.getName());
return null;
}
List<SubnetInfo> subnetInfoList = new ArrayList<>();
- for (FixedIps portFixedIp : portFixedIps) {
+ for (FixedIps portFixedIp : keyFixedIpsMap.values()) {
Uuid subnetId = portFixedIp.getSubnetId();
Subnet subnet = getNeutronSubnet(subnetId);
if (subnet != null) {
List<Subnetmap> subnetMapList = new ArrayList<>();
Optional<Subnetmaps> subnetMaps = read(LogicalDatastoreType.CONFIGURATION, SUBNETMAPS_IID);
if (subnetMaps.isPresent() && subnetMaps.get().getSubnetmap() != null) {
- for (Subnetmap subnetmap : subnetMaps.get().getSubnetmap()) {
+ for (Subnetmap subnetmap : subnetMaps.get().getSubnetmap().values()) {
if (routerId.equals(subnetmap.getRouterId())) {
subnetMapList.add(subnetmap);
}
List<Uuid> subnetIdList = new ArrayList<>();
Optional<Subnetmaps> subnetMaps = read(LogicalDatastoreType.CONFIGURATION, SUBNETMAPS_IID);
if (subnetMaps.isPresent() && subnetMaps.get().getSubnetmap() != null) {
- for (Subnetmap subnetmap : subnetMaps.get().getSubnetmap()) {
+ for (Subnetmap subnetmap : subnetMaps.get().getSubnetmap().values()) {
if (routerId.equals(subnetmap.getRouterId())) {
subnetIdList.add(subnetmap.getId());
}
try {
// FIXME: why are we not using getNeutronSubnet() here? it does caching for us...
Optional<Subnet> subnet = read(LogicalDatastoreType.CONFIGURATION,
- NEUTRON_SUBNETS_IID.child(Subnet.class, new SubnetKey(port.getFixedIps().get(0).getSubnetId())));
+ NEUTRON_SUBNETS_IID.child(Subnet.class, new SubnetKey(
+ new ArrayList<FixedIps>(port.getFixedIps().values()).get(0).getSubnetId())));
if (subnet.isPresent()) {
String cidr = subnet.get().getCidr().stringValue();
// Extract the prefix length from cidr
interVpnLinksOpData = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
interVpnLinksIid);
if (interVpnLinksOpData.isPresent()) {
- for (InterVpnLink interVpnLink : interVpnLinksOpData.get().nonnullInterVpnLink()) {
+ for (InterVpnLink interVpnLink : interVpnLinksOpData.get().nonnullInterVpnLink().values()) {
if (interVpnLink.getFirstEndpoint().getIpAddress().getValue().equals(endpointIp)
|| interVpnLink.getSecondEndpoint().getIpAddress().getValue().equals(endpointIp)) {
return Optional.of(interVpnLink);
InstanceIdentifier<VpnInstances> path = InstanceIdentifier.builder(VpnInstances.class).build();
Optional<VpnInstances> vpnInstancesOptional = read(LogicalDatastoreType.CONFIGURATION, path);
if (vpnInstancesOptional.isPresent() && vpnInstancesOptional.get().getVpnInstance() != null) {
- for (VpnInstance vpnInstance : vpnInstancesOptional.get().getVpnInstance()) {
+ for (VpnInstance vpnInstance : vpnInstancesOptional.get().getVpnInstance().values()) {
List<String> rds = vpnInstance.getRouteDistinguisher();
if (rds != null) {
existingRDs.addAll(rds);
public static List<StaticMacEntries> buildStaticMacEntry(Port port) {
PhysAddress physAddress = new PhysAddress(port.getMacAddress().getValue());
- List<FixedIps> fixedIps = port.getFixedIps();
+ Map<FixedIpsKey, FixedIps> keyFixedIpsMap = port.getFixedIps();
IpAddress ipAddress = null;
- if (isNotEmpty(fixedIps)) {
- ipAddress = port.getFixedIps().get(0).getIpAddress();
+ if (isNotEmpty(keyFixedIpsMap.values())) {
+ ipAddress = new ArrayList<FixedIps>(port.getFixedIps().values()).get(0).getIpAddress();
}
StaticMacEntriesBuilder staticMacEntriesBuilder = new StaticMacEntriesBuilder();
List<StaticMacEntries> staticMacEntries = new ArrayList<>();
List<Subnetmap> subnetIdList = new ArrayList<>();
Optional<Subnetmaps> subnetMaps = read(LogicalDatastoreType.CONFIGURATION, SUBNETMAPS_IID);
if (subnetMaps.isPresent() && subnetMaps.get().getSubnetmap() != null) {
- for (Subnetmap subnetmap : subnetMaps.get().getSubnetmap()) {
+ for (Subnetmap subnetmap : subnetMaps.get().getSubnetmap().values()) {
if (routerId.equals(subnetmap.getRouterId())) {
subnetIdList.add(subnetmap);
}
Optional<Subnetmaps> allSubnetMaps = read(LogicalDatastoreType.CONFIGURATION, SUBNETMAPS_IID);
// calculate and store in list IpVersion for each subnetMap, belonging to current VpnInstance
List<IpVersionChoice> snIpVersions = new ArrayList<>();
- for (Subnetmap snMap : allSubnetMaps.get().nonnullSubnetmap()) {
+ for (Subnetmap snMap : allSubnetMaps.get().nonnullSubnetmap().values()) {
if (snMap.getId().equals(sm.getId())) {
continue;
}
LOG.info("updateVpnInstanceWithIpFamily: Successfully {} IP family {} to Vpn {}",
add == true ? "added" : "removed", ipVersion, vpnName);
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
- CONFIGURATION, tx -> tx.merge(vpnIdentifier, builder.build(), false)));
+ CONFIGURATION, tx -> tx.mergeParentStructureMerge(vpnIdentifier, builder.build())));
});
return;
}
VpnInstanceOpDataEntryBuilder builder = new VpnInstanceOpDataEntryBuilder(vpnInstanceOpDataEntry);
builder.setBgpvpnType(choice);
ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
- tx.merge(id, builder.build(), false);
+ tx.merge(id, builder.build());
LOG.debug("updateVpnInstanceOpWithType: sent merge to operDS BgpvpnType {} for {}", choice, vpn.getValue());
}), LOG, "Error updating VPN instance op {} with type {}", vpn, choice);
}
LogicalDatastoreType.OPERATIONAL, id);
List<Uint64> dpns = new ArrayList<>();
if (routerDpnListData.isPresent()) {
- for (DpnVpninterfacesList dpnVpnInterface : routerDpnListData.get().nonnullDpnVpninterfacesList()) {
+ for (DpnVpninterfacesList dpnVpnInterface
+ : routerDpnListData.get().nonnullDpnVpninterfacesList().values()) {
dpns.add(dpnVpnInterface.getDpnId());
}
}
List<String> rd = vpnInstance.getRouteDistinguisher();
List<String> ertList = new ArrayList<>();
List<String> irtList = new ArrayList<>();
- for (VpnTarget vpnTarget : vpnInstance.getVpnTargets().nonnullVpnTarget()) {
+ for (VpnTarget vpnTarget : vpnInstance.getVpnTargets().nonnullVpnTarget().values()) {
if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ExportExtcommunity) {
ertList.add(vpnTarget.getVrfRTValue());
}
import java.util.Collections;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
-
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elanmanager.api.ElanHelper;
import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
}
elanInstanceBuilder.addAugmentation(EvpnAugmentation.class, evpnAugmentationBuilder.build());
- tx.put(elanIid, elanInstanceBuilder.build(), WriteTransaction.CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(elanIid, elanInstanceBuilder.build());
}), LOG, "Error updating ELAN with VPN info {}, {}, {}", elanInstanceName, vpnInstance, operation);
}
evpnRdToNetworkBuilder.setNetworkId(elanInstanceName);
LOG.info("updating Evpn {} with elaninstance {} and rd {}",
vpnInstance.getVpnInstanceName(), elanInstanceName, rd);
- tx.put(rdToNetworkIdentifier,
- evpnRdToNetworkBuilder.build(), WriteTransaction.CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(rdToNetworkIdentifier,
+ evpnRdToNetworkBuilder.build());
}
})));
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.apache.karaf.shell.commands.Command;
DhcpConfig currentConfig = SingleTransactionDataBroker.syncRead(dataBroker, CONFIGURATION, iid);
if (currentConfig != null && currentConfig.getConfigs() != null
&& !currentConfig.getConfigs().isEmpty()) {
- Configs dhcpConfig = currentConfig.getConfigs().get(0);
+ Configs dhcpConfig = new ArrayList<Configs>(currentConfig.getConfigs().values()).get(0);
if (dhcpConfig.getLeaseDuration() != null) {
currLeaseDuration = dhcpConfig.getLeaseDuration();
}
import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
+import java.util.ArrayList;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DhcpConfig;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.dhcp.config.Configs;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
InstanceIdentifier<DhcpConfig> iid = InstanceIdentifier.create(DhcpConfig.class);
DhcpConfig dhcpConfig = SingleTransactionDataBroker.syncRead(dataBroker, CONFIGURATION, iid);
if (isDhcpConfigAvailable(dhcpConfig)) {
- leaseDuration = dhcpConfig.getConfigs().get(0).getLeaseDuration();
- defDomain = dhcpConfig.getConfigs().get(0).getDefaultDomain();
+ leaseDuration = new ArrayList<Configs>(dhcpConfig.getConfigs().values()).get(0).getLeaseDuration();
+ defDomain = new ArrayList<Configs>(dhcpConfig.getConfigs().values()).get(0).getDefaultDomain();
} else {
session.getConsole().println("DHCP Config not present");
LOG.error("doExecute: DHCP Config not present");
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
-
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
InstanceIdentifier.builder(SubnetOpData.class).build();
Optional<SubnetOpData> optionalSubnetOpData = syncReadOptional(dataBroker, OPERATIONAL, subOpIdentifier);
if (optionalSubnetOpData.isPresent()) {
- List<SubnetOpDataEntry> subnetOpDataEntryList = optionalSubnetOpData.get().getSubnetOpDataEntry();
+ List<SubnetOpDataEntry> subnetOpDataEntryList
+ = new ArrayList<SubnetOpDataEntry>(optionalSubnetOpData.get().getSubnetOpDataEntry().values());
System.out.println("number of subnetOpDataEntry found are : " + subnetOpDataEntryList + "\n");
subnetOpDataEntryList.forEach(subnetOpDataEntry -> {
SubnetOpDataEntry data = subnetOpDataEntry;
InstanceIdentifier<Subnetmaps> subMapIdentifier = InstanceIdentifier.builder(Subnetmaps.class).build();
Optional<Subnetmaps> optionalSubnetmaps = syncReadOptional(dataBroker, CONFIGURATION, subMapIdentifier);
if (optionalSubnetmaps.isPresent()) {
- List<Subnetmap> subnetMapList = optionalSubnetmaps.get().getSubnetmap();
- System.out.println("number of subnetmaps found are : " + subnetMapList.size() + "\n");
- subnetMapList.forEach(sn -> {
+ Map<SubnetmapKey, Subnetmap> keySubnetmapMap = optionalSubnetmaps.get().getSubnetmap();
+ System.out.println("number of subnetmaps found are : " + keySubnetmapMap.size() + "\n");
+ keySubnetmapMap.values().forEach(sn -> {
if (sn != null) {
System.out.println("Fetching subnetmap for given subnetId\n");
System.out.println("------------------------"
if (!optionalSubnetmaps.isPresent()) {
System.out.println("No Subnetmaps configured.");
} else {
- subnetmapList = optionalSubnetmaps.get().getSubnetmap();
+ subnetmapList = new ArrayList<Subnetmap>(optionalSubnetmaps.get().getSubnetmap().values());
}
Optional<SubnetOpData> optionalSubnetOpData = syncReadOptional(dataBroker, OPERATIONAL, subOpIdentifier);
if (!optionalSubnetOpData.isPresent()) {
System.out.println("No SubnetOpData configured.");
} else {
- subnetOpDataEntryList = optionalSubnetOpData.get().getSubnetOpDataEntry();
+ subnetOpDataEntryList
+ = new ArrayList<SubnetOpDataEntry>(optionalSubnetOpData.get().getSubnetOpDataEntry().values());
}
for (SubnetOpDataEntry subnetOpDataEntry : subnetOpDataEntryList) {
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
-
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
if (!optionalNeutronVpnPort.isPresent()) {
System.out.println("No NeutronVpnPortIpToPortData configured.");
} else {
- vpnPortipToPortList = optionalNeutronVpnPort.get().getVpnPortipToPort();
+ vpnPortipToPortList
+ = new ArrayList<VpnPortipToPort>(optionalNeutronVpnPort.get().getVpnPortipToPort().values());
}
}
if (!optionalLearntVpnPort.isPresent()) {
System.out.println("No LearntVpnVipToPortData discovered.");
} else {
- vpnVipToPortList = optionalLearntVpnPort.get().getLearntVpnVipToPort();
+ vpnVipToPortList = new ArrayList<LearntVpnVipToPort>(optionalLearntVpnPort.get()
+ .getLearntVpnVipToPort().values());
}
}
<modelVersion>4.0.0</modelVersion>
<dependencies>
- <dependency>
+ <!--dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<artifactId>opendaylight-l2-types</artifactId>
- </dependency>
+ </dependency-->
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>aclservice-api</artifactId>
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
<artifactId>vpnmanager-api</artifactId>
<version>${project.version}</version>
</dependency>
- <dependency>
+ <!--dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-api-mockito</artifactId>
<scope>test</scope>
- </dependency>
+ </dependency-->
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-module-junit4</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>
<groupId>org.opendaylight.mdsal.binding.model.iana</groupId>
<artifactId>iana-if-type</artifactId>
</dependency>
- <dependency>
+ <!--dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<artifactId>yang-ext</artifactId>
- </dependency>
+ </dependency-->
</dependencies>
</project>
package org.opendaylight.netvirt.qosservice;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import java.util.List;
+import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.qosalert.config.rev170301.QosalertConfigBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMapKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.Uint64;
.build();
ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> tx.put(path, qosAlertConfig,
- CREATE_MISSING_PARENTS)), LOG, "Error writing to the config data store");
+ tx -> tx.mergeParentStructurePut(path,
+ qosAlertConfig)), LOG, "Error writing to the config data store");
}
private void pollDirectStatisticsForAllNodes() {
GetNodeConnectorStatisticsOutput nodeConnectorStatisticsOutput = rpcResult.getResult();
- List<NodeConnectorStatisticsAndPortNumberMap> nodeConnectorStatisticsAndPortNumberMapList =
+ Map<NodeConnectorStatisticsAndPortNumberMapKey, NodeConnectorStatisticsAndPortNumberMap>
+ nodeConnectorStatisticsAndPortNumberMap =
nodeConnectorStatisticsOutput.getNodeConnectorStatisticsAndPortNumberMap();
ConcurrentMap<String, QosAlertPortData> portDataMap = entry.getValue();
- for (NodeConnectorStatisticsAndPortNumberMap stats : nodeConnectorStatisticsAndPortNumberMapList) {
+ for (NodeConnectorStatisticsAndPortNumberMap stats
+ : nodeConnectorStatisticsAndPortNumberMap.values()) {
QosAlertPortData portData = portDataMap.get(stats.getNodeConnectorId().getValue());
if (portData != null) {
portData.updatePortStatistics(stats);
tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
try {
if (writeConfigTxn != null) {
- writeConfigTxn.merge(InstanceIdentifier
+ writeConfigTxn.mergeParentStructureMerge(InstanceIdentifier
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundUtils.OVSDB_TOPOLOGY_ID))
.child(Node.class, bridgeNode.get().key())
- .child(TerminationPoint.class, new TerminationPointKey(tp.key())), tpBuilder.build(), true);
+ .child(TerminationPoint.class, new TerminationPointKey(tp.key())), tpBuilder.build());
} else {
MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier
.create(NetworkTopology.class)
public int getIpVersions(Port port) {
int versions = 0;
- for (FixedIps fixedIp: port.getFixedIps()) {
+ for (FixedIps fixedIp: port.getFixedIps().values()) {
if (fixedIp.getIpAddress().getIpv4Address() != null) {
versions |= (1 << QosConstants.IPV4_ADDR_MASK_BIT);
} else if (fixedIp.getIpAddress().getIpv6Address() != null) {
}
@NonNull List<BandwidthLimitRules> nonnullBandwidthLimitRules =
- qosNeutronUtils.getQosPolicyMap().get(policyUuid).nonnullBandwidthLimitRules();
+ new ArrayList<BandwidthLimitRules>(qosNeutronUtils.getQosPolicyMap().get(policyUuid)
+ .nonnullBandwidthLimitRules().values());
if (!nonnullBandwidthLimitRules.isEmpty()) {
BandwidthLimitRules bandwidthLimitRules = nonnullBandwidthLimitRules.get(0);
update(policyUuid, bandwidthLimitRules);
}
@NonNull List<DscpmarkingRules> nonnullDscpmarkingRules =
- qosNeutronUtils.getQosPolicyMap().get(policyUuid).nonnullDscpmarkingRules();
+ new ArrayList<DscpmarkingRules>(qosNeutronUtils.getQosPolicyMap().get(policyUuid)
+ .nonnullDscpmarkingRules().values());
if (!nonnullDscpmarkingRules.isEmpty()) {
DscpmarkingRules dscpmarkingRules = nonnullDscpmarkingRules.get(0);
update(policyUuid, dscpmarkingRules);
tpAugmentationBuilder.setIngressPolicingRate(bwRule.getMaxKbps().longValue());
tpAugmentationBuilder.setIngressPolicingBurst(bwRule.getMaxBurstKbps().longValue());
- tx.merge(InstanceIdentifier.create(NetworkTopology.class)
+ tx.mergeParentStructureMerge(InstanceIdentifier.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundUtils.OVSDB_TOPOLOGY_ID))
.child(Node.class, identifier.firstKeyOf(Node.class))
.child(TerminationPoint.class, identifier.firstKeyOf(TerminationPoint.class))
.augmentation(OvsdbTerminationPointAugmentation.class),
- tpAugmentationBuilder.build(), true);
+ tpAugmentationBuilder.build());
})));
}
@Nullable
private String getIfaceId(OvsdbTerminationPointAugmentation tpAugmentation) {
if (tpAugmentation.getInterfaceExternalIds() != null) {
- for (InterfaceExternalIds entry: tpAugmentation.getInterfaceExternalIds()) {
+ for (InterfaceExternalIds entry: tpAugmentation.getInterfaceExternalIds().values()) {
if (EXTERNAL_ID_INTERFACE_ID.equals(entry.getExternalIdKey())) {
return entry.getExternalIdValue();
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<!-- <dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
import java.math.BigInteger;
import java.util.List;
-
-import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
import org.opendaylight.genius.mdsalutil.MatchInfoBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public abstract class AbstractCountersService {
*/
package org.opendaylight.netvirt.statistics;
+import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.netvirt.statistics.api.ICountersInterfaceChangeHandler;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
private static AtomicLong flowIdInc = new AtomicLong(2);
- private CountersServiceUtils() { }
+ private CountersServiceUtils() {
+
+ }
public static BoundServices getBoundServices(String serviceName, short servicePriority, int flowPriority,
BigInteger cookie, List<Instruction> instructions) {
private static final Collection<String> UNACCUMULATED_COUNTER_GROUPS = ImmutableSet.of("Duration");
- private CountersUtils() { }
+ private CountersUtils() {
+
+ }
public static String getNodeId(BigInteger dpId) {
return IfmConstants.OF_URI_PREFIX + dpId;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
import org.opendaylight.genius.mdsalutil.MatchInfoBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeEgress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
import org.opendaylight.genius.mdsalutil.MatchInfoBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeIngress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
*/
package org.opendaylight.netvirt.statistics;
-import java.util.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.ReadTransaction;
-import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
-import org.opendaylight.mdsal.binding.api.WriteTransaction;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.mdsalutil.MatchInfoBase;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.statistics.api.ICountersInterfaceChangeHandler;
import org.opendaylight.netvirt.vpnmanager.api.InterfaceUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
IngressElementCountersRequestConfigBuilder ecrcb = new IngressElementCountersRequestConfigBuilder();
ecrcb.setCounterRequests(counterRequests);
requestConfig = ecrcb.build();
- transaction.put(LogicalDatastoreType.CONFIGURATION, ecrcIdentifier, requestConfig,
- WriteTransaction.CREATE_MISSING_PARENTS);
+ transaction.mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, ecrcIdentifier, requestConfig);
}
private void putEgressElementCounterRequestInConfig(AcquireElementCountersRequestHandlerInput input,
EgressElementCountersRequestConfigBuilder ecrcb = new EgressElementCountersRequestConfigBuilder();
ecrcb.setCounterRequests(counterRequests);
requestConfig = ecrcb.build();
- transaction.put(LogicalDatastoreType.CONFIGURATION, ecrcIdentifier, requestConfig,
- WriteTransaction.CREATE_MISSING_PARENTS);
+ transaction.put(LogicalDatastoreType.CONFIGURATION, ecrcIdentifier, requestConfig);
}
private void creatIngressEelementCountersContainerInConfig(ReadWriteTransaction transaction,
List<CounterRequests> counterRequests = new ArrayList<>();
iecrcb.setCounterRequests(counterRequests);
IngressElementCountersRequestConfig iecrc = iecrcb.build();
- transaction.put(LogicalDatastoreType.CONFIGURATION, ecrcIdentifier, iecrc,
- WriteTransaction.CREATE_MISSING_PARENTS);
+ transaction.put(LogicalDatastoreType.CONFIGURATION, ecrcIdentifier, iecrc);
}
private void creatEgressEelementCountersContainerInConfig(ReadWriteTransaction transaction,
List<CounterRequests> counterRequests = new ArrayList<>();
eecrcb.setCounterRequests(counterRequests);
EgressElementCountersRequestConfig eecrc = eecrcb.build();
- transaction.put(LogicalDatastoreType.CONFIGURATION, ecrcIdentifier, eecrc,
- WriteTransaction.CREATE_MISSING_PARENTS);
+ transaction.put(LogicalDatastoreType.CONFIGURATION, ecrcIdentifier, eecrc);
}
private Integer allocateId(String idKey) {
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.RpcProviderService;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.statistics.rev170120.StatisticsService;
import org.slf4j.Logger;
<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.mdsal.binding.model.ietf</groupId>
<artifactId>rfc7223</artifactId>
</dependency>
- <dependency>
+ <!--dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<artifactId>yang-ext</artifactId>
- </dependency>
+ </dependency-->
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>bgpmanager-api</artifactId>
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 java.util.concurrent.Future;
LOG.error("getUsedRds: failed to read Used Rds for vpn {} destprefix {} due to exception", vpnId,
destPrefix, e);
}
- return usedRds.isPresent() && usedRds.get().getAllocatedRds() != null ? usedRds.get().getAllocatedRds().stream()
+ return usedRds.isPresent() && usedRds.get().getAllocatedRds() != null
+ ? usedRds.get().getAllocatedRds().values().stream()
.map(AllocatedRds::getRd).distinct().collect(toList()) : new ArrayList<>();
}
public static List<String> getUsedRds(TypedReadTransaction<Configuration> confTx, Uint32 vpnId, String destPrefix)
throws ExecutionException, InterruptedException {
Optional<DestPrefixes> usedRds = confTx.read(getUsedRdsIdentifier(vpnId, destPrefix)).get();
- return usedRds.isPresent() && usedRds.get().getAllocatedRds() != null ? usedRds.get().getAllocatedRds().stream()
+ return usedRds.isPresent() && usedRds.get().getAllocatedRds() != null
+ ? usedRds.get().getAllocatedRds().values().stream()
.map(AllocatedRds::getRd).distinct().collect(toList()) : new ArrayList<>();
}
try {
Optional<ExtrarouteRds> optionalExtraRoutes = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION,
getUsedRdsIdentifier(vpnId));
- List<DestPrefixes> prefixes = optionalExtraRoutes.map(ExtrarouteRds::getDestPrefixes).orElse(null);
- return prefixes == null ? Collections.emptyList() : prefixes;
+ Map<DestPrefixesKey, DestPrefixes> prefixesMap
+ = optionalExtraRoutes.map(ExtrarouteRds::getDestPrefixes).orElse(null);
+ return prefixesMap == null ? Collections.emptyList() : new ArrayList<DestPrefixes>(prefixesMap.values());
} catch (ExecutionException | InterruptedException e) {
LOG.error("getExtraRouteDestPrefixes: failed to read ExRoutesRdsMap for vpn {} due to exception", vpnId, e);
}
InstanceIdentifier<VpnInstances> id = InstanceIdentifier.builder(VpnInstances.class).build();
Optional<VpnInstances> optVpnInstances = read(broker, LogicalDatastoreType.CONFIGURATION, id);
if (optVpnInstances.isPresent() && optVpnInstances.get().getVpnInstance() != null) {
- return optVpnInstances.get().getVpnInstance();
+ return new ArrayList<VpnInstance>(optVpnInstances.get().getVpnInstance().values());
} else {
return Collections.emptyList();
}
@Nullable
public static String getFirstVpnNameFromVpnInterface(final VpnInterface original) {
- List<VpnInstanceNames> optList = original.getVpnInstanceNames();
+ List<VpnInstanceNames> optList = new ArrayList<VpnInstanceNames>(original.getVpnInstanceNames().values());
if (optList != null && !optList.isEmpty()) {
return optList.get(0).getVpnName();
} else {
import java.util.List;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
-
import org.opendaylight.yangtools.yang.common.Uint32;
public interface IVpnLinkService {
</dependency>-->
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <artifactId>mdsal-binding-test-utils</artifactId>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.genius</groupId>
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ExecutionException;
import javax.annotation.PreDestroy;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.NaptSwitches;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitch;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint64;
Uuid extNetworkId = router.getNetworkId();
String extGwMacAddress = router.getExtGwMacAddress();
String routerName = router.getRouterName();
- List<ExternalIps> externalIps = router.getExternalIps();
- if (externalIps.isEmpty()) {
+ Map<ExternalIpsKey, ExternalIps> externalIpsMap = router.getExternalIps();
+ if (externalIpsMap.isEmpty()) {
LOG.error("CentralizedSwitchChangeListener: setupRouterGwFlows no externalIP present");
return;
}
- for (ExternalIps extIp : router.nonnullExternalIps()) {
+ for (ExternalIps extIp : router.nonnullExternalIps().values()) {
Uuid subnetVpnName = extIp.getSubnetId();
if (addOrRemove == NwConstants.ADD_FLOW) {
vpnManager.addRouterGwMacFlow(routerName, extGwMacAddress, primarySwitchId, extNetworkId,
if (addOrRemove == NwConstants.ADD_FLOW) {
vpnManager.addArpResponderFlowsToExternalNetworkIps(routerName,
- VpnUtil.getIpsListFromExternalIps(router.getExternalIps()),
+ VpnUtil.getIpsListFromExternalIps(new ArrayList<ExternalIps>(router.getExternalIps().values())),
extGwMacAddress, primarySwitchId, extNetworkId);
} else {
vpnManager.removeArpResponderFlowsToExternalNetworkIps(routerName,
- VpnUtil.getIpsListFromExternalIps(router.getExternalIps()),
+ VpnUtil.getIpsListFromExternalIps(new ArrayList<ExternalIps>(router.getExternalIps().values())),
extGwMacAddress, primarySwitchId, extNetworkId);
}
}
import java.math.BigInteger;
import java.util.Collection;
-import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.locks.ReentrantLock;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.remove.dpn.event.RemoveEventData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
if (vpnOpValue.isPresent()) {
VpnInstanceOpDataEntry vpnInstOpData = vpnOpValue.get();
- List<VpnToDpnList> vpnToDpnList = vpnInstOpData.nonnullVpnToDpnList();
+ Map<VpnToDpnListKey, VpnToDpnList> vpnToDpnMap = vpnInstOpData.nonnullVpnToDpnList();
boolean flushDpnsOnVpn = true;
- for (VpnToDpnList dpn : vpnToDpnList) {
+ for (VpnToDpnList dpn : vpnToDpnMap.values()) {
if (dpn.getDpnState() == VpnToDpnList.DpnState.Active) {
flushDpnsOnVpn = false;
break;
if (flushDpnsOnVpn) {
try {
txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
- tx -> deleteDpn(vpnToDpnList, rd, tx)).get();
+ tx -> deleteDpn(vpnToDpnMap.values(), rd, tx)).get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error removing dpnToVpnList for vpn {} ", vpnName);
throw new RuntimeException(e.getMessage(), e);
LOG.trace("Remove Fib event - Key : {}, value : {} ", identifier, del);
final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class);
String rd = key.getRouteDistinguisher();
- List<RoutePaths> routePaths = del.getRoutePaths();
+ List<RoutePaths> routePaths = new ArrayList<RoutePaths>(del.getRoutePaths().values());
removeLabelFromVpnInstance(rd, routePaths);
}
VrfEntry original, VrfEntry update) {
final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class);
String rd = key.getRouteDistinguisher();
- List<RoutePaths> originalRoutePaths = new ArrayList<>(original.getRoutePaths());
- List<RoutePaths> updateRoutePaths = new ArrayList<>(update.getRoutePaths());
+ List<RoutePaths> originalRoutePaths = new ArrayList<RoutePaths>(original.getRoutePaths().values());
+ List<RoutePaths> updateRoutePaths = new ArrayList<RoutePaths>(update.getRoutePaths().values());
if (originalRoutePaths.size() < updateRoutePaths.size()) {
updateRoutePaths.removeAll(originalRoutePaths);
addLabelToVpnInstance(rd, updateRoutePaths);
LOG.trace("Add Vrf Entry event - Key : {}, value : {}", identifier, add);
final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class);
String rd = key.getRouteDistinguisher();
- addLabelToVpnInstance(rd, add.getRoutePaths());
+ addLabelToVpnInstance(rd, new ArrayList<RoutePaths>(add.getRoutePaths().values()));
}
private void addLabelToVpnInstance(String rd, List<RoutePaths> routePaths) {
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn._interface.op.data.VpnInterfaceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.Adjacencies;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.Adjacency;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.AdjacencyKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.vpn._interface.VpnInstanceNames;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
final VpnInterface vpnIf = vpnUtil.getConfiguredVpnInterface(interfaceName);
if (vpnIf != null) {
for (VpnInstanceNames vpnInterfaceVpnInstance :
- vpnIf.nonnullVpnInstanceNames()) {
+ vpnIf.nonnullVpnInstanceNames().values()) {
String vpnName = vpnInterfaceVpnInstance.getVpnName();
String primaryRd = vpnUtil.getPrimaryRd(vpnName);
if (!vpnInterfaceManager.isVpnInstanceReady(vpnName)) {
return;
}
for (VpnInstanceNames vpnInterfaceVpnInstance :
- cfgVpnInterface.nonnullVpnInstanceNames()) {
+ cfgVpnInterface.nonnullVpnInstanceNames().values()) {
String vpnName = vpnInterfaceVpnInstance.getVpnName();
Optional<VpnInterfaceOpDataEntry> optVpnInterface =
vpnUtil.getVpnInterfaceOpDataEntry(ifName, vpnName);
if (state.equals(IntfTransitionState.STATE_UP)
&& vpnIf.getVpnInstanceNames() != null) {
for (VpnInstanceNames vpnInterfaceVpnInstance :
- vpnIf.getVpnInstanceNames()) {
+ vpnIf.getVpnInstanceNames().values()) {
String vpnName = vpnInterfaceVpnInstance.getVpnName();
String primaryRd = vpnUtil.getPrimaryRd(vpnName);
Set<String> prefixes = new HashSet<>();
} else if (state.equals(IntfTransitionState.STATE_DOWN)
&& vpnIf.getVpnInstanceNames() != null) {
for (VpnInstanceNames vpnInterfaceVpnInstance :
- vpnIf.getVpnInstanceNames()) {
+ vpnIf.getVpnInstanceNames().values()) {
String vpnName = vpnInterfaceVpnInstance.getVpnName();
LOG.info("VPN Interface update event - intfName {} "
+ " onto vpnName {} running oper-driven DOWN",
String interfaceName = cfgVpnInterface.getName();
Adjacencies adjacencies = cfgVpnInterface.augmentation(Adjacencies.class);
if (adjacencies != null) {
- List<Adjacency> adjacencyList = adjacencies.getAdjacency();
- if (!adjacencyList.isEmpty()) {
- for (Adjacency adj : adjacencyList) {
+ Map<AdjacencyKey, Adjacency> adjacencyMap = adjacencies.getAdjacency();
+ if (!adjacencyMap.isEmpty()) {
+ for (Adjacency adj : adjacencyMap.values()) {
if (adj.getAdjacencyType() != Adjacency.AdjacencyType.PrimaryAdjacency) {
String ipAddress = adj.getIpAddress();
String prefix = ipAddress.split("/")[0];
}
SubnetToDpnBuilder subDpnBuilder = new SubnetToDpnBuilder(subDpn);
List<VpnInterfaces> vpnIntfList = new ArrayList<>();
- vpnIntfList = subDpnBuilder.getVpnInterfaces() != null ? new ArrayList<>(subDpnBuilder.getVpnInterfaces())
- : vpnIntfList;
+ vpnIntfList = subDpnBuilder.getVpnInterfaces() != null
+ ? new ArrayList<>(subDpnBuilder.getVpnInterfaces().values()) : vpnIntfList;
VpnInterfaces vpnIntfs =
new VpnInterfacesBuilder().withKey(new VpnInterfacesKey(intfName)).setInterfaceName(intfName).build();
SubnetToDpnBuilder subDpnBuilder = new SubnetToDpnBuilder(optionalSubDpn.get());
List<VpnInterfaces> vpnIntfList = new ArrayList<>();
vpnIntfList = (subDpnBuilder.getVpnInterfaces() != null && !subDpnBuilder.getVpnInterfaces().isEmpty())
- ? new ArrayList<>(subDpnBuilder.getVpnInterfaces()) : vpnIntfList;
+ ? new ArrayList<>(subDpnBuilder.getVpnInterfaces().values()) : vpnIntfList;
VpnInterfaces vpnIntfs =
new VpnInterfacesBuilder().withKey(new VpnInterfacesKey(intfName)).setInterfaceName(intfName).build();
vpnIntfList.remove(vpnIntfs);
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.annotation.PreDestroy;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.vpn._interface.VpnInstanceNames;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint64;
}
boolean interfaceDownEligible = false;
for (VpnInstanceNames vpnInterfaceVpnInstance :
- cfgVpnInterface.get().nonnullVpnInstanceNames()) {
+ cfgVpnInterface.get().nonnullVpnInstanceNames().values()) {
String vpnName = vpnInterfaceVpnInstance.getVpnName();
InstanceIdentifier<VpnInterfaceOpDataEntry> idOper = VpnUtil
.getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnName);
}
boolean interfaceChangeEligible = false;
for (VpnInstanceNames vpnInterfaceVpnInstance :
- cfgVpnInterface.get().nonnullVpnInstanceNames()) {
+ cfgVpnInterface.get().nonnullVpnInstanceNames().values()) {
String vpnName = vpnInterfaceVpnInstance.getVpnName();
InstanceIdentifier<VpnInterfaceOpDataEntry> idOper = VpnUtil
.getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnName);
if (port == null) {
return listSubnetIds;
}
- List<FixedIps> portIps = port.getFixedIps();
- if (portIps != null) {
- for (FixedIps portIp : portIps) {
+ Map<FixedIpsKey, FixedIps> portIpsMap = port.getFixedIps();
+ if (portIpsMap != null) {
+ for (FixedIps portIp : portIpsMap.values()) {
listSubnetIds.add(portIp.getSubnetId());
}
}
import com.google.common.primitives.Ints;
import java.net.InetAddress;
import java.net.UnknownHostException;
+import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.vpn._interface.VpnInstanceNames;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
return;
}
if (VpnHelper.doesVpnInterfaceBelongToVpnInstance(vpnIdVpnInstanceName,
- vmVpnInterface.getVpnInstanceNames())
+ new ArrayList<VpnInstanceNames>(vmVpnInterface.getVpnInstanceNames().values()))
&& !vpnUtil.isBgpVpnInternet(vpnIdVpnInstanceName)) {
LOG.trace("Unknown IP is in internal network");
handlePacketToInternalNetwork(dstIp, dstIpStr, elanTag, srcIpStr);
} else {
LOG.trace("Unknown IP is in external network");
- String vpnName = vpnUtil.getInternetVpnFromVpnInstanceList(vmVpnInterface.getVpnInstanceNames());
+ String vpnName = vpnUtil.getInternetVpnFromVpnInstanceList(
+ new ArrayList<VpnInstanceNames>(vmVpnInterface.getVpnInstanceNames().values()));
if (vpnName != null) {
handlePacketToExternalNetwork(new Uuid(vpnIdVpnInstanceName), vpnName, dstIp, dstIpStr, elanTag);
} else {
return;
}
- List<ExternalIps> externalIps = externalRouter.getExternalIps();
- if (externalIps == null || externalIps.isEmpty()) {
+ Map<ExternalIpsKey, ExternalIps> externalIpsMap = externalRouter.getExternalIps();
+ if (externalIpsMap == null || externalIpsMap.isEmpty()) {
Counter counter = packetInCounter.label(CounterUtility.subnet_route_packet_failed.toString())
.label("." + dstIpStr);
counter.increment();
return;
}
- java.util.Optional<ExternalIps> externalIp = externalRouter.getExternalIps().stream()
+ java.util.Optional<ExternalIps> externalIp = externalRouter.getExternalIps().values().stream()
.filter(eip -> vpnInstanceNameUuid.equals(eip.getSubnetId())).findFirst();
if (!externalIp.isPresent()) {
Counter counter = packetInCounter.label(CounterUtility.subnet_route_packet_failed.toString())
*/
package org.opendaylight.netvirt.vpnmanager;
-import static java.util.Collections.emptyList;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn._interface.op.data.VpnInterfaceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.Adjacency;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.AdjacencyKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.vpn._interface.VpnInstanceNames;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
}
vpnInstanceOpData.stream()
.filter(opData -> opData.getVpnToDpnList() != null
- && opData.getVpnToDpnList().stream().anyMatch(
+ && opData.getVpnToDpnList().values().stream().anyMatch(
vpnToDpn -> Objects.equals(vpnToDpn.getDpnId(), srcDpnId)))
.forEach(opData -> {
List<DestPrefixes> prefixes = VpnExtraRouteHelper.getExtraRouteDestPrefixes(dataBroker,
if (vrfEntry == null || vrfEntry.getRoutePaths() == null) {
return;
}
- List<RoutePaths> routePaths = vrfEntry.getRoutePaths();
+ List<RoutePaths> routePaths = new ArrayList<RoutePaths>(vrfEntry.getRoutePaths().values());
routePaths.forEach(routePath -> {
if (Objects.equals(routePath.getNexthopAddress(), srcTepIp)) {
String prefix = destPrefix.getDestPrefix();
vpnUtil.getConfiguredVpnInterface(intfName);
if (vpnInterface != null) {
listVpnName.addAll(VpnHelper
- .getVpnInterfaceVpnInstanceNamesString(vpnInterface.getVpnInstanceNames()));
+ .getVpnInterfaceVpnInstanceNamesString(
+ new ArrayList<VpnInstanceNames>(vpnInterface.getVpnInstanceNames().values())));
handleTunnelEventForDPNVpn(stateTunnelList, vpnIdRdMap,
tunnelAction, isTepDeletedOnDpn,
subnetList, TunnelEventProcessingMethod.POPULATESUBNETS,
return;
}
try {
- for (VpnInstanceNames vpnInstance : cfgVpnInterface.getVpnInstanceNames()) {
+ for (VpnInstanceNames vpnInstance : cfgVpnInterface.getVpnInstanceNames().values()) {
String vpnName = vpnInstance.getVpnName();
if (method == TunnelEventProcessingMethod.POPULATESUBNETS) {
Optional<VpnInterfaceOpDataEntry> opVpnInterface = vpnUtil
if (opVpnInterface.isPresent()) {
VpnInterfaceOpDataEntry vpnInterface = opVpnInterface.get();
AdjacenciesOp adjacencies = vpnInterface.augmentation(AdjacenciesOp.class);
- List<Adjacency> adjList =
+ Map<AdjacencyKey, Adjacency> adjacencyKeyAdjacencyMap =
adjacencies != null && adjacencies.getAdjacency() != null ? adjacencies.getAdjacency()
- : emptyList();
+ : Collections.<AdjacencyKey, Adjacency>emptyMap();
String prefix = null;
Uint32 vpnId = vpnUtil.getVpnId(vpnInterface.getVpnInstanceName());
if (vpnIdRdMap.containsKey(vpnId)) {
LOG.info("handleTunnelEventForDPN: Remote DpnId {} VpnId {} rd {} VpnInterface {}"
+ " srcTepIp {} destTepIp {}", remoteDpnId, vpnId, rd , vpnInterface, srcTepIp,
destTepIp);
- for (Adjacency adj : adjList) {
+ for (Adjacency adj : adjacencyKeyAdjacencyMap.values()) {
prefix = adj.getIpAddress();
Uint32 label = adj.getLabel();
if (tunnelAction == TunnelAction.TUNNEL_EP_ADD
package org.opendaylight.netvirt.vpnmanager;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicBoolean;
Optional<VpnToDpnList> dpnInVpn = tx.read(id).get();
if (dpnInVpn.isPresent()) {
VpnToDpnList vpnToDpnList = dpnInVpn.get();
- List<VpnInterfaces> vpnInterfaces = new ArrayList<>(vpnToDpnList.nonnullVpnInterfaces());
+ List<VpnInterfaces> vpnInterfaces = new ArrayList<>(vpnToDpnList.nonnullVpnInterfaces().values());
vpnInterfaces.add(vpnInterface);
VpnToDpnListBuilder vpnToDpnListBuilder = new VpnToDpnListBuilder(vpnToDpnList);
vpnToDpnListBuilder.setDpnState(VpnToDpnList.DpnState.Active).setVpnInterfaces(vpnInterfaces);
- tx.put(id, vpnToDpnListBuilder.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(id, vpnToDpnListBuilder.build());
/*
* If earlier state was inactive, it is considered new DPN coming back to the
* same VPN
VpnToDpnListBuilder vpnToDpnListBuilder = new VpnToDpnListBuilder().setDpnId(dpnId);
vpnToDpnListBuilder.setDpnState(VpnToDpnList.DpnState.Active).setVpnInterfaces(vpnInterfaces);
- tx.put(id, vpnToDpnListBuilder.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(id, vpnToDpnListBuilder.build());
newDpnOnVpn.set(true);
LOG.debug("createOrUpdateVpnToDpnList: Creating vpn footprint for vpn {} vpnId {} interface {}"
+ " on dpn {}", vpnName, vpnId, intfName, dpnId);
Optional<VpnToDpnList> dpnInVpn = tx.read(id).get();
if (dpnInVpn.isPresent()) {
VpnToDpnList vpnToDpnList = dpnInVpn.get();
- List<IpAddresses> ipAddresses = new ArrayList<>(vpnToDpnList.nonnullIpAddresses());
+ List<IpAddresses> ipAddresses = new ArrayList<>(vpnToDpnList.nonnullIpAddresses().values());
ipAddresses.add(ipAddressesBldr.build());
VpnToDpnListBuilder vpnToDpnListBuilder = new VpnToDpnListBuilder(vpnToDpnList);
vpnToDpnListBuilder.setDpnState(VpnToDpnList.DpnState.Active).setIpAddresses(ipAddresses);
- tx.put(id, vpnToDpnListBuilder.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(id, vpnToDpnListBuilder.build());
/*
* If earlier state was inactive, it is considered new DPN coming back to the
* same VPN
ipAddresses.add(ipAddressesBldr.build());
VpnToDpnListBuilder vpnToDpnListBuilder = new VpnToDpnListBuilder().setDpnId(dpnId);
vpnToDpnListBuilder.setDpnState(VpnToDpnList.DpnState.Active).setIpAddresses(ipAddresses);
- tx.put(id, vpnToDpnListBuilder.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(id, vpnToDpnListBuilder.build());
newDpnOnVpn.set(true);
}
return;
}
VpnToDpnList dpnInVpn = dpnInVpnOpt.get();
- List<VpnInterfaces> vpnInterfaces = new ArrayList<>(dpnInVpn.nonnullVpnInterfaces());
+ List<VpnInterfaces> vpnInterfaces = new ArrayList<>(dpnInVpn.nonnullVpnInterfaces().values());
if (vpnInterfaces == null) {
LOG.error("Could not find vpnInterfaces for DpnInVpn map for VPN=[name={} rd={} id={}] and "
+ "dpnId={}", vpnName, rd, id, dpnId);
VpnInterfaces currVpnInterface = new VpnInterfacesBuilder().setInterfaceName(intfName).build();
if (vpnInterfaces.remove(currVpnInterface)) {
if (vpnInterfaces.isEmpty()) {
- List<IpAddresses> ipAddresses = dpnInVpn.getIpAddresses();
+ Map<IpAddressesKey, IpAddresses> ipAddressesMap = dpnInVpn.getIpAddresses();
VpnToDpnListBuilder dpnInVpnBuilder =
- new VpnToDpnListBuilder(dpnInVpn).setVpnInterfaces(null);
- if (ipAddresses == null || ipAddresses.isEmpty()) {
+ new VpnToDpnListBuilder(dpnInVpn).setVpnInterfaces(Collections.EMPTY_LIST);
+ if (ipAddressesMap == null || ipAddressesMap.isEmpty()) {
dpnInVpnBuilder.setDpnState(VpnToDpnList.DpnState.Inactive);
lastDpnOnVpn.set(true);
} else {
}
LOG.debug("removeOrUpdateVpnToDpnList: Removing vpn footprint for vpn {} vpnId {} "
+ "interface {}, on dpn {}", vpnName, vpnName, intfName, dpnId);
- tx.put(id, dpnInVpnBuilder.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(id, dpnInVpnBuilder.build());
} else {
tx.delete(id.child(VpnInterfaces.class, new VpnInterfacesKey(intfName)));
return;
}
VpnToDpnList dpnInVpn = dpnInVpnOpt.get();
- List<IpAddresses> ipAddresses = new ArrayList<>(dpnInVpn.nonnullIpAddresses());
+ List<IpAddresses> ipAddresses = new ArrayList<>(dpnInVpn.nonnullIpAddresses().values());
if (ipAddresses == null) {
LOG.info("Could not find ipAddresses for DpnInVpn map for VPN=[name={} rd={} id={}] "
+ "and dpnId={}", vpnName, rd, id, dpnId);
.setIpAddressSource(ipAddressSourceValuePair.getKey()).build();
if (ipAddresses.remove(currIpAddress)) {
if (ipAddresses.isEmpty()) {
- List<VpnInterfaces> vpnInterfaces = dpnInVpn.getVpnInterfaces();
+ Map<VpnInterfacesKey, VpnInterfaces> vpnInterfacesMap = dpnInVpn.getVpnInterfaces();
VpnToDpnListBuilder dpnInVpnBuilder =
- new VpnToDpnListBuilder(dpnInVpn).setIpAddresses(null);
- if (vpnInterfaces == null || vpnInterfaces.isEmpty()) {
+ new VpnToDpnListBuilder(dpnInVpn).setIpAddresses(Collections.<IpAddresses>emptyList());
+ if (vpnInterfacesMap == null || vpnInterfacesMap.isEmpty()) {
dpnInVpnBuilder.setDpnState(VpnToDpnList.DpnState.Inactive);
lastDpnOnVpn.set(true);
} else {
LOG.warn("ip addresses are empty but vpn interfaces are present for the vpn {} in "
+ "dpn {}", vpnName, dpnId);
}
- tx.put(id, dpnInVpnBuilder.build(), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(id, dpnInVpnBuilder.build());
} else {
tx.delete(id.child(IpAddresses.class, new IpAddressesKey(ipAddressSourceValuePair.getValue())));
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.ExternalTunnelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnelKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.DcGatewayIpList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.dc.gateway.ip.list.DcGatewayIp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.dc.gateway.ip.list.DcGatewayIpKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryBuilder;
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance
vpnInstanceToVpnId = VpnUtil.getVpnInstanceToVpnId(vpnInstanceName, vpnId, primaryRd);
- writeConfigTxn.put(VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnInstanceName),
- vpnInstanceToVpnId, CREATE_MISSING_PARENTS);
+ writeConfigTxn.mergeParentStructurePut(VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnInstanceName),
+ vpnInstanceToVpnId);
VpnIds vpnIdToVpnInstance = VpnUtil.getVpnIdToVpnInstance(vpnId, value.getVpnInstanceName(),
primaryRd, VpnUtil.isBgpVpn(vpnInstanceName, primaryRd));
- writeConfigTxn.put(VpnUtil.getVpnIdToVpnInstanceIdentifier(vpnId), vpnIdToVpnInstance, CREATE_MISSING_PARENTS);
+ writeConfigTxn.mergeParentStructurePut(VpnUtil.getVpnIdToVpnInstanceIdentifier(vpnId), vpnIdToVpnInstance);
try {
String cachedTransType = fibManager.getConfTransType();
}
VpnTargets vpnTargets = value.getVpnTargets();
if (vpnTargets != null) {
- List<VpnTarget> vpnTargetList = vpnTargets.getVpnTarget();
- if (vpnTargetList != null) {
- for (VpnTarget vpnTarget : vpnTargetList) {
+ @Nullable Map<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn
+ .instances.vpn.instance.vpntargets.VpnTargetKey, VpnTarget> vpnTargetListMap
+ = vpnTargets.getVpnTarget();
+ if (vpnTargetListMap != null) {
+ for (VpnTarget vpnTarget : vpnTargetListMap.values()) {
VpnTargetBuilder vpnTargetBuilder =
new VpnTargetBuilder().withKey(new VpnTargetKey(vpnTarget.key().getVrfRTValue()))
.setVrfRTType(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
} else {
builder.setBgpvpnType(VpnInstanceOpDataEntry.BgpvpnType.VPN);
}
- writeOperTxn.merge(VpnUtil.getVpnInstanceOpDataIdentifier(primaryRd), builder.build(), CREATE_MISSING_PARENTS);
+ writeOperTxn.mergeParentStructureMerge(VpnUtil.getVpnInstanceOpDataIdentifier(primaryRd), builder.build());
LOG.info("{} addVpnInstance: VpnInstanceOpData populated successfully for vpn {} rd {}", LOGGING_PREFIX_ADD,
vpnInstanceName, primaryRd);
}
@SuppressWarnings("checkstyle:IllegalCatch")
private boolean addBgpVrf() {
String primaryRd = vpnUtil.getPrimaryRd(vpnName);
- List<VpnTarget> vpnTargetList = vpnInstance.getVpnTargets().getVpnTarget();
+ @Nullable Map<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn
+ .instances.vpn.instance.vpntargets.VpnTargetKey, VpnTarget> vpnTargetList
+ = vpnInstance.getVpnTargets().getVpnTarget();
if (vpnTargetList == null) {
log.error("{} addBgpVrf: vpn target list is empty for vpn {} RD {}", LOGGING_PREFIX_ADD,
LOG.info("No DC gateways configured.");
return tunnelInterfaceNameList;
}
- List<DcGatewayIp> dcGatewayIps = dcGatewayIpListOptional.get().nonnullDcGatewayIp();
+ Map<DcGatewayIpKey, DcGatewayIp> keyDcGatewayIpMap = dcGatewayIpListOptional.get().nonnullDcGatewayIp();
InstanceIdentifier<ExternalTunnelList> externalTunnelListId = InstanceIdentifier
.create(ExternalTunnelList.class);
Optional<ExternalTunnelList> externalTunnelListOptional = SingleTransactionDataBroker.syncReadOptional(
dataBroker, LogicalDatastoreType.OPERATIONAL, externalTunnelListId);
if (externalTunnelListOptional.isPresent()) {
- List<ExternalTunnel> externalTunnels = externalTunnelListOptional.get().nonnullExternalTunnel();
+ Map<ExternalTunnelKey, ExternalTunnel> keyExternalTunnelMap
+ = externalTunnelListOptional.get().nonnullExternalTunnel();
List<String> externalTunnelIpList = new ArrayList<>();
- for (ExternalTunnel externalTunnel: externalTunnels) {
+ for (ExternalTunnel externalTunnel: keyExternalTunnelMap.values()) {
externalTunnelIpList.add(externalTunnel.getDestinationDevice());
}
List<String> dcGatewayIpList = new ArrayList<>();
- for (DcGatewayIp dcGatewayIp: dcGatewayIps) {
+ for (DcGatewayIp dcGatewayIp: keyDcGatewayIpMap.values()) {
dcGatewayIpList.add(dcGatewayIp.getIpAddress().getIpv4Address().toString());
}
// Find all externalTunnelIps present in dcGateWayIpList
}
}
for (String externalTunnelIpsInDcGatewayIp: externalTunnelIpsInDcGatewayIpList) {
- for (ExternalTunnel externalTunnel: externalTunnels) {
+ for (ExternalTunnel externalTunnel: keyExternalTunnelMap.values()) {
if (externalTunnel.getDestinationDevice().contentEquals(externalTunnelIpsInDcGatewayIp)) {
tunnelInterfaceNameList.add(externalTunnel.getTunnelInterfaceName());
}
import static java.util.Collections.emptyList;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterators;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpntargets.VpnTarget;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.Subnets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.Adjacencies;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.VpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.Adjacency;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.Adjacency.AdjacencyType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.AdjacencyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.AdjacencyKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.vpn._interface.VpnInstanceNames;
public void add(final InstanceIdentifier<VpnInterface> identifier, final VpnInterface vpnInterface) {
LOG.trace("Received VpnInterface add event: vpnInterface={}", vpnInterface);
LOG.info("add: intfName {} onto vpnName {}", vpnInterface.getName(),
- VpnHelper.getVpnInterfaceVpnInstanceNamesString(vpnInterface.getVpnInstanceNames()));
+ VpnHelper.getVpnInterfaceVpnInstanceNamesString(
+ new ArrayList<VpnInstanceNames>(vpnInterface.getVpnInstanceNames().values())));
addVpnInterface(identifier, vpnInterface, null, null);
}
@SuppressWarnings("checkstyle:IllegalCatch")
private void addVpnInterface(final InstanceIdentifier<VpnInterface> identifier, final VpnInterface vpnInterface,
final @Nullable List<Adjacency> oldAdjs, final @Nullable List<Adjacency> newAdjs) {
- for (VpnInstanceNames vpnInterfaceVpnInstance : vpnInterface.nonnullVpnInstanceNames()) {
+ for (VpnInstanceNames vpnInterfaceVpnInstance : vpnInterface.nonnullVpnInstanceNames().values()) {
String vpnName = vpnInterfaceVpnInstance.getVpnName();
addVpnInterfaceCall(identifier, vpnInterface, oldAdjs, newAdjs, vpnName);
}
Optional<Adjacencies> optAdjacencies = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, path);
if (!optAdjacencies.isPresent()) {
- LOG.trace("No config adjacencies present for vpninterface {}", vpnInterface);
+ LOG.trace("No config adjacencyKeyAdjacencyMap present for vpninterface {}", vpnInterface);
return;
}
- List<Adjacency> adjacencies = optAdjacencies.get().nonnullAdjacency();
- for (Adjacency adjacency : adjacencies) {
+ Map<AdjacencyKey, Adjacency> adjacencyKeyAdjacencyMap = optAdjacencies.get().nonnullAdjacency();
+ for (Adjacency adjacency : adjacencyKeyAdjacencyMap.values()) {
if (adjacency.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
continue;
}
if (router != null) {
if (addOrRemove == NwConstants.ADD_FLOW) {
vpnManager.addArpResponderFlowsToExternalNetworkIps(routerName,
- VpnUtil.getIpsListFromExternalIps(router.getExternalIps()), router.getExtGwMacAddress(),
+ VpnUtil.getIpsListFromExternalIps(new ArrayList<ExternalIps>(router
+ .getExternalIps().values())), router.getExtGwMacAddress(),
dpId, interfaceName, lportTag);
} else {
vpnManager.removeArpResponderFlowsToExternalNetworkIps(routerName,
- VpnUtil.getIpsListFromExternalIps(router.getExternalIps()),
+ VpnUtil.getIpsListFromExternalIps(new ArrayList<ExternalIps>(router
+ .getExternalIps().values())),
dpId, interfaceName, lportTag);
}
} else {
Optional<AdjacenciesOp> adjacencies = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, path);
if (adjacencies.isPresent()) {
- List<Adjacency> nextHops = adjacencies.get().getAdjacency();
- if (nextHops != null && !nextHops.isEmpty()) {
+ Map<AdjacencyKey, Adjacency> nextHopsMap = adjacencies.get().getAdjacency();
+ if (nextHopsMap != null && !nextHopsMap.isEmpty()) {
LOG.debug("advertiseAdjacenciesForVpnToBgp: NextHops are {} for interface {} on dpn {} for vpn {}"
- + " rd {}", nextHops, interfaceName, dpnId, vpnName, rd);
+ + " rd {}", nextHopsMap, interfaceName, dpnId, vpnName, rd);
VpnInstanceOpDataEntry vpnInstanceOpData = vpnUtil.getVpnInstanceOpData(rd);
Uint32 l3vni = vpnInstanceOpData.getL3vni();
VrfEntry.EncapType encapType = VpnUtil.isL3VpnOverVxLan(l3vni)
? VrfEntry.EncapType.Vxlan : VrfEntry.EncapType.Mplsgre;
- for (Adjacency nextHop : nextHops) {
+ for (Adjacency nextHop : nextHopsMap.values()) {
if (nextHop.getAdjacencyType() == AdjacencyType.ExtraRoute) {
continue;
}
interfaceName, vpnName);
}
if (adjacencies.isPresent()) {
- List<Adjacency> nextHops = adjacencies.get().getAdjacency();
+ Map<AdjacencyKey, Adjacency> nextHopsMap = adjacencies.get().getAdjacency();
- if (nextHops != null && !nextHops.isEmpty()) {
+ if (nextHopsMap != null && !nextHopsMap.isEmpty()) {
LOG.trace("withdrawAdjacenciesForVpnFromBgp: NextHops are {} for interface {} in vpn {} rd {}",
- nextHops, interfaceName, vpnName, rd);
- for (Adjacency nextHop : nextHops) {
+ nextHopsMap, interfaceName, vpnName, rd);
+ for (Adjacency nextHop : nextHopsMap.values()) {
try {
if (nextHop.getAdjacencyType() != AdjacencyType.ExtraRoute) {
LOG.info("VPN WITHDRAW: withdrawAdjacenciesForVpnFromBgp: Removing Fib Entry rd {}"
boolean isL3VpnOverVxLan = VpnUtil.isL3VpnOverVxLan(l3vni);
VrfEntry.EncapType encapType = isL3VpnOverVxLan ? VrfEntry.EncapType.Vxlan : VrfEntry.EncapType.Mplsgre;
VpnPopulator registeredPopulator = L3vpnRegistry.getRegisteredPopulator(encapType);
- List<Adjacency> nextHops = adjacencies != null ? adjacencies.getAdjacency() : emptyList();
+ Map<AdjacencyKey, Adjacency> nextHopsMap = adjacencies != null ? adjacencies.getAdjacency()
+ : Collections.<AdjacencyKey, Adjacency>emptyMap();
List<Adjacency> value = new ArrayList<>();
- for (Adjacency nextHop : nextHops) {
+ for (Adjacency nextHop : nextHopsMap.values()) {
String rd = primaryRd;
String nexthopIpValue = nextHop.getIpAddress().split("/")[0];
if (vpnInstanceOpData.getBgpvpnType() == VpnInstanceOpDataEntry.BgpvpnType.BGPVPNInternet
String prefix = VpnUtil.getIpPrefix(nextHop.getIpAddress());
Prefixes.PrefixCue prefixCue = nextHop.isPhysNetworkFunc()
? Prefixes.PrefixCue.PhysNetFunc : Prefixes.PrefixCue.None;
- LOG.debug("processVpnInterfaceAdjacencies: Adding prefix {} to interface {} with nextHops {} on dpn {}"
- + " for vpn {}", prefix, interfaceName, nhList, dpnId, vpnName);
+ LOG.debug("processVpnInterfaceAdjacencies: Adding prefix {} to interface {} with nextHopsMap {} "
+ + "on dpn {} for vpn {}", prefix, interfaceName, nhList, dpnId, vpnName);
Prefixes prefixes = intfnetworkUuid != null
? VpnUtil.getPrefixToInterface(dpnId, interfaceName, prefix, intfnetworkUuid ,networkType,
segmentationId, prefixCue) :
VpnUtil.getPrefixToInterface(dpnId, interfaceName, prefix, prefixCue);
- writeOperTxn.merge(VpnUtil.getPrefixToInterfaceIdentifier(
- vpnUtil.getVpnId(vpnName), prefix), prefixes, true);
+ writeOperTxn.mergeParentStructureMerge(VpnUtil.getPrefixToInterfaceIdentifier(
+ vpnUtil.getVpnId(vpnName), prefix), prefixes);
final Uuid subnetId = nextHop.getSubnetId();
gatewayIp = nextHop.getSubnetGatewayIp();
subnetId, interfaceName, vpnName);
gwMac = InterfaceUtils.getMacAddressFromInterfaceState(interfaceState);
}
- LOG.info("processVpnInterfaceAdjacencies: Added prefix {} to interface {} with nextHops {} on dpn {}"
+ LOG.info("processVpnInterfaceAdjacencies: Added prefix {} to interface {} with nextHopsMap {} on dpn {}"
+ " for vpn {}", prefix, interfaceName, nhList, dpnId, vpnName);
} else {
//Extra route adjacency
.setGatewayMac(gwMac.orElse(null)).setInterfaceName(interfaceName)
.setVpnName(vpnName).setDpnId(dpnId).setEncapType(encapType);
- for (Adjacency nextHop : aug.getAdjacency()) {
+ for (Adjacency nextHop : aug.getAdjacency().values()) {
// Adjacencies other than primary Adjacencies are handled in the addExtraRoute call above.
if (nextHop.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
RouteOrigin origin = VpnUtil.getRouteOrigin(nextHop.getAdjacencyType());
VpnUtil.getVpnInterfaceOpDataEntry(interfaceName, vpnName, aug, dpnId, lportTag, gwMac, gwIp);
InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId = VpnUtil
.getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnName);
- writeOperTxn.put(interfaceId, opInterface, CREATE_MISSING_PARENTS);
+ writeOperTxn.mergeParentStructurePut(interfaceId, opInterface);
LOG.info("addVpnInterfaceToOperational: Added VPN Interface {} on dpn {} vpn {} to operational datastore",
interfaceName, dpnId, vpnName);
}
String srcTepIp = stateTunnelList.getSrcInfo().getTepIp().stringValue();
Uint64 srcDpnId = Uint64.valueOf(stateTunnelList.getSrcInfo().getTepDeviceId()).intern();
AdjacenciesOp adjacencies = vpnInterface.augmentation(AdjacenciesOp.class);
- List<Adjacency> adjList =
- adjacencies != null && adjacencies.getAdjacency() != null ? adjacencies.getAdjacency() : emptyList();
- if (adjList.isEmpty()) {
+ Map<AdjacencyKey, Adjacency> keyAdjacencyMap =
+ adjacencies != null && adjacencies.getAdjacency() != null ? adjacencies.getAdjacency()
+ : Collections.<AdjacencyKey, Adjacency>emptyMap();
+ if (keyAdjacencyMap.isEmpty()) {
LOG.trace("updateVpnInterfaceOnTepAdd: Adjacencies are empty for vpnInterface {} on dpn {}",
vpnInterface, srcDpnId);
return;
String primaryRd = vpnUtil.getPrimaryRd(vpnName);
LOG.info("updateVpnInterfaceOnTepAdd: AdjacencyList for interface {} on dpn {} vpn {} is {}",
vpnInterface.getName(), vpnInterface.getDpnId(),
- vpnInterface.getVpnInstanceName(), adjList);
- for (Adjacency adj : adjList) {
+ vpnInterface.getVpnInstanceName(), keyAdjacencyMap);
+ for (Adjacency adj : keyAdjacencyMap.values()) {
String rd = adj.getVrfId();
rd = rd != null ? rd : vpnName;
prefix = adj.getIpAddress();
.addAugmentation(AdjacenciesOp.class, aug).build();
InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId =
VpnUtil.getVpnInterfaceOpDataEntryIdentifier(vpnInterface.getName(), vpnName);
- writeOperTxn.put(interfaceId, opInterface, CREATE_MISSING_PARENTS);
+ writeOperTxn.mergeParentStructurePut(interfaceId, opInterface);
LOG.info("updateVpnInterfaceOnTepAdd: interface {} updated successully on tep add on dpn {} vpn {}",
vpnInterface.getName(), srcDpnId, vpnName);
TypedWriteTransaction<Operational> writeOperTxn) {
AdjacenciesOp adjacencies = vpnInterface.augmentation(AdjacenciesOp.class);
- List<Adjacency> adjList = adjacencies != null ? adjacencies.getAdjacency() : new ArrayList<>();
+ List<Adjacency> adjList = adjacencies != null ? new ArrayList<Adjacency>(adjacencies.getAdjacency().values())
+ : new ArrayList<>();
String prefix = null;
boolean isNextHopRemoveReqd = false;
String srcTepIp = stateTunnelList.getSrcInfo().getTepIp().stringValue();
.addAugmentation(AdjacenciesOp.class, aug).build();
InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId =
VpnUtil.getVpnInterfaceOpDataEntryIdentifier(vpnInterface.getName(), vpnName);
- writeOperTxn.put(interfaceId, opInterface, CREATE_MISSING_PARENTS);
+ writeOperTxn.mergeParentStructurePut(interfaceId, opInterface);
LOG.info("updateVpnInterfaceOnTepDelete: interface {} updated successully on tep delete on dpn {} vpn {}",
vpnInterface.getName(), srcDpnId, vpnName);
}
}
String prefix = vrfEntry.getDestPrefix();
String gwMac = vrfEntry.getGatewayMacAddress();
- vrfEntry.nonnullRoutePaths().forEach(routePath -> {
+ vrfEntry.nonnullRoutePaths().values().forEach(routePath -> {
String nh = routePath.getNexthopAddress();
Uint32 label = routePath.getLabel();
if (FibHelper.isControllerManagedVpnInterfaceRoute(RouteOrigin.value(
LOG.trace("Received VpnInterface remove event: vpnInterface={}", vpnInterface);
final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class);
final String interfaceName = key.getName();
- for (VpnInstanceNames vpnInterfaceVpnInstance : vpnInterface.nonnullVpnInstanceNames()) {
+ for (VpnInstanceNames vpnInterfaceVpnInstance : vpnInterface.nonnullVpnInstanceNames().values()) {
String vpnName = vpnInterfaceVpnInstance.getVpnName();
removeVpnInterfaceCall(identifier, vpnInterface, vpnName, interfaceName);
}
AdjacenciesOp adjacencies = vpnInterfaceOpDataEnteryOptional.get().augmentation(AdjacenciesOp.class);
if (adjacencies != null && !adjacencies.getAdjacency().isEmpty()) {
- List<Adjacency> nextHops = adjacencies.getAdjacency();
+ Map<AdjacencyKey, Adjacency> nextHopsMap = adjacencies.getAdjacency();
LOG.info("removeAdjacenciesFromVpn: NextHops for interface {} on dpn {} for vpn {} are {}",
- interfaceName, dpnId, vpnName, nextHops);
- for (Adjacency nextHop : nextHops) {
+ interfaceName, dpnId, vpnName, nextHopsMap);
+ for (Adjacency nextHop : nextHopsMap.values()) {
if (nextHop.isPhysNetworkFunc()) {
LOG.info("removeAdjacenciesFromVpn: Removing PNF FIB entry rd {} prefix {}",
nextHop.getSubnetId().getValue(), nextHop.getIpAddress());
LOG.info("update: handled Instance update for VPNInterface {} on dpn {} from oldVpn(s) {} "
+ "to newVpn(s) {}",
original.getName(), dpnId,
- VpnHelper.getVpnInterfaceVpnInstanceNamesString(original.getVpnInstanceNames()),
- VpnHelper.getVpnInterfaceVpnInstanceNamesString(update.getVpnInstanceNames()));
+ VpnHelper.getVpnInterfaceVpnInstanceNamesString(
+ new ArrayList<VpnInstanceNames>(original.getVpnInstanceNames().values())),
+ VpnHelper.getVpnInterfaceVpnInstanceNamesString(
+ new ArrayList<VpnInstanceNames>(update.getVpnInstanceNames().values())));
return emptyList();
}
updateVpnInstanceAdjChange(original, update, vpnInterfaceName, futures);
List<ListenableFuture<Void>> futures) {
final Adjacencies origAdjs = original.augmentation(Adjacencies.class);
final List<Adjacency> oldAdjs = origAdjs != null && origAdjs.getAdjacency() != null
- ? origAdjs.getAdjacency() : new ArrayList<>();
+ ? new ArrayList<Adjacency>(origAdjs.getAdjacency().values()) : new ArrayList<>();
final Adjacencies updateAdjs = update.augmentation(Adjacencies.class);
final List<Adjacency> newAdjs = updateAdjs != null && updateAdjs.getAdjacency() != null
- ? updateAdjs.getAdjacency() : new ArrayList<>();
+ ? new ArrayList<Adjacency>(updateAdjs.getAdjacency().values()) : new ArrayList<>();
boolean isOldVpnRemoveCallExecuted = false;
for (String oldVpnName : oldVpnList) {
List<ListenableFuture<Void>> futures) {
final Adjacencies origAdjs = original.augmentation(Adjacencies.class);
final List<Adjacency> oldAdjs = origAdjs != null && origAdjs.getAdjacency()
- != null ? origAdjs.getAdjacency() : new ArrayList<>();
+ != null ? new ArrayList<Adjacency>(origAdjs.getAdjacency().values()) : new ArrayList<>();
final Adjacencies updateAdjs = update.augmentation(Adjacencies.class);
final List<Adjacency> newAdjs = updateAdjs != null && updateAdjs.getAdjacency()
- != null ? updateAdjs.getAdjacency() : new ArrayList<>();
+ != null ? new ArrayList<Adjacency>(updateAdjs.getAdjacency().values()) : new ArrayList<>();
final Uint64 dpnId = InterfaceUtils.getDpnForInterface(ifaceMgrRpcService, vpnInterfaceName);
- for (VpnInstanceNames vpnInterfaceVpnInstance : update.nonnullVpnInstanceNames()) {
+ for (VpnInstanceNames vpnInterfaceVpnInstance : update.nonnullVpnInstanceNames().values()) {
String newVpnName = vpnInterfaceVpnInstance.getVpnName();
List<Adjacency> copyNewAdjs = new ArrayList<>(newAdjs);
List<Adjacency> copyOldAdjs = new ArrayList<>(oldAdjs);
InstanceIdentifier<VrfTables> vrfTableId = idBuilder.build();
VrfTables vrfTableNew = new VrfTablesBuilder().setRouteDistinguisher(rd).setVrfEntry(vrfEntryList).build();
if (writeConfigTxn != null) {
- writeConfigTxn.merge(vrfTableId, vrfTableNew, CREATE_MISSING_PARENTS);
+ writeConfigTxn.mergeParentStructureMerge(vrfTableId, vrfTableNew);
} else {
vpnUtil.syncUpdate(LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew);
}
VpnPopulator populator = L3vpnRegistry.getRegisteredPopulator(encapType);
List<Adjacency> adjacencies = new ArrayList<>();
if (optAdjacencies.isPresent() && optAdjacencies.get().getAdjacency() != null) {
- adjacencies.addAll(optAdjacencies.get().getAdjacency());
+ adjacencies.addAll(optAdjacencies.get().getAdjacency().values());
}
Uint32 vpnId = vpnUtil.getVpnId(vpnName);
L3vpnInput input = new L3vpnInput().setNextHop(adj).setVpnName(vpnName)
String parentVpnRd = getParentVpnRdForExternalSubnet(adj);
- writeOperTxn.merge(
+ writeOperTxn.mergeParentStructureMerge(
VpnUtil.getPrefixToInterfaceIdentifier(vpnUtil.getVpnId(adj.getSubnetId().getValue()),
- prefix), pnfPrefix, true);
+ prefix), pnfPrefix);
fibManager.addOrUpdateFibEntry(adj.getSubnetId().getValue(), adj.getMacAddress(),
adj.getIpAddress(), emptyList(), null /* EncapType */, Uint32.ZERO /* label */,
VpnUtil.getVpnInterfaceOpDataEntry(currVpnIntf.getName(), currVpnIntf.getVpnInstanceName(),
aug, dpnId, currVpnIntf.getLportTag().toJava(),
currVpnIntf.getGatewayMacAddress(), currVpnIntf.getGatewayIpAddress());
- writeOperTxn.merge(identifier, newVpnIntf, CREATE_MISSING_PARENTS);
+ writeOperTxn.mergeParentStructureMerge(identifier, newVpnIntf);
}
} catch (InterruptedException | ExecutionException e) {
LOG.error("addNewAdjToVpnInterface: Failed to read data store for interface {} dpn {} vpn {} rd {} ip "
Optional<AdjacenciesOp> optAdjacencies = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, path);
if (optAdjacencies.isPresent()) {
- List<Adjacency> adjacencies = optAdjacencies.get().getAdjacency();
+ Map<AdjacencyKey, Adjacency> keyAdjacencyMap = optAdjacencies.get().getAdjacency();
- if (adjacencies != null && !adjacencies.isEmpty()) {
- LOG.trace("delAdjFromVpnInterface: Adjacencies are {}", adjacencies);
- for (Adjacency adjacency : adjacencies) {
+ if (keyAdjacencyMap != null && !keyAdjacencyMap.isEmpty()) {
+ LOG.trace("delAdjFromVpnInterface: Adjacencies are {}", keyAdjacencyMap);
+ for (Adjacency adjacency : keyAdjacencyMap.values()) {
if (Objects.equals(adjacency.getIpAddress(), adj.getIpAddress())) {
String rd = adjacency.getVrfId();
if (adj.getNextHopIpList() != null) {
Adjacencies adjs = vpnInterface.augmentation(Adjacencies.class);
String rd = vpnUtil.getVpnRd(vpnName);
if (adjs != null) {
- List<Adjacency> adjsList = adjs.nonnullAdjacency();
- for (Adjacency adj : adjsList) {
+ Map<AdjacencyKey, Adjacency> keyAdjacencyMap = adjs.nonnullAdjacency();
+ for (Adjacency adj : keyAdjacencyMap.values()) {
if (adj.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
String primaryInterfaceIp = adj.getIpAddress();
String prefix = VpnUtil.getIpPrefix(primaryInterfaceIp);
if (vpnInstanceOpData == null) {
return;
}
- List<VpnToDpnList> vpnToDpnLists = vpnInstanceOpData.getVpnToDpnList();
+ List<VpnToDpnList> vpnToDpnLists = new ArrayList<VpnToDpnList>(vpnInstanceOpData.getVpnToDpnList().values());
if (vpnToDpnLists == null || vpnToDpnLists.isEmpty()) {
return;
}
if (vpnToDpnList.getVpnInterfaces() == null) {
return;
}
- vpnToDpnList.getVpnInterfaces().forEach(vpnInterface -> {
+ vpnToDpnList.getVpnInterfaces().values().forEach(vpnInterface -> {
try {
InstanceIdentifier<VpnInterfaceOpDataEntry> existingVpnInterfaceId =
VpnUtil.getVpnInterfaceOpDataEntryIdentifier(vpnInterface.getInterfaceName(), vpnName);
LOG.debug("There is no adjacency available for vpnInterface:{}", vpnInterface);
return;
}
- List<Adjacency> operationVpnAdjacencies = vpnInterfaceOptional.get()
- .augmentation(AdjacenciesOp.class).nonnullAdjacency();
+ List<Adjacency> operationVpnAdjacencies = new ArrayList<Adjacency>(vpnInterfaceOptional.get()
+ .augmentation(AdjacenciesOp.class).nonnullAdjacency().values());
// Due to insufficient rds, some of the extra route wont get processed when it is added.
// The unprocessed adjacencies will be present in config vpn interface DS but will be missing
// in operational DS. These unprocessed adjacencies will be handled below.
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 java.util.concurrent.ExecutorService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.Adjacency;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.AdjacencyKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
VpnInstanceOpDataEntry vpnInstOp = vpnUtil.getVpnInstanceOpData(rd);
AdjacenciesOp adjs = del.augmentation(AdjacenciesOp.class);
- List<Adjacency> adjList = adjs != null ? adjs.getAdjacency() : null;
+ Map<AdjacencyKey, Adjacency> adjMap = adjs != null ? adjs.getAdjacency() : null;
- if (vpnInstOp != null && adjList != null && adjList.size() > 0) {
+ if (vpnInstOp != null && adjMap != null && adjMap.size() > 0) {
/*
* When a VPN Interface is removed by FibManager (aka VrfEntryListener and its cohorts),
* one adjacency or two adjacency (in case of dual-stack)
* vpnInterface from it.
*/
List<Prefixes> prefixToInterface = new ArrayList<>();
- for (Adjacency adjacency : adjs.getAdjacency()) {
+ for (Adjacency adjacency : adjs.getAdjacency().values()) {
List<Prefixes> prefixToInterfaceLocal = new ArrayList<>();
Optional<Prefixes> prefix = operTx.read(
VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(),
package org.opendaylight.netvirt.vpnmanager;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
for (RouteTarget routerTarget : routeTargetSet) {
if (routerTarget.getAssociatedSubnet() != null) {
for (int i = 0; i < routerTarget.getAssociatedSubnet().size(); i++) {
- AssociatedSubnet associatedSubnet = routerTarget.getAssociatedSubnet().get(i);
+ AssociatedSubnet associatedSubnet =
+ new ArrayList<AssociatedSubnet>(routerTarget.getAssociatedSubnet().values()).get(i);
if (VpnUtil.areSubnetsOverlapping(associatedSubnet.getCidr(), subnetCidr)) {
return true;
}
* (2) iRT=A eRT=B subnet-range=S1; OK
* (3) iRT=B eRT=A subnet-range=S2; NOK
* Check if (1) and (2) are importing the same subnet-range routes to (3) */
- List<AssociatedVpn> multipleAssociatedVpn = associatedSubnet.getAssociatedVpn();
+ List<AssociatedVpn> multipleAssociatedVpn
+ = new ArrayList<AssociatedVpn>(associatedSubnet.getAssociatedVpn().values());
if (multipleAssociatedVpn != null && multipleAssociatedVpn.size() > 1) {
LOG.error("doesExistingVpnsHaveConflictingSubnet: There is an indirect complete overlap"
+ " for subnet CIDR {} for rt {} rtType {}", subnetCidr, routerTarget.getRt(),
}
for (int j = i + 1; j < routerTarget.getAssociatedSubnet().size(); j++) {
if (VpnUtil.areSubnetsOverlapping(associatedSubnet.getCidr(),
- routerTarget.getAssociatedSubnet().get(j).getCidr())) {
+ new ArrayList<AssociatedSubnet>(routerTarget.getAssociatedSubnet()
+ .values()).get(j).getCidr())) {
LOG.error("doesExistingVpnsHaveConflictingSubnet: There is an indirect paartial"
+ " overlap for subnet CIDR {} for rt {} rtType {}", subnetCidr,
routerTarget.getRt(), routerTarget.getRtType());
routerTarget.getRt(), RouteTarget.RtType.ERT));
if (indirectRts.isPresent() && indirectRts.get().getAssociatedSubnet() != null
&& routerTarget.getAssociatedSubnet() != null) {
- for (AssociatedSubnet associatedSubnet : indirectRts.get().getAssociatedSubnet()) {
+ for (AssociatedSubnet associatedSubnet : indirectRts.get().getAssociatedSubnet().values()) {
if (VpnUtil.areSubnetsOverlapping(associatedSubnet.getCidr(), subnetCidr)) {
LOG.error("doesExistingVpnsHaveConflictingSubnet: There is an indirect overlap for"
+ " subnet CIDR {} for rt {} rtType {}", subnetCidr, routerTarget.getRt(),
tx.read(VpnUtil.getAssociatedSubnetIdentifier(rt, rtType, cidr)).get();
boolean deleteParent = false;
if (associatedSubnet.isPresent()) {
- List<AssociatedVpn> associatedVpns = new ArrayList<>(associatedSubnet.get().nonnullAssociatedVpn());
+ List<AssociatedVpn> associatedVpns
+ = new ArrayList<>(associatedSubnet.get().nonnullAssociatedVpn().values());
if (associatedVpns == null || associatedVpns.isEmpty()) {
deleteParent = true;
} else {
}
} else {
//Add RT-Subnet-Vpn Association
- tx.put(VpnUtil.getAssociatedSubnetAndVpnIdentifier(rt, rtType, cidr, vpnName),
- VpnUtil.buildAssociatedSubnetAndVpn(vpnName), CREATE_MISSING_PARENTS);
+ tx.mergeParentStructurePut(VpnUtil.getAssociatedSubnetAndVpnIdentifier(rt, rtType, cidr, vpnName),
+ VpnUtil.buildAssociatedSubnetAndVpn(vpnName));
}
}
Optional<RouteTarget> rtToSubnetsAssociation = tx.read(rtIdentifier).get();
if (rtToSubnetsAssociation.isPresent()) {
List<AssociatedSubnet> associatedSubnets = new ArrayList<>(rtToSubnetsAssociation.get()
- .nonnullAssociatedSubnet());
+ .nonnullAssociatedSubnet().values());
if (associatedSubnets != null && !associatedSubnets.isEmpty()) {
for (Iterator<AssociatedSubnet> iterator = associatedSubnets.iterator(); iterator.hasNext(); ) {
if (Objects.equals(iterator.next().getCidr(), cidr)) {
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 java.util.concurrent.locks.ReentrantLock;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpntargets.VpnTarget;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpntargets.VpnTargetKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.Vpn;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint32;
vpnName, primaryRd);
return;
}
- List<VpnTarget> vpnTargetList = update.getVpnTargets().getVpnTarget();
+ Map<VpnTargetKey, VpnTarget> vpnTargetMap = update.getVpnTargets().getVpnTarget();
List<String> ertList = new ArrayList<>();
List<String> irtList = new ArrayList<>();
- if (vpnTargetList != null) {
- for (VpnTarget vpnTarget : vpnTargetList) {
+ if (vpnTargetMap != null) {
+ for (VpnTarget vpnTarget : vpnTargetMap.values()) {
if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ExportExtcommunity) {
ertList.add(vpnTarget.getVrfRTValue());
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.subnet.op.data.entry.SubnetToDpn;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.subnet.op.data.entry.SubnetToDpnKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalNetworks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.Networks;
}
SubnetOpDataEntry subnetOpDataEntry = optionalSubs.get();
SubnetOpDataEntryBuilder subOpBuilder = new SubnetOpDataEntryBuilder(subnetOpDataEntry);
- subOpBuilder.setSubnetToDpn(concat(subnetOpDataEntry.getSubnetToDpn(), subDpn));
+ subOpBuilder.setSubnetToDpn(concat(new ArrayList<SubnetToDpn>(subnetOpDataEntry.getSubnetToDpn().values()),
+ subDpn));
if (subOpBuilder.getRouteAdvState() != TaskState.Advertised) {
if (subOpBuilder.getNhDpnId() == null) {
// No nexthop selected yet, elect one now
subOpBuilder.getRouteAdvState(), subOpBuilder.getLastAdvState());
boolean isExternalSubnetVpn = VpnUtil.isExternalSubnetVpn(subnetOpDataEntry.getVpnName(),
subnetId.getValue());
- subOpBuilder.setSubnetToDpn(concat(subnetOpDataEntry.getSubnetToDpn(), subDpn));
+ subOpBuilder.setSubnetToDpn(concat(new ArrayList<SubnetToDpn>(subnetOpDataEntry.getSubnetToDpn().values()),
+ subDpn));
if (subOpBuilder.getRouteAdvState() != TaskState.Advertised) {
if (subOpBuilder.getNhDpnId() == null) {
// No nexthop selected yet, elect one now
String nhTepIp = null;
Uint64 nhDpnId = null;
- List<SubnetToDpn> subDpnList = subOpBuilder.getSubnetToDpn();
- if (subDpnList != null) {
- for (SubnetToDpn subnetToDpn : subDpnList) {
+ Map<SubnetToDpnKey, SubnetToDpn> toDpnKeySubnetToDpnMap = subOpBuilder.getSubnetToDpn();
+ if (toDpnKeySubnetToDpnMap != null) {
+ for (SubnetToDpn subnetToDpn : toDpnKeySubnetToDpnMap.values()) {
if (subnetToDpn.getDpnId().equals(oldDpnId)) {
// Is this same is as input dpnId, then ignore it
continue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnTargets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpntargets.VpnTarget;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpntargets.VpnTargetKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.Vpn;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.VpnKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.Networks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.NetworksKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.SubnetsKey;
public List<VrfEntry> getAllVrfEntries(String rd) {
VrfTables vrfTables = getVrfTable(rd);
if (vrfTables != null && vrfTables.getVrfEntry() != null) {
- return vrfTables.getVrfEntry();
+ return new ArrayList<VrfEntry>(vrfTables.getVrfEntry().values());
}
return emptyList();
}
Optional<VpnInstanceOpData> vpnInstanceOpDataOptional = read(LogicalDatastoreType.OPERATIONAL, id);
return
vpnInstanceOpDataOptional.isPresent() && vpnInstanceOpDataOptional.get()
- .getVpnInstanceOpDataEntry() != null ? vpnInstanceOpDataOptional.get()
- .getVpnInstanceOpDataEntry() : emptyList();
+ .getVpnInstanceOpDataEntry() != null
+ ? new ArrayList<VpnInstanceOpDataEntry>(vpnInstanceOpDataOptional.get()
+ .getVpnInstanceOpDataEntry().values()) : emptyList();
} catch (Exception e) {
LOG.error("getAllVpnInstanceOpData: Could not retrieve all vpn instance op data subtree...", e);
return emptyList();
String primaryRd = getPrimaryRd(vpnInstance);
InstanceIdentifier<VpnToDpnList> dpnToVpnId = VpnHelper.getVpnToDpnListIdentifier(primaryRd, dpnId);
Optional<VpnToDpnList> dpnInVpn = read(LogicalDatastoreType.OPERATIONAL, dpnToVpnId);
- return dpnInVpn.isPresent() && dpnInVpn.get().getVpnInterfaces() != null ? dpnInVpn.get().getVpnInterfaces()
+ return dpnInVpn.isPresent() && dpnInVpn.get().getVpnInterfaces() != null
+ ? new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op
+ .data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces>(dpnInVpn.get()
+ .getVpnInterfaces().values())
: emptyList();
}
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
Optional<Adjacencies> adjacencies = read(LogicalDatastoreType.CONFIGURATION, path);
if (adjacencies.isPresent()) {
- return adjacencies.get().getAdjacency();
+ return new ArrayList<Adjacency>(adjacencies.get().getAdjacency().values());
}
return null;
}
ListenableFutures.addErrorLogging(
new ManagedNewTransactionRunnerImpl(dataBroker).callWithNewWriteOnlyTransactionAndSubmit(
Datastore.CONFIGURATION, tx -> {
- for (VrfEntry vrfEntry : vrfTables.nonnullVrfEntry()) {
+ for (VrfEntry vrfEntry : vrfTables.nonnullVrfEntry().values()) {
if (origin == RouteOrigin.value(vrfEntry.getOrigin())) {
tx.delete(vpnVrfTableIid.child(VrfEntry.class, vrfEntry.key()));
}
List<VrfEntry> matches = new ArrayList<>();
if (vrfTablesOpc.isPresent()) {
VrfTables vrfTables = vrfTablesOpc.get();
- for (VrfEntry vrfEntry : vrfTables.nonnullVrfEntry()) {
- vrfEntry.nonnullRoutePaths().stream()
+ for (VrfEntry vrfEntry : vrfTables.nonnullVrfEntry().values()) {
+ vrfEntry.nonnullRoutePaths().values().stream()
.filter(routePath -> routePath.getNexthopAddress() != null && routePath.getNexthopAddress()
.equals(nexthop)).findFirst().ifPresent(routePath -> matches.add(vrfEntry));
}
if (optConfiguredVpnInterface.isPresent()) {
VpnInterface cfgVpnInterface = optConfiguredVpnInterface.get();
java.util.Optional<List<VpnInstanceNames>> optVpnInstanceList =
- java.util.Optional.ofNullable(cfgVpnInterface.getVpnInstanceNames());
+ java.util.Optional.ofNullable(
+ new ArrayList<VpnInstanceNames>(cfgVpnInterface.getVpnInstanceNames().values()));
if (optVpnInstanceList.isPresent()) {
List<String> vpnList = new ArrayList<>();
for (VpnInstanceNames vpnInstance : optVpnInstanceList.get()) {
vpnInstanceName)).setName(interfaceName).setDpnId(dpnId).setVpnInstanceName(vpnInstanceName)
.build();
if (writeOperTxn != null) {
- writeOperTxn.merge(interfaceId, interfaceToUpdate, true);
+ writeOperTxn.mergeParentStructureMerge(interfaceId, interfaceToUpdate);
} else {
syncUpdate(LogicalDatastoreType.OPERATIONAL, interfaceId, interfaceToUpdate);
}
.setMacAddress(macAddress.toLowerCase(Locale.getDefault()))
.setCreationTime(new SimpleDateFormat("MM/dd/yyyy h:mm:ss a").format(new Date()));
if (writeOperTxn != null) {
- writeOperTxn.put(id, builder.build(), true);
+ writeOperTxn.mergeParentStructurePut(id, builder.build());
} else {
syncWrite(LogicalDatastoreType.OPERATIONAL, id, builder.build());
}
LOG.debug("getDpnsOnVpn: Could not find OpState for VpnName={}", vpnInstanceName);
return result;
}
- List<VpnToDpnList> vpnToDpnList = vpnInstanceOpData.getVpnToDpnList();
- if (vpnToDpnList == null) {
+ Map<VpnToDpnListKey, VpnToDpnList> vpnToDpnListKeyVpnToDpnListMap = vpnInstanceOpData.getVpnToDpnList();
+ if (vpnToDpnListKeyVpnToDpnListMap == null) {
LOG.debug("getDpnsOnVpn: Could not find DPN footprint for VpnName={}", vpnInstanceName);
return result;
}
- for (VpnToDpnList vpnToDpn : vpnToDpnList) {
+ for (VpnToDpnList vpnToDpn : vpnToDpnListKeyVpnToDpnListMap.values()) {
result.add(vpnToDpn.getDpnId());
}
return result;
String routerName = null;
- for (Routers routerData : extRouterData.get().nonnullRouters()) {
- List<ExternalIps> externalIps = routerData.nonnullExternalIps();
- for (ExternalIps externalIp : externalIps) {
+ for (Routers routerData : extRouterData.get().nonnullRouters().values()) {
+ Map<ExternalIpsKey, ExternalIps> keyExternalIpsMap = routerData.nonnullExternalIps();
+ for (ExternalIps externalIp : keyExternalIpsMap.values()) {
if (Objects.equals(externalIp.getIpAddress(), extIp)) {
routerName = routerData.getRouterName();
break;
return routerName;
}
- for (Routers routerData : extRouterData.get().nonnullRouters()) {
- List<ExternalIps> externalIps = routerData.nonnullExternalIps();
- for (ExternalIps externalIp : externalIps) {
+ for (Routers routerData : extRouterData.get().nonnullRouters().values()) {
+ Map<ExternalIpsKey, ExternalIps> keyExternalIpsMap = routerData.nonnullExternalIps();
+ for (ExternalIps externalIp : keyExternalIpsMap.values()) {
Subnet neutronSubnet = neutronVpnService.getNeutronSubnet(externalIp.getSubnetId());
if (neutronSubnet == null) {
LOG.warn("Failed to retrieve subnet {} referenced by router {}",
if (!extRouterData.isPresent() || extRouterData.get().getRouters() == null) {
return null;
}
- for (Routers routerData : extRouterData.get().getRouters()) {
- List<ExternalIps> externalIps = routerData.getExternalIps();
- if (externalIps != null) {
- for (ExternalIps externalIp : externalIps) {
+ for (Routers routerData : extRouterData.get().getRouters().values()) {
+ Map<ExternalIpsKey, ExternalIps> keyExternalIpsMap = routerData.getExternalIps();
+ if (keyExternalIpsMap != null) {
+ for (ExternalIps externalIp : keyExternalIpsMap.values()) {
Subnet neutronSubnet = neutronVpnService.getNeutronSubnet(externalIp.getSubnetId());
if (neutronSubnet == null) {
LOG.warn("Failed to retrieve subnet {} referenced by router {}",
//TODO(Gobinath): Need to fix this as assuming port will belong to only one Subnet would be incorrect"
Port port = neutronVpnService.getNeutronPort(srcInterface);
if (port != null && port.getFixedIps() != null) {
- for (FixedIps portIp : port.getFixedIps()) {
+ for (FixedIps portIp : port.getFixedIps().values()) {
if (doesInterfaceAndHiddenIpAddressTypeMatch(hiddenIp, portIp)) {
gatewayIp =
Optional.of(neutronVpnService.getNeutronSubnet(portIp.getSubnetId()).getGatewayIp());
BoundServices serviceInfo = isTunnelInterface
? VpnUtil.getBoundServicesForTunnelInterface(vpnInstanceName, interfaceName)
: getBoundServicesForVpnInterface(vpnInstanceName, interfaceName);
- tx.put(InterfaceUtils.buildServiceId(interfaceName,
+ tx.mergeParentStructurePut(InterfaceUtils.buildServiceId(interfaceName,
ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
NwConstants.L3VPN_SERVICE_INDEX)),
- serviceInfo, WriteTransaction.CREATE_MISSING_PARENTS);
+ serviceInfo);
})), SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
}
public Uuid getSubnetFromExternalRouterByIp(Uuid routerId, String ip) {
Routers externalRouter = getExternalRouter(routerId.getValue());
if (externalRouter != null && externalRouter.getExternalIps() != null) {
- for (ExternalIps externalIp : externalRouter.getExternalIps()) {
+ for (ExternalIps externalIp : externalRouter.getExternalIps().values()) {
if (Objects.equals(externalIp.getIpAddress(), ip)) {
return externalIp.getSubnetId();
}
LOG.debug("getRts: vpn targets not available for {}", name);
return rts;
}
- List<VpnTarget> vpnTargets = targets.getVpnTarget();
- if (vpnTargets == null) {
+ Map<VpnTargetKey, VpnTarget> keyVpnTargetMap = targets.getVpnTarget();
+ if (keyVpnTargetMap == null) {
LOG.debug("getRts: vpnTarget values not available for {}", name);
return rts;
}
- for (VpnTarget target : vpnTargets) {
+ for (VpnTarget target : keyVpnTargetMap.values()) {
//TODO: Check for RT type is Both
if (target.getVrfRTType().equals(rtType) || target.getVrfRTType().equals(VpnTarget.VrfRTType.Both)) {
String rtValue = target.getVrfRTValue();
ListenableFuture<Void> unsetScheduledToRemoveForVpnInterface(String interfaceName) {
VpnInterfaceBuilder builder = new VpnInterfaceBuilder().withKey(new VpnInterfaceKey(interfaceName));
- return txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> tx.merge(
- VpnUtil.getVpnInterfaceIdentifier(interfaceName), builder.build(),
- WriteTransaction.CREATE_MISSING_PARENTS));
+ return txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> tx.mergeParentStructureMerge(
+ VpnUtil.getVpnInterfaceIdentifier(interfaceName), builder.build()));
}
/**
Optional<ElanDpnInterfacesList> dpnInElanInterfaces = read(LogicalDatastoreType.OPERATIONAL,
elanDpnInterfaceId);
if (dpnInElanInterfaces.isPresent()) {
- List<DpnInterfaces> dpnInterfaces = dpnInElanInterfaces.get().nonnullDpnInterfaces();
- for (DpnInterfaces dpnInterface : dpnInterfaces) {
+ Map<DpnInterfacesKey, DpnInterfaces> dpnInterfacesMap
+ = dpnInElanInterfaces.get().nonnullDpnInterfaces();
+ for (DpnInterfaces dpnInterface : dpnInterfacesMap.values()) {
dpnIdSet.add(dpnInterface.getDpId());
}
}
String getVpnNameFromElanIntanceName(String elanInstanceName) {
Optional<Subnetmaps> subnetMapsData = read(LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
if (subnetMapsData.isPresent()) {
- List<Subnetmap> subnetMapList = subnetMapsData.get().getSubnetmap();
- if (subnetMapList != null && !subnetMapList.isEmpty()) {
- for (Subnetmap subnet : subnetMapList) {
+ Map<SubnetmapKey, Subnetmap> keySubnetmapMap = subnetMapsData.get().getSubnetmap();
+ if (keySubnetmapMap != null && !keySubnetmapMap.isEmpty()) {
+ for (Subnetmap subnet : keySubnetmapMap.values()) {
if (subnet.getNetworkId().getValue().equals(elanInstanceName)) {
if (subnet.getVpnId() != null) {
return subnet.getVpnId().getValue();
List<Subnetmap> subnetMapList = new ArrayList<>();
Subnetmaps subnetMaps = subnetMapsData.get();
subnetMapList = (subnetMaps.getSubnetmap() != null && !subnetMaps.getSubnetmap().isEmpty())
- ? new ArrayList<>(subnetMaps.getSubnetmap()) : subnetMapList;
+ ? new ArrayList<>(subnetMaps.getSubnetmap().values()) : subnetMapList;
if (subnetMapList != null && !subnetMapList.isEmpty()) {
for (Subnetmap subnet : subnetMapList) {
String getRouterPordIdFromElanInstance(String elanInstanceName) {
Optional<Subnetmaps> subnetMapsData = read(LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
if (subnetMapsData.isPresent()) {
- List<Subnetmap> subnetMapList = subnetMapsData.get().getSubnetmap();
- if (subnetMapList != null && !subnetMapList.isEmpty()) {
- for (Subnetmap subnet : subnetMapList) {
+ Map<SubnetmapKey, Subnetmap> keySubnetmapMap = subnetMapsData.get().getSubnetmap();
+ if (keySubnetmapMap != null && !keySubnetmapMap.isEmpty()) {
+ for (Subnetmap subnet : keySubnetmapMap.values()) {
if (subnet.getNetworkId().getValue().equals(elanInstanceName)) {
if (subnet.getRouterInterfacePortId() != null) {
return subnet.getRouterInterfacePortId().getValue();
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances
.vpn.instance.VpnTargets vpnTargets = vpnInstanceOptional.get().getVpnTargets();
if (vpnTargets != null && vpnTargets.getVpnTarget() != null) {
- rtList.addAll(vpnTargets.getVpnTarget());
+ rtList.addAll(vpnTargets.getVpnTarget().values());
}
} else {
LOG.error("getRtListForVpn: Vpn Instance {} not present in config DS", vpnName);
}
public static List<String> getVpnListForVpnInterface(VpnInterface vpnInter) {
- return vpnInter.nonnullVpnInstanceNames().stream()
+ return vpnInter.nonnullVpnInstanceNames().values().stream()
.map(VpnInstanceNames::getVpnName).collect(Collectors.toList());
}
InstanceIdentifier<VpnInstanceOpDataEntry> id = InstanceIdentifier
.builder(VpnInstanceOpData.class).child(VpnInstanceOpDataEntry.class,
new VpnInstanceOpDataEntryKey(primaryRd)).build();
- tx.merge(id, builder.build(), false);
+ tx.merge(id, builder.build());
LOG.debug("updateVpnInstanceWithRdList: Successfully updated the VPN {} with list of RDs {}",
vpnName, updatedRdList);
}));
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.VpnMaps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMapKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.vpnmap.RouterIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.l3.attributes.Routes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.l3.attributes.RoutesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.RouterKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint32;
String vpn2Endpoint = vpnLink.getOtherEndpointIpAddr(vpn2Uuid);
List<VrfEntry> allVpnVrfEntries = vpnUtil.getAllVrfEntries(vpn1Rd);
for (VrfEntry vrfEntry : allVpnVrfEntries) {
- vrfEntry.nonnullRoutePaths().stream()
+ vrfEntry.nonnullRoutePaths().values().stream()
.filter(routePath -> Objects.equals(routePath.getNexthopAddress(), vpn2Endpoint))
.forEach(routePath -> {
// Vpn1 has a route pointing to Vpn2's endpoint. Forcing the leaking of the route will update
return new HashMap<>();
}
Map<String,String> vmap = new HashMap<>();
- final List<VpnMap> VpnMapList = optVpnMaps.get().nonnullVpnMap();
- for (VpnMap map : VpnMapList) {
+ final Map<VpnMapKey, VpnMap> keyVpnMapMap = optVpnMaps.get().nonnullVpnMap();
+ for (VpnMap map : keyVpnMapMap.values()) {
if (map.getRouterIds() == null) {
continue;
}
- final List<Uuid> vpnRouterIds = NeutronUtils.getVpnMapRouterIdsListUuid(map.getRouterIds());
+ final List<Uuid> vpnRouterIds = NeutronUtils.getVpnMapRouterIdsListUuid(
+ new ArrayList<RouterIds>(map.getRouterIds().values()));
for (Uuid routerId : vpnRouterIds) {
if (map.getVpnId().getValue().equalsIgnoreCase(routerId.getValue())) {
break; // VPN is internal
if (!routerOpData.isPresent()) {
return;
}
- List<Router> routers = routerOpData.get().nonnullRouter();
- for (Router router : routers) {
+ Map<RouterKey, Router> keyRouterMap = routerOpData.get().nonnullRouter();
+ for (Router router : keyRouterMap.values()) {
String vpnId = routerXL3VpnMap.get(router.getUuid().getValue());
if (vpnId == null) {
LOG.warn("Could not find suitable VPN for router {}", router.getUuid());
continue; // with next router
}
- List<Routes> routerRoutes = router.getRoutes();
- if (routerRoutes != null) {
- for (Routes route : routerRoutes) {
+ Map<RoutesKey, Routes> routesKeyRoutesMap = router.getRoutes();
+ if (routesKeyRoutesMap != null) {
+ for (Routes route : routesKeyRoutesMap.values()) {
handleStaticRoute(vpnId, route, ivpnLink);
}
}
return; // Nothing to be added to cache
}
InterVpnLinks interVpnLinks = optIVpnLinksOpData.get();
- for (InterVpnLink interVpnLink : interVpnLinks.nonnullInterVpnLink()) {
+ for (InterVpnLink interVpnLink : interVpnLinks.nonnullInterVpnLink().values()) {
addInterVpnLinkToCaches(interVpnLink);
}
return;
}
InterVpnLinkStates interVpnLinkStates = optIVpnLinkStateOpData.get();
- for (InterVpnLinkState interVpnLinkState : interVpnLinkStates.nonnullInterVpnLinkState()) {
+ for (InterVpnLinkState interVpnLinkState : interVpnLinkStates.nonnullInterVpnLinkState().values()) {
addInterVpnLinkStateToCaches(interVpnLinkState);
}
} catch (ExecutionException | InterruptedException e) {
package org.opendaylight.netvirt.vpnmanager.intervpnlink;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
.setErrorDescription(errorMsg)
.build();
ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx ->
- tx.put(vpnLinkStateIid, vpnLinkErrorState, CREATE_MISSING_PARENTS)),
+ tx.mergeParentStructurePut(vpnLinkStateIid, vpnLinkErrorState)),
LOG, "Error storing the VPN link error state for {}, {}", vpnLinkStateIid, vpnLinkErrorState);
// Sending out an error Notification
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnTargets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpntargets.VpnTarget;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpntargets.VpnTargetKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.links.InterVpnLink;
import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
LOG.trace("vpn targets not available for {}", name);
return new ArrayList<>();
}
- List<VpnTarget> vpnTargets = targets.getVpnTarget();
+ Map<VpnTargetKey, VpnTarget> vpnTargets = targets.getVpnTarget();
if (vpnTargets == null) {
LOG.trace("vpnTarget values not available for {}", name);
return new ArrayList<>();
}
- return vpnTargets.stream()
+ return vpnTargets.values().stream()
.filter(target -> Objects.equals(target.getVrfRTType(), rtType)
|| Objects.equals(target.getVrfRTType(), VpnTarget.VrfRTType.Both))
.map(VpnTarget::getVrfRTValue)
package org.opendaylight.netvirt.vpnmanager.intervpnlink;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
.setFirstEndpointState(firstEndPointState).setSecondEndpointState(secondEndPointState)
.build();
return txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx ->
- tx.merge(InterVpnLinkUtil.getInterVpnLinkStateIid(interVpnLinkState.getInterVpnLinkName()),
- newInterVpnLinkState, CREATE_MISSING_PARENTS));
+ tx.mergeParentStructureMerge(InterVpnLinkUtil
+ .getInterVpnLinkStateIid(interVpnLinkState.getInterVpnLinkName()), newInterVpnLinkState));
}
private void installLPortDispatcherTable(InterVpnLinkState interVpnLinkState, List<Uint64> firstDpnList,
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkDataComposite;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.InterVpnLinkStates;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.InterVpnLinks;
}
- public static List<Instruction> buildLportDispatcherTableInstructions(Uint32 vpnId) {
+ public static Map<InstructionKey, Instruction> buildLportDispatcherTableInstructions(Uint32 vpnId) {
int instructionKey = 0;
- List<Instruction> instructions = new ArrayList<>();
- instructions.add(MDSALUtil.buildAndGetWriteMetadaInstruction(MetaDataUtil.getVpnIdMetadata(vpnId.intValue()),
- MetaDataUtil.METADATA_MASK_VRFID,
- ++instructionKey));
- instructions.add(MDSALUtil.buildAndGetGotoTableInstruction(NwConstants.L3_FIB_TABLE, ++instructionKey));
+ Map<InstructionKey, Instruction> instructions = new HashMap<InstructionKey, Instruction>();
+ instructions.put(new InstructionKey(++instructionKey), MDSALUtil.buildAndGetWriteMetadaInstruction(MetaDataUtil
+ .getVpnIdMetadata(vpnId.intValue()), MetaDataUtil.METADATA_MASK_VRFID, instructionKey));
+ instructions.put(new InstructionKey(++instructionKey),
+ MDSALUtil.buildAndGetGotoTableInstruction(NwConstants.L3_FIB_TABLE, instructionKey));
return instructions;
}
package org.opendaylight.netvirt.vpnmanager.intervpnlink.tasks;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
interVpnLinkToPersist.getSecondEndpoint().getIpAddress());
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx ->
- tx.merge(InterVpnLinkUtil.getInterVpnLinkPath(interVpnLinkToPersist.getName()),
- interVpnLinkToPersist, CREATE_MISSING_PARENTS)));
+ tx.mergeParentStructureMerge(InterVpnLinkUtil.getInterVpnLinkPath(interVpnLinkToPersist.getName()),
+ interVpnLinkToPersist)));
}
}
}
Adjacencies configAdjacencies = optVpnInterface.get().augmentation(Adjacencies.class);
List<Adjacency> adjacencyList = configAdjacencies == null ? new ArrayList<>()
- : new ArrayList<>(configAdjacencies.getAdjacency());
+ : new ArrayList<>(configAdjacencies.getAdjacency().values());
String ip = VpnUtil.getIpPrefix(srcPrefix);
AdjacencyBuilder newAdjBuilder;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import static org.opendaylight.infrautils.utils.concurrent.ListenableFutures.addErrorLogging;
-import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.base.Preconditions;
import java.util.Collections;
LabelRouteInfo lri = lriBuilder.build();
InstanceIdentifier<LabelRouteInfo> lriIid = InstanceIdentifier.builder(LabelRouteMap.class)
.child(LabelRouteInfo.class, new LabelRouteInfoKey(label)).build();
- tx.merge(lriIid, lri, CREATE_MISSING_PARENTS);
+ tx.mergeParentStructureMerge(lriIid, lri);
LOG.info("addToLabelMapper: Added label route info to label {} prefix {} nextHopList {} vpnId {}"
+ " interface {} rd {} elantag {}", labelStr, prefix, nextHopIpList, vpnId,
vpnInterfaceName, rd, elanTag);
.setVrfId(vpn.vpnOpData.getVrfId())
.build();
WriteTransaction writeTx1 = broker.newWriteOnlyTransaction();
- writeTx1.merge(LogicalDatastoreType.CONFIGURATION,
+ writeTx1.mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,
VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpn.vpnCfgData.getVpnInstanceName()),
- vpnInstance, true);
+ vpnInstance);
writeTx1.commit().get();
WriteTransaction writeTx2 = broker.newWriteOnlyTransaction();
- writeTx2.merge(LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getVpnInstanceOpDataIdentifier(vpn.vpnOpData.getVrfId()), vpn.vpnOpData, true);
+ writeTx2.mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL,
+ VpnUtil.getVpnInstanceOpDataIdentifier(vpn.vpnOpData.getVrfId()), vpn.vpnOpData);
writeTx2.commit().get();
}
}
vpnIntfList.add(vpnIntfs);
SubnetToDpn subnetToDpnLocal = new SubnetToDpnBuilder().setDpnId(dpId).withKey(new SubnetToDpnKey(dpId))
.setVpnInterfaces(vpnIntfList).build();
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, dpnOpId, subnetToDpnLocal,
- WriteTransaction.CREATE_MISSING_PARENTS);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, dpnOpId, subnetToDpnLocal);
}
subOpDpnManager.addPortOpDataEntry(infName, subnetId, dpId);
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, portOpIdentifier, portOp,
- WriteTransaction.CREATE_MISSING_PARENTS);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, portOpIdentifier, portOp);
}
@Test
subOpDpnManager.addPortOpDataEntry(infName, subnetId, dpId);
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, portOpIdentifier, portOp,
- WriteTransaction.CREATE_MISSING_PARENTS);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, portOpIdentifier, portOp);
}
@Test
vpnInstanceOptional = Optional.of(vpnInstnce);
optionalNetworks = Optional.of(networks);
- doReturn(Futures.immediateCheckedFuture(optionalIfState)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateFuture(optionalIfState)).when(mockReadTx).read(LogicalDatastoreType
.OPERATIONAL, ifStateId);
- doReturn(Futures.immediateCheckedFuture(optionalSubs)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateFuture(optionalSubs)).when(mockReadTx).read(LogicalDatastoreType
.OPERATIONAL, subOpIdentifier);
- doReturn(Futures.immediateCheckedFuture(optionalSubDpn)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateFuture(optionalSubDpn)).when(mockReadTx).read(LogicalDatastoreType
.OPERATIONAL, dpnOpId);
- doReturn(Futures.immediateCheckedFuture(optionalTunnelInfo)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateFuture(optionalTunnelInfo)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION, tunnelInfoId);
- doReturn(Futures.immediateCheckedFuture(optionalPortOp)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateFuture(optionalPortOp)).when(mockReadTx).read(LogicalDatastoreType
.OPERATIONAL, portOpIdentifier);
- doReturn(Futures.immediateCheckedFuture(optionalPtOp)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateFuture(optionalPtOp)).when(mockReadTx).read(LogicalDatastoreType
.OPERATIONAL, portOpIdentifr);
- doReturn(Futures.immediateCheckedFuture(optionalPortOp)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateFuture(optionalPortOp)).when(mockReadTx).read(LogicalDatastoreType
.OPERATIONAL, instPortOp);
- doReturn(Futures.immediateCheckedFuture(optionalSubnetMap)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateFuture(optionalSubnetMap)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION, subMapid);
- doReturn(Futures.immediateCheckedFuture(optionalVpnInstnce)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateFuture(optionalVpnInstnce)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION, instVpnInstance);
- doReturn(Futures.immediateCheckedFuture(vpnInstanceOptional)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateFuture(vpnInstanceOptional)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION, vpnInstanceIdentifier);
- doReturn(Futures.immediateCheckedFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION, netsIdentifier);
doReturn(idOutputOptional).when(idManager).allocateId(allocateIdInput);
networks = new NetworksBuilder().setId(portId).withKey(new NetworksKey(portId)).build();
doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
- doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).commit();
+ doReturn(Futures.immediateFuture(null)).when(mockWriteTx).commit();
}
@Ignore
vpnSubnetRouteHandler.onPortAddedToSubnet(subnetmap, portId);
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, portOpIdentifier, portOp,
- WriteTransaction.CREATE_MISSING_PARENTS);
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, dpnOpId, subnetToDpn,
- WriteTransaction.CREATE_MISSING_PARENTS);
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subnetOp,
- WriteTransaction.CREATE_MISSING_PARENTS);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, portOpIdentifier, portOp);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, dpnOpId, subnetToDpn);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subnetOp);
}
@Ignore
vpnSubnetRouteHandler.onPortRemovedFromSubnet(subnetmap, portId);
verify(mockWriteTx).delete(LogicalDatastoreType.OPERATIONAL, portOpIdentifier);
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, dpnOpId, subnetToDpn,
- WriteTransaction.CREATE_MISSING_PARENTS);
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subnetOp,
- WriteTransaction.CREATE_MISSING_PARENTS);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, dpnOpId, subnetToDpn);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subnetOp);
}
vpnSubnetRouteHandler.onInterfaceUp(dpId, interfaceName, subnetId);
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, instPortOp, portOp,
- WriteTransaction.CREATE_MISSING_PARENTS);
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, dpnOpId, subnetToDpn,
- WriteTransaction.CREATE_MISSING_PARENTS);
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subnetOp,
- WriteTransaction.CREATE_MISSING_PARENTS);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, instPortOp, portOp);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, dpnOpId, subnetToDpn);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subnetOp);
}
@Ignore
// TODO: subnetOpDpnManager is mocked so not sure how this delete ever worked.
//verify(mockWriteTx).delete(LogicalDatastoreType.OPERATIONAL, dpnOpId);
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subnetOp,
- WriteTransaction.CREATE_MISSING_PARENTS);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, subOpIdentifier, subnetOp);
}
@Test
public void testOnSubnetAddedToVpn() {
- doReturn(Futures.immediateCheckedFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
.OPERATIONAL, subOpIdentifier);
vpnSubnetRouteHandler.onSubnetAddedToVpn(subnetmap, true, elanTag);
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, dpnOpId, subnetToDpn,
- WriteTransaction.CREATE_MISSING_PARENTS);
- verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, portOpIdentifier, portOp,
- WriteTransaction.CREATE_MISSING_PARENTS);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, dpnOpId, subnetToDpn);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, portOpIdentifier, portOp);
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.1</version>
<relativePath/>
</parent>
Set<String> vpnInstances = new HashSet<>();
for (VpnInterface vpnInterface : vpnInterfaceConfigList) {
if (vpnInterface.getVpnInstanceNames() != null) {
- for (VpnInstanceNames vpnInterfaceVpnInstance : vpnInterface.getVpnInstanceNames()) {
+ for (VpnInstanceNames vpnInterfaceVpnInstance : vpnInterface.getVpnInstanceNames().values()) {
String vpnName = vpnInterfaceVpnInstance.getVpnName();
if (vpnName != null) {
vpnInstances.add(vpnName);
showVpn();
session.getConsole().println("Present Config VpnInterfaces are:");
for (VpnInterface vpnInterface : vpnInterfaceConfigList) {
- if (VpnHelper.doesVpnInterfaceBelongToVpnInstance(detail, vpnInterface.getVpnInstanceNames())) {
+ if (VpnHelper.doesVpnInterfaceBelongToVpnInstance(detail,
+ new ArrayList<VpnInstanceNames>(vpnInterface.getVpnInstanceNames().values()))) {
session.getConsole().println(vpnInterface.getName());
}
}
LOG.trace("No VPNInstances configured.");
session.getConsole().println("No VPNInstances configured.");
} else {
- vpnInstanceList = optionalVpnInstances.get().getVpnInstance();
+ vpnInstanceList = new ArrayList<VpnInstance>(optionalVpnInstances.get().getVpnInstance().values());
}
Optional<VpnInterfaces> optionalVpnInterfacesConfig =
LOG.trace("No Config VpnInterface is present");
session.getConsole().println("No Config VpnInterface is present");
} else {
- vpnInterfaceConfigList = optionalVpnInterfacesConfig.get().getVpnInterface();
+ vpnInterfaceConfigList = new ArrayList<VpnInterface>(optionalVpnInterfacesConfig.get()
+ .getVpnInterface().values());
}
LOG.trace("No Oper VpnInterface is present");
session.getConsole().println("No Oper VpnInterface is present");
} else {
- vpnInterfaceOpList = optionalVpnInterfacesOper.get().getVpnInterfaceOpDataEntry();
+ vpnInterfaceOpList = new ArrayList<VpnInterfaceOpDataEntry>(optionalVpnInterfacesOper.get()
+ .getVpnInterfaceOpDataEntry().values());
}
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.VpnInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances.VpnInstance;
import org.opendaylight.yangtools.yang.binding.DataObject;
"------------------------------------------------------------------------------");
VpnInstanceOpDataEntry check = vpnInstanceOpDataEntryMap.get(detail);
Long intfCount = 0L;
- List<VpnToDpnList> dpnToVpns = check.getVpnToDpnList();
- if (dpnToVpns != null) {
- for (VpnToDpnList dpn : dpnToVpns) {
+ Map<VpnToDpnListKey, VpnToDpnList> vpnToDpnListKeyVpnToDpnListMap = check.getVpnToDpnList();
+ if (vpnToDpnListKeyVpnToDpnListMap != null) {
+ for (VpnToDpnList dpn : vpnToDpnListKeyVpnToDpnListMap.values()) {
if (dpn.getVpnInterfaces() != null) {
intfCount = intfCount + dpn.getVpnInterfaces().size();
}
LOG.trace("No VPNInstances configured.");
session.getConsole().println("No VPNInstances configured.");
} else {
- vpnInstanceList = optionalVpnInstances.get().getVpnInstance();
+ vpnInstanceList = new ArrayList<VpnInstance>(optionalVpnInstances.get().getVpnInstance().values());
}
Optional<VpnInstanceOpData> optionalOpData = read(LogicalDatastoreType.OPERATIONAL,
LOG.trace("No VPNInstanceOpDataEntry present.");
session.getConsole().println("No VPNInstanceOpDataEntry present.");
} else {
- vpnInstanceOpDataEntryList = optionalOpData.get().getVpnInstanceOpDataEntry();
+ vpnInstanceOpDataEntryList = new ArrayList<VpnInstanceOpDataEntry>(optionalOpData.get()
+ .getVpnInstanceOpDataEntry().values());
}
for (VpnInstanceOpDataEntry vpnInstanceOpDataEntry : vpnInstanceOpDataEntryList) {
Code Review / netvirt.git / commitdiff