import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPort;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
boolean isBgpVpnInternetVpn = vpnUtil.isBgpVpnInternet(vpnName);
if (interfaceState != null) {
try {
- final BigInteger dpnId = InterfaceUtils.getDpIdFromInterface(interfaceState);
+ final Uint64 dpnId = InterfaceUtils.getDpIdFromInterface(interfaceState);
final int ifIndex = interfaceState.getIfIndex();
jobCoordinator.enqueueJob("VPNINTERFACE-" + interfaceName, () -> {
// TODO Deal with sequencing — the config tx must only submitted if the oper tx goes in
// "Unconditional wait" and "Wait not in loop" wrt the VpnNotifyTask below - suppressing the FB violation -
// see comments below.
@SuppressFBWarnings({"UW_UNCOND_WAIT", "WA_NOT_IN_LOOP"})
- protected void processVpnInterfaceUp(final BigInteger dpId, VpnInterface vpnInterface, final String primaryRd,
+ protected void processVpnInterfaceUp(final Uint64 dpId, VpnInterface vpnInterface, final String primaryRd,
final int lportTag, boolean isInterfaceUp,
TypedWriteTransaction<Configuration> writeConfigTxn,
TypedWriteTransaction<Operational> writeOperTxn,
if (!isInterfaceUp) {
LOG.info("processVpnInterfaceUp: Binding vpn service to interface {} onto dpn {} for vpn {}",
interfaceName, dpId, vpnName);
- long vpnId = vpnUtil.getVpnId(vpnName);
- if (vpnId == VpnConstants.INVALID_ID) {
+ Uint32 vpnId = vpnUtil.getVpnId(vpnName);
+ if (VpnConstants.INVALID_ID.equals(vpnId)) {
LOG.warn("processVpnInterfaceUp: VpnInstance to VPNId mapping not available for VpnName {}"
+ " processing vpninterface {} on dpn {}, bailing out now.", vpnName, interfaceName,
dpId);
}
}
- private void processExternalVpnInterface(String interfaceName, String vpnName, BigInteger dpId,
+ private void processExternalVpnInterface(String interfaceName, String vpnName, Uint64 dpId,
int lportTag, int addOrRemove) {
Uuid extNetworkId;
try {
+ " for vpn {}", routerIds, interfaceName, dpId, vpnName);
for (Uuid routerId : routerIds) {
String routerName = routerId.getValue();
- BigInteger primarySwitch = vpnUtil.getPrimarySwitchForRouter(routerName);
+ Uint64 primarySwitch = vpnUtil.getPrimarySwitchForRouter(routerName);
if (Objects.equals(primarySwitch, dpId)) {
Routers router = vpnUtil.getExternalRouter(routerName);
if (router != null) {
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- private void advertiseAdjacenciesForVpnToBgp(final String rd, BigInteger dpnId,
+ private void advertiseAdjacenciesForVpnToBgp(final String rd, Uint64 dpnId,
final InstanceIdentifier<VpnInterfaceOpDataEntry> identifier,
String vpnName, String interfaceName) {
if (rd == null) {
LOG.debug("advertiseAdjacenciesForVpnToBgp: NextHops are {} for interface {} on dpn {} for vpn {}"
+ " rd {}", nextHops, interfaceName, dpnId, vpnName, rd);
VpnInstanceOpDataEntry vpnInstanceOpData = vpnUtil.getVpnInstanceOpData(rd);
- long l3vni = vpnInstanceOpData.getL3vni();
+ Uint32 l3vni = vpnInstanceOpData.getL3vni();
VrfEntry.EncapType encapType = VpnUtil.isL3VpnOverVxLan(l3vni)
? VrfEntry.EncapType.Vxlan : VrfEntry.EncapType.Mplsgre;
for (Adjacency nextHop : nextHops) {
continue;
}
String gatewayMac = null;
- long label = 0;
+ Uint32 label = Uint32.ZERO;
if (VpnUtil.isL3VpnOverVxLan(l3vni)) {
final VpnPortipToPort gwPort = vpnUtil.getNeutronPortFromVpnPortFixedIp(
vpnInstanceOpData.getVpnInstanceName(), nextHop.getIpAddress());
LOG.info("VPN ADVERTISE: advertiseAdjacenciesForVpnToBgp: Adding Fib Entry rd {} prefix {}"
+ " nexthop {} label {}", rd, nextHop.getIpAddress(), nextHopIp, label);
bgpManager.advertisePrefix(rd, nextHop.getMacAddress(), nextHop.getIpAddress(), nextHopIp,
- encapType, (int)label, l3vni, 0 /*l2vni*/,
+ encapType, label, l3vni, Uint32.ZERO /*l2vni*/,
gatewayMac);
LOG.info("VPN ADVERTISE: advertiseAdjacenciesForVpnToBgp: Added Fib Entry rd {} prefix {}"
+ " nexthop {} label {} for interface {} on dpn {} for vpn {}", rd,
}
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void processVpnInterfaceAdjacencies(BigInteger dpnId, final int lportTag, String vpnName,
- String primaryRd, String interfaceName, final long vpnId,
+ protected void processVpnInterfaceAdjacencies(Uint64 dpnId, final int lportTag, String vpnName,
+ String primaryRd, String interfaceName, final Uint32 vpnId,
TypedWriteTransaction<Configuration> writeConfigTxn,
TypedWriteTransaction<Operational> writeOperTxn,
TypedReadWriteTransaction<Configuration> writeInvTxn,
if (vpnInteface.isPresent()) {
intfnetworkUuid = vpnInteface.get().getNetworkId();
networkType = vpnInteface.get().getNetworkType();
- segmentationId = vpnInteface.get().getSegmentationId();
+ segmentationId = vpnInteface.get().getSegmentationId().toJava();
adjacencies = vpnInteface.get().augmentation(Adjacencies.class);
if (adjacencies == null) {
addVpnInterfaceToOperational(vpnName, interfaceName, dpnId, null/*adjacencies*/, lportTag,
- null/*gwMac*/, writeOperTxn);
+ null/*gwMac*/, null/*gatewayIp*/, writeOperTxn);
return;
}
}
// Get the rd of the vpn instance
String nextHopIp = null;
+ String gatewayIp = null;
try {
nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, dpnId);
} catch (Exception e) {
Optional<String> gwMac = Optional.absent();
String vpnInterfaceSubnetGwMacAddress = null;
VpnInstanceOpDataEntry vpnInstanceOpData = vpnUtil.getVpnInstanceOpData(primaryRd);
- Long l3vni = vpnInstanceOpData.getL3vni();
+ Uint32 l3vni = vpnInstanceOpData.getL3vni() != null ? vpnInstanceOpData.getL3vni() : Uint32.ZERO;
boolean isL3VpnOverVxLan = VpnUtil.isL3VpnOverVxLan(l3vni);
VrfEntry.EncapType encapType = isL3VpnOverVxLan ? VrfEntry.EncapType.Vxlan : VrfEntry.EncapType.Mplsgre;
VpnPopulator registeredPopulator = L3vpnRegistry.getRegisteredPopulator(encapType);
vpnUtil.getVpnId(vpnName), prefix), prefixes, true);
final Uuid subnetId = nextHop.getSubnetId();
- String gatewayIp = nextHop.getSubnetGatewayIp();
+ gatewayIp = nextHop.getSubnetGatewayIp();
if (gatewayIp == null) {
Optional<String> gatewayIpOptional = vpnUtil.getVpnSubnetGatewayIp(subnetId);
if (gatewayIpOptional.isPresent()) {
AdjacenciesOp aug = VpnUtil.getVpnInterfaceOpDataEntryAugmentation(value);
addVpnInterfaceToOperational(vpnName, interfaceName, dpnId, aug, lportTag,
- gwMac.isPresent() ? gwMac.get() : null, writeOperTxn);
+ gwMac.isPresent() ? gwMac.get() : null, gatewayIp, writeOperTxn);
- L3vpnInput input = new L3vpnInput().setNextHopIp(nextHopIp).setL3vni(l3vni).setPrimaryRd(primaryRd)
+ L3vpnInput input = new L3vpnInput().setNextHopIp(nextHopIp).setL3vni(l3vni.longValue()).setPrimaryRd(primaryRd)
.setGatewayMac(gwMac.orNull()).setInterfaceName(interfaceName)
.setVpnName(vpnName).setDpnId(dpnId).setEncapType(encapType);
}
}
- private void addVpnInterfaceToOperational(String vpnName, String interfaceName, BigInteger dpnId, AdjacenciesOp aug,
- long lportTag, String gwMac,
+ private void addVpnInterfaceToOperational(String vpnName, String interfaceName, Uint64 dpnId, AdjacenciesOp aug,
+ long lportTag, String gwMac, String gwIp,
TypedWriteTransaction<Operational> writeOperTxn) {
VpnInterfaceOpDataEntry opInterface =
- VpnUtil.getVpnInterfaceOpDataEntry(interfaceName, vpnName, aug, dpnId, lportTag, gwMac);
+ VpnUtil.getVpnInterfaceOpDataEntry(interfaceName, vpnName, aug, dpnId, lportTag, gwMac, gwIp);
InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId = VpnUtil
.getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnName);
writeOperTxn.put(interfaceId, opInterface, CREATE_MISSING_PARENTS);
TypedWriteTransaction<Operational> writeOperTxn) {
String srcTepIp = stateTunnelList.getSrcInfo().getTepIp().stringValue();
- BigInteger srcDpnId = new BigInteger(stateTunnelList.getSrcInfo().getTepDeviceId());
+ 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();
return;
}
String prefix = null;
- long label = 0;
List<Adjacency> value = new ArrayList<>();
boolean isNextHopAddReqd = false;
String vpnName = vpnInterface.getVpnInstanceName();
- long vpnId = vpnUtil.getVpnId(vpnName);
+ Uint32 vpnId = vpnUtil.getVpnId(vpnName);
String primaryRd = vpnUtil.getPrimaryRd(vpnName);
LOG.info("updateVpnInterfaceOnTepAdd: AdjacencyList for interface {} on dpn {} vpn {} is {}",
vpnInterface.getName(), vpnInterface.getDpnId(),
String rd = adj.getVrfId();
rd = rd != null ? rd : vpnName;
prefix = adj.getIpAddress();
- label = adj.getLabel();
+ Uint32 label = adj.getLabel();
List<String> nhList = Collections.singletonList(srcTepIp);
List<String> nextHopList = adj.getNextHopIpList();
// If TEP is added , update the nexthop of primary adjacency.
try {
if (!rd.equalsIgnoreCase(vpnName)) {
bgpManager.advertisePrefix(rd, null /*macAddress*/, prefix, nhList,
- VrfEntry.EncapType.Mplsgre, (int)label, 0 /*evi*/, 0 /*l2vni*/,
+ VrfEntry.EncapType.Mplsgre, label, Uint32.ZERO /*evi*/, Uint32.ZERO /*l2vni*/,
null /*gatewayMacAddress*/);
}
LOG.info("updateVpnInterfaceOnTepAdd: Advertised rd {} prefix {} nhList {} label {}"
AdjacenciesOp adjacencies = vpnInterface.augmentation(AdjacenciesOp.class);
List<Adjacency> adjList = adjacencies != null ? adjacencies.getAdjacency() : new ArrayList<>();
String prefix = null;
- long label = 0;
boolean isNextHopRemoveReqd = false;
String srcTepIp = stateTunnelList.getSrcInfo().getTepIp().stringValue();
- BigInteger srcDpnId = new BigInteger(stateTunnelList.getSrcInfo().getTepDeviceId());
+ Uint64 srcDpnId = Uint64.valueOf(stateTunnelList.getSrcInfo().getTepDeviceId()).intern();
String vpnName = vpnInterface.getVpnInstanceName();
- long vpnId = vpnUtil.getVpnId(vpnName);
+ Uint32 vpnId = vpnUtil.getVpnId(vpnName);
String primaryRd = vpnUtil.getVpnRd(vpnName);
if (adjList != null) {
List<Adjacency> value = new ArrayList<>();
rd = rd != null ? rd : vpnName;
prefix = adj.getIpAddress();
List<String> nextHopList = adj.getNextHopIpList();
- label = adj.getLabel();
+ Uint32 label = adj.getLabel();
if (nextHopList != null && !nextHopList.isEmpty()) {
isNextHopRemoveReqd = true;
}
String gwMac = vrfEntry.getGatewayMacAddress();
vrfEntry.nonnullRoutePaths().forEach(routePath -> {
String nh = routePath.getNexthopAddress();
- int label = routePath.getLabel().intValue();
+ Uint32 label = routePath.getLabel();
if (FibHelper.isControllerManagedVpnInterfaceRoute(RouteOrigin.value(
vrfEntry.getOrigin()))) {
LOG.info(
vpn.getVrfId(), prefix, nh, label, vpnName, vpnRd);
fibManager.addOrUpdateFibEntry(vpnRd, null /*macAddress*/, prefix,
Collections.singletonList(nh), VrfEntry.EncapType.Mplsgre, label,
- 0 /*l3vni*/, gwMac, vpn.getVrfId(), RouteOrigin.SELF_IMPORTED,
+ Uint32.ZERO /*l3vni*/, gwMac, vpn.getVrfId(), RouteOrigin.SELF_IMPORTED,
confTx);
} else {
LOG.info("handleVpnsExportingRoutes: Importing subnet route fib entry"
txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, writeInvTxn -> {
LOG.info("remove: - intfName {} onto vpnName {} running config-driven",
interfaceName, vpnName);
- BigInteger dpId;
+ Uint64 dpId;
int ifIndex;
String gwMacAddress;
InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId =
+ " data store for interface {} on dpn {} for vpn {} Fetching"
+ " from vpn interface op data store. ", interfaceName,
vpnInterface.getDpnId(), vpnName, e);
- dpId = BigInteger.ZERO;
+ dpId = Uint64.ZERO;
}
ifIndex = interfaceState.getIfIndex();
gwMacAddress = interfaceState.getPhysAddress().getValue();
}, DJC_MAX_RETRIES);
}
- protected void processVpnInterfaceDown(BigInteger dpId,
+ protected void processVpnInterfaceDown(Uint64 dpId,
String interfaceName,
int lportTag,
String gwMac,
InstanceIdentifier<VpnInterfaceOpDataEntry> identifier = VpnUtil.getVpnInterfaceOpDataEntryIdentifier(
interfaceName, vpnName);
if (!isInterfaceStateDown) {
- final long vpnId = vpnUtil.getVpnId(vpnName);
+ final Uint32 vpnId = vpnUtil.getVpnId(vpnName);
vpnUtil.scheduleVpnInterfaceForRemoval(interfaceName, dpId, vpnName, null);
final boolean isBgpVpnInternetVpn = vpnUtil.isBgpVpnInternet(vpnName);
removeAdjacenciesFromVpn(dpId, lportTag, interfaceName, vpnName,
}
}
- private void removeAdjacenciesFromVpn(final BigInteger dpnId, final int lportTag, final String interfaceName,
- final String vpnName, final long vpnId, String gwMac,
+ private void removeAdjacenciesFromVpn(final Uint64 dpnId, final int lportTag, final String interfaceName,
+ final String vpnName, final Uint32 vpnId, String gwMac,
TypedWriteTransaction<Configuration> writeConfigTxn,
TypedWriteTransaction<Operational> writeOperTxn,
TypedReadWriteTransaction<Configuration> writeInvTxn)
try {
InstanceIdentifier<VpnInterfaceOpDataEntry> identifier = VpnUtil
.getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnName);
- InstanceIdentifier<AdjacenciesOp> path = identifier.augmentation(AdjacenciesOp.class);
- Optional<AdjacenciesOp> adjacencies = SingleTransactionDataBroker.syncReadOptional(dataBroker,
- LogicalDatastoreType.OPERATIONAL, path);
- boolean isLearntIP = false;
+ Optional<VpnInterfaceOpDataEntry> vpnInterfaceOpDataEnteryOptional =
+ SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, identifier);
+ boolean isLearntIP = Boolean.FALSE;
String primaryRd = vpnUtil.getVpnRd(vpnName);
LOG.info("removeAdjacenciesFromVpn: For interface {} on dpn {} RD recovered for vpn {} as rd {}",
interfaceName, dpnId, vpnName, primaryRd);
- if (adjacencies.isPresent() && adjacencies.get().getAdjacency() != null
- && !adjacencies.get().getAdjacency().isEmpty()) {
- List<Adjacency> nextHops = adjacencies.get().getAdjacency();
+ if (!vpnInterfaceOpDataEnteryOptional.isPresent()) {
+ LOG.error("removeAdjacenciesFromVpn: VpnInterfaceOpDataEntry-Oper DS is absent for Interface {} "
+ + "on vpn {} dpn {}", interfaceName, vpnName, dpnId);
+ return;
+ }
+ AdjacenciesOp adjacencies = vpnInterfaceOpDataEnteryOptional.get().augmentation(AdjacenciesOp.class);
+
+ if (adjacencies != null && !adjacencies.getAdjacency().isEmpty()) {
+ List<Adjacency> nextHops = adjacencies.getAdjacency();
LOG.info("removeAdjacenciesFromVpn: NextHops for interface {} on dpn {} for vpn {} are {}",
interfaceName, dpnId, vpnName, nextHops);
for (Adjacency nextHop : nextHops) {
nhList = nextHop.getNextHopIpList() != null ? nextHop.getNextHopIpList()
: emptyList();
removeGwMacAndArpResponderFlows(nextHop, vpnId, dpnId, lportTag, gwMac,
+ vpnInterfaceOpDataEnteryOptional.get().getGatewayIpAddress(),
interfaceName, writeInvTxn);
}
if (!nhList.isEmpty()) {
}
private Consumer<String> removeAdjacencyFromInternalVpn(Adjacency nextHop, String vpnName,
- String interfaceName, BigInteger dpnId,
+ String interfaceName, Uint64 dpnId,
TypedWriteTransaction<Configuration> writeConfigTxn,
TypedWriteTransaction<Operational> writeOperTx) {
return (nh) -> {
}
private void removeAdjacencyFromBgpvpn(Adjacency nextHop, List<String> nhList, String vpnName, String primaryRd,
- BigInteger dpnId, String rd, String interfaceName,
+ Uint64 dpnId, String rd, String interfaceName,
TypedWriteTransaction<Configuration> writeConfigTxn,
TypedWriteTransaction<Operational> writeOperTx) {
List<VpnInstanceOpDataEntry> vpnsToImportRoute =
});
}
- private void removeGwMacAndArpResponderFlows(Adjacency nextHop, long vpnId, BigInteger dpnId,
- int lportTag, String gwMac, String interfaceName,
+ private void removeGwMacAndArpResponderFlows(Adjacency nextHop, Uint32 vpnId, Uint64 dpnId,
+ int lportTag, String gwMac, String gwIp, String interfaceName,
TypedReadWriteTransaction<Configuration> writeInvTxn)
throws ExecutionException, InterruptedException {
final Uuid subnetId = nextHop.getSubnetId();
// to remove the flows for the same here from the L3_GW_MAC_TABLE.
vpnUtil.setupGwMacIfExternalVpn(dpnId, interfaceName, vpnId, writeInvTxn, NwConstants.DEL_FLOW, gwMac);
}
- arpResponderHandler.removeArpResponderFlow(dpnId, lportTag, interfaceName, nextHop.getSubnetGatewayIp(),
+ arpResponderHandler.removeArpResponderFlow(dpnId, lportTag, interfaceName, gwIp,
subnetId);
}
- private List<String> getNextHopForNonPrimaryAdjacency(Adjacency nextHop, String vpnName, BigInteger dpnId,
+ private List<String> getNextHopForNonPrimaryAdjacency(Adjacency nextHop, String vpnName, Uint64 dpnId,
String interfaceName) {
// This is either an extra-route (or) a learned IP via subnet-route
List<String> nhList = null;
return;
}
final String vpnInterfaceName = update.getName();
- final BigInteger dpnId = InterfaceUtils.getDpnForInterface(ifaceMgrRpcService, vpnInterfaceName);
+ final Uint64 dpnId = InterfaceUtils.getDpnForInterface(ifaceMgrRpcService, vpnInterfaceName);
LOG.info("VPN Interface update event - intfName {}", vpnInterfaceName);
//handles switching between <internal VPN - external VPN>
jobCoordinator.enqueueJob("VPNINTERFACE-" + vpnInterfaceName, () -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
- //Ignore
+ LOG.error("updateVpnInstanceChange: InterruptedException caught for interface {}", interfaceName, e);
}
}
for (String newVpnName : newVpnList) {
+ "VPN instance {}", interfaceName, newAdjs, original.getVpnInstanceNames());
updateVpnInstanceAdjChange(original, update, interfaceName, futures);
}
+ } else {
+ LOG.info("updateVpnInstanceChange: failed to Add for update on VPNInterface {} from oldVpn(s) {} to "
+ + "newVpn {} as the new vpn does not exist in oper DS or it is in PENDING_DELETE state",
+ interfaceName, oldVpnListCopy, newVpnName);
}
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private List<ListenableFuture<Void>> updateVpnInstanceAdjChange(VpnInterface original, VpnInterface update,
String vpnInterfaceName,
List<ListenableFuture<Void>> futures) {
final List<Adjacency> newAdjs = updateAdjs != null && updateAdjs.getAdjacency()
!= null ? updateAdjs.getAdjacency() : new ArrayList<>();
- final BigInteger dpnId = InterfaceUtils.getDpnForInterface(ifaceMgrRpcService, vpnInterfaceName);
+ final Uint64 dpnId = InterfaceUtils.getDpnForInterface(ifaceMgrRpcService, vpnInterfaceName);
for (VpnInstanceNames vpnInterfaceVpnInstance : update.nonnullVpnInstanceNames()) {
String newVpnName = vpnInterfaceVpnInstance.getVpnName();
List<Adjacency> copyNewAdjs = new ArrayList<>(newAdjs);
} else {
// add new adjacency
if (!isBgpVpnInternetVpn || vpnUtil.isAdjacencyEligibleToVpnInternet(adj)) {
- addNewAdjToVpnInterface(vpnInterfaceOpIdentifier, primaryRd, adj,
+ try {
+ addNewAdjToVpnInterface(vpnInterfaceOpIdentifier, primaryRd, adj,
dpnId, operTx, confTx, confTx, prefixListForRefreshFib);
+ } catch (RuntimeException e) {
+ LOG.error("Failed to add adjacency {} to vpn interface {} with"
+ + " dpnId {}", adj, vpnInterfaceName, dpnId, e);
+ }
}
LOG.info("update: new Adjacency {} with nextHop {} label {} subnet {} "
+ " added to vpn interface {} on vpn {} dpnId {}",
return futures;
}
- private void updateLabelMapper(Long label, List<String> nextHopIpList) {
+ private void updateLabelMapper(Uint32 label, List<String> nextHopIpList) {
final String labelStr = Preconditions.checkNotNull(label, "updateLabelMapper: label cannot be null or empty!")
.toString();
// FIXME: separate this out somehow?
}
}
- public synchronized void importSubnetRouteForNewVpn(String rd, String prefix, String nextHop, int label,
+ public synchronized void importSubnetRouteForNewVpn(String rd, String prefix, String nextHop, Uint32 label,
SubnetRoute route, String parentVpnRd, TypedWriteTransaction<Configuration> writeConfigTxn) {
RouteOrigin origin = RouteOrigin.SELF_IMPORTED;
}
protected void addNewAdjToVpnInterface(InstanceIdentifier<VpnInterfaceOpDataEntry> identifier, String primaryRd,
- Adjacency adj, BigInteger dpnId,
+ Adjacency adj, Uint64 dpnId,
TypedWriteTransaction<Operational> writeOperTxn,
TypedWriteTransaction<Configuration> writeConfigTxn,
TypedReadWriteTransaction<Configuration> writeInvTxn,
LogicalDatastoreType.OPERATIONAL, adjPath);
boolean isL3VpnOverVxLan = VpnUtil.isL3VpnOverVxLan(vpnInstanceOpData.getL3vni());
VrfEntry.EncapType encapType = VpnUtil.getEncapType(isL3VpnOverVxLan);
- long l3vni = vpnInstanceOpData.getL3vni() == null ? 0L : vpnInstanceOpData.getL3vni();
+ Uint32 l3vni = vpnInstanceOpData.getL3vni() == null ? Uint32.ZERO : vpnInstanceOpData.getL3vni();
VpnPopulator populator = L3vpnRegistry.getRegisteredPopulator(encapType);
List<Adjacency> adjacencies = new ArrayList<>();
if (optAdjacencies.isPresent() && optAdjacencies.get().getAdjacency() != null) {
adjacencies.addAll(optAdjacencies.get().getAdjacency());
}
- long vpnId = vpnUtil.getVpnId(vpnName);
+ Uint32 vpnId = vpnUtil.getVpnId(vpnName);
L3vpnInput input = new L3vpnInput().setNextHop(adj).setVpnName(vpnName)
.setInterfaceName(currVpnIntf.getName()).setPrimaryRd(primaryRd).setRd(primaryRd);
Adjacency operationalAdjacency = null;
vpnUtil.getVpnsImportingMyRoute(vpnName);
vpnsToImportRoute.forEach(vpn -> {
if (vpn.getVrfId() != null) {
- vpnUtil.allocateRdForExtraRouteAndUpdateUsedRdsMap(vpn.getVpnId(), vpnId, prefix,
+ vpnUtil.allocateRdForExtraRouteAndUpdateUsedRdsMap(vpn.getVpnId(),
+ vpnId, prefix,
vpnUtil.getVpnName(vpn.getVpnId()), nh, dpnId)
.ifPresent(
rds -> vpnManager.addExtraRoute(
.getVpnInterfaceIdentifier(currVpnIntf.getName());
Optional<VpnInterface> vpnIntefaceConfig = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, vpnIfaceConfigidentifier);
- Prefixes pnfPrefix = VpnUtil.getPrefixToInterface(BigInteger.ZERO, currVpnIntf.getName(), prefix,
+ Prefixes pnfPrefix = VpnUtil.getPrefixToInterface(Uint64.ZERO, currVpnIntf.getName(), prefix,
Prefixes.PrefixCue.PhysNetFunc);
if (vpnIntefaceConfig.isPresent()) {
- pnfPrefix = VpnUtil.getPrefixToInterface(BigInteger.ZERO, currVpnIntf.getName(), prefix,
+ pnfPrefix = VpnUtil.getPrefixToInterface(Uint64.ZERO, currVpnIntf.getName(), prefix,
vpnIntefaceConfig.get().getNetworkId(), vpnIntefaceConfig.get().getNetworkType(),
- vpnIntefaceConfig.get().getSegmentationId(), Prefixes.PrefixCue.PhysNetFunc);
+ vpnIntefaceConfig.get().getSegmentationId().toJava(), Prefixes.PrefixCue.PhysNetFunc);
}
String parentVpnRd = getParentVpnRdForExternalSubnet(adj);
prefix), pnfPrefix, true);
fibManager.addOrUpdateFibEntry(adj.getSubnetId().getValue(), adj.getMacAddress(),
- adj.getIpAddress(), emptyList(), null /* EncapType */, 0 /* label */,
- 0 /*l3vni*/, null /* gw-mac */, parentVpnRd, RouteOrigin.LOCAL, writeConfigTxn);
+ adj.getIpAddress(), emptyList(), null /* EncapType */, Uint32.ZERO /* label */,
+ Uint32.ZERO /*l3vni*/, null /* gw-mac */, parentVpnRd,
+ RouteOrigin.LOCAL, writeConfigTxn);
input.setRd(adj.getVrfId());
}
AdjacenciesOp aug = VpnUtil.getVpnInterfaceOpDataEntryAugmentation(adjacencies);
VpnInterfaceOpDataEntry newVpnIntf =
VpnUtil.getVpnInterfaceOpDataEntry(currVpnIntf.getName(), currVpnIntf.getVpnInstanceName(),
- aug, dpnId, currVpnIntf.getLportTag(),
- currVpnIntf.getGatewayMacAddress());
-
+ aug, dpnId, currVpnIntf.getLportTag().toJava(),
+ currVpnIntf.getGatewayMacAddress(), currVpnIntf.getGatewayIpAddress());
writeOperTxn.merge(identifier, newVpnIntf, CREATE_MISSING_PARENTS);
}
} catch (ReadFailedException e) {
}
protected void delAdjFromVpnInterface(InstanceIdentifier<VpnInterfaceOpDataEntry> identifier, Adjacency adj,
- BigInteger dpnId, TypedWriteTransaction<Operational> writeOperTxn,
+ Uint64 dpnId, TypedWriteTransaction<Operational> writeOperTxn,
TypedWriteTransaction<Configuration> writeConfigTxn) {
String interfaceName = identifier.firstKeyOf(VpnInterfaceOpDataEntry.class).getName();
String vpnName = identifier.firstKeyOf(VpnInterfaceOpDataEntry.class).getVpnInstanceName();
for (Adjacency adjacency : adjacencies) {
if (Objects.equals(adjacency.getIpAddress(), adj.getIpAddress())) {
String rd = adjacency.getVrfId();
- InstanceIdentifier<Adjacency> adjIdentifier = VpnUtil
- .getVpnInterfaceOpDataEntryAdjacencyIdentifier(currVpnIntf.getName(),
- currVpnIntf.getVpnInstanceName(), adj.getIpAddress());
- LOG.debug("delAdjFromVpnInterface: adjIdentifier {}", adjIdentifier);
- writeOperTxn.delete(adjIdentifier);
if (adj.getNextHopIpList() != null) {
for (String nh : adj.getNextHopIpList()) {
deleteExtraRouteFromCurrentAndImportingVpns(
private void deleteExtraRouteFromCurrentAndImportingVpns(String vpnName, String destination, String nextHop,
String rd, String intfName, TypedWriteTransaction<Configuration> writeConfigTxn,
TypedWriteTransaction<Operational> writeOperTx) {
+ LOG.info("removing extra-route {} for nexthop {} in VPN {} intfName {} rd {}",
+ destination, nextHop, vpnName, intfName, rd);
vpnManager.delExtraRoute(vpnName, destination, nextHop, rd, vpnName, intfName, writeConfigTxn, writeOperTx);
List<VpnInstanceOpDataEntry> vpnsToImportRoute = vpnUtil.getVpnsImportingMyRoute(vpnName);
for (VpnInstanceOpDataEntry vpn : vpnsToImportRoute) {
String vpnRd = vpn.getVrfId();
if (vpnRd != null) {
+ LOG.info("deleting extra-route {} for nexthop {} in VPN {} intfName {} vpnRd {}",
+ destination, nextHop, vpnName, intfName, vpnRd);
vpnManager.delExtraRoute(vpnName, destination, nextHop, vpnRd, vpnName, intfName, writeConfigTxn,
writeOperTx);
}
}
}
- InstanceIdentifier<DpnVpninterfacesList> getRouterDpnId(String routerName, BigInteger dpnId) {
+ InstanceIdentifier<DpnVpninterfacesList> getRouterDpnId(String routerName, Uint64 dpnId) {
return InstanceIdentifier.builder(NeutronRouterDpns.class)
.child(RouterDpnList.class, new RouterDpnListKey(routerName))
.child(DpnVpninterfacesList.class, new DpnVpninterfacesListKey(dpnId)).build();
String macAddress = adj.getMacAddress();
String prefix = VpnUtil.getIpPrefix(primaryInterfaceIp);
- long label = vpnUtil.getUniqueId(VpnConstants.VPN_IDPOOL_NAME,
+ Uint32 label = vpnUtil.getUniqueId(VpnConstants.VPN_IDPOOL_NAME,
VpnUtil.getNextHopLabelKey(primaryRd, prefix));
RouterInterface routerInt = new RouterInterfaceBuilder().setUuid(vpnName)
ListenableFuture<Void> configTxFuture =
txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
confTx -> addNewAdjToVpnInterface(existingVpnInterfaceId,
- primaryRd, adjacency, vpnInterfaceOptional.get().getDpnId(),
+ primaryRd, adjacency,
+ vpnInterfaceOptional.get().getDpnId(),
operTx, confTx, confTx, prefixListForRefreshFib));
Futures.addCallback(configTxFuture,
new VpnInterfaceCallBackHandler(primaryRd, prefixListForRefreshFib),