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);
}));
Code Review / netvirt.git / blobdiff