LinkedList<Long> ids = new LinkedList<>();
ids.add(1L);
-
-
- vi.setRouteEntryId(ids);
- vi.setVpnInterfaceCount(1L);
vi.setVrfId("1");
vi.setKey(new VpnInstanceOpDataEntryKey(rd));
// If another renderer(for eg : CSS) needs to be supported, check can be performed here
// to call the respective helpers.
String ifName = prefixInfo.getVpnInterfaceName();
- WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
Optional<VpnInterface> optvpnInterface = FibUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
FibUtil.getVpnInterfaceIdentifier(ifName));
if (optvpnInterface.isPresent()) {
}
//remove adjacency corr to prefix
if (numAdj > 1) {
- LOG.trace("cleanUpOpDataForFib: remove adjacency for prefix: {} {}", vpnId, vrfEntry.getDestPrefix());
+ LOG.info("cleanUpOpDataForFib: remove adjacency for prefix: {} {}", vpnId, vrfEntry.getDestPrefix());
FibUtil.delete(dataBroker, LogicalDatastoreType.OPERATIONAL,
FibUtil.getAdjacencyIdentifier(ifName, vrfEntry.getDestPrefix()));
}
FibUtil.getNextHopLabelKey(rd, vrfEntry.getDestPrefix()));
}
}
- CheckedFuture<Void, TransactionCommitFailedException> futures = writeTxn.submit();
- try {
- futures.get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Error cleaning up interface {} on vpn {}", ifName, vpnId);
- throw new RuntimeException(e.getMessage());
- }
return null;
}
}
dpnId, vpnId, rd, localNextHopIp, remoteNextHopIp);
InstanceIdentifier<VrfTables> id = buildVrfId(rd);
final VpnInstanceOpDataEntry vpnInstance = getVpnInstance(rd);
- final Optional<VrfTables> vrfTable = FibUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
- if (vrfTable.isPresent()) {
- DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
- dataStoreCoordinator.enqueueJob("FIB-" + vpnId + "-" + dpnId.toString(),
- new Callable<List<ListenableFuture<Void>>>() {
- @Override
- public List<ListenableFuture<Void>> call() throws Exception {
- List<ListenableFuture<Void>> futures = new ArrayList<>();
- synchronized (vpnInstance.getVpnInstanceName().intern()) {
- WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
- LOG.trace("populate FIB starts on Dpn " + dpnId
- + "rd " + rd.toString()
- + "localNextHopIp " + localNextHopIp
- + "remoteNextHopIp" + remoteNextHopIp
- + "vpnId " + vpnId );
- for (VrfEntry vrfEntry : vrfTable.get().getVrfEntry()) {
- LOG.trace("old vrfEntry before populate:: {}", vrfEntry);
-
- if (vrfEntry.getOrigin().equals(RouteOrigin.BGP.getValue())) {
- if (remoteNextHopIp.trim().equals(vrfEntry.getNextHopAddressList().get(0).trim())) {
- LOG.trace(" creating remote FIB entry for vfEntry {}", vrfEntry);
- createRemoteFibEntry(dpnId, vpnId, vrfTable.get().getKey(), vrfEntry, writeTransaction);
- }
- } else if (vrfEntry.getOrigin().equals(RouteOrigin.STATIC.getValue())) {
- BigInteger dpnIdForPrefix = null;
- String destPfx = vrfEntry.getDestPrefix();
- if (vrfEntry.getAugmentation(SubnetRoute.class) == null) {
- Optional<Extraroute> extraRouteInfo =
- FibUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- getVpnToExtrarouteIdentifier(rd, vrfEntry.getDestPrefix()));
- if (extraRouteInfo.isPresent()) {
- continue;
- }
- dpnIdForPrefix = nextHopManager.getDpnForPrefix(vpnId, destPfx);
- } else {
- // Subnet Route handling
- Optional<Prefixes> localNextHopInfoData =
- FibUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- FibUtil.getPrefixToInterfaceIdentifier(vpnId, destPfx));
- if (localNextHopInfoData.isPresent()) {
- Prefixes prefixes = localNextHopInfoData.get();
- dpnIdForPrefix = prefixes.getDpnId();
- }
- }
- if (dpnIdForPrefix == null) {
- LOG.trace("Populate::the dpnIdForPrefix is null for prefix {}.",
- vrfEntry.getDestPrefix());
+ final Optional<VrfTables> vrfTable = FibUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ if (vrfTable.isPresent()) {
+ DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
+ dataStoreCoordinator.enqueueJob("FIB-" + vpnId + "-" + dpnId.toString(),
+ new Callable<List<ListenableFuture<Void>>>() {
+ @Override
+ public List<ListenableFuture<Void>> call() throws Exception {
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ synchronized (vpnInstance.getVpnInstanceName().intern()) {
+ WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
+ LOG.trace("populate FIB starts on Dpn " + dpnId
+ + "rd " + rd.toString()
+ + "localNextHopIp " + localNextHopIp
+ + "remoteNextHopIp" + remoteNextHopIp
+ + "vpnId " + vpnId );
+ for (VrfEntry vrfEntry : vrfTable.get().getVrfEntry()) {
+ LOG.trace("old vrfEntry before populate:: {}", vrfEntry);
+
+ if (vrfEntry.getOrigin().equals(RouteOrigin.BGP.getValue())) {
+ if (remoteNextHopIp.trim().equals(vrfEntry.getNextHopAddressList().get(0).trim())) {
+ LOG.trace(" creating remote FIB entry for vfEntry {}", vrfEntry);
+ createRemoteFibEntry(dpnId, vpnId, vrfTable.get().getKey(), vrfEntry, writeTransaction);
+ }
+ } else if (vrfEntry.getOrigin().equals(RouteOrigin.STATIC.getValue())) {
+ BigInteger dpnIdForPrefix = null;
+ String destPfx = vrfEntry.getDestPrefix();
+ if (vrfEntry.getAugmentation(SubnetRoute.class) == null) {
+ Optional<Extraroute> extraRouteInfo =
+ FibUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ getVpnToExtrarouteIdentifier(rd, vrfEntry.getDestPrefix()));
+ if (extraRouteInfo.isPresent()) {
continue;
}
- int sameDpnId = dpnIdForPrefix.compareTo(dpnId);
- if (sameDpnId != 0) {
- LOG.trace("Populate::Different srcDpnId {} and dpnIdForPrefix {} for prefix {}",
- dpnId, dpnIdForPrefix, vrfEntry.getDestPrefix());
- continue;
+ dpnIdForPrefix = nextHopManager.getDpnForPrefix(vpnId, destPfx);
+ } else {
+ // Subnet Route handling
+ Optional<Prefixes> localNextHopInfoData =
+ FibUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ FibUtil.getPrefixToInterfaceIdentifier(vpnId, destPfx));
+ if (localNextHopInfoData.isPresent()) {
+ Prefixes prefixes = localNextHopInfoData.get();
+ dpnIdForPrefix = prefixes.getDpnId();
}
- InstanceIdentifier<VrfEntry> vrfEntryId = getVrfEntryId(rd, vrfEntry.getDestPrefix());
- List<String> newNextHopAddrList = vrfEntry.getNextHopAddressList();
- newNextHopAddrList.add(localNextHopIp);
- VrfEntry newVrfEntry =
- new VrfEntryBuilder(vrfEntry).setNextHopAddressList(newNextHopAddrList).build();
- // Just update the VrfEntry
- FibUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION,
- vrfEntryId, newVrfEntry);
- // writeTransaction.put(LogicalDatastoreType.CONFIGURATION,
- // vrfEntryId, newVrfEntry);
- vrfEntry = getVrfEntry(dataBroker, rd, destPfx);
- LOG.trace("updated vrfEntry after populate:: {}", vrfEntry);
}
+ if (dpnIdForPrefix == null) {
+ LOG.trace("Populate::the dpnIdForPrefix is null for prefix {}.",
+ vrfEntry.getDestPrefix());
+ continue;
+ }
+ int sameDpnId = dpnIdForPrefix.compareTo(dpnId);
+ if (sameDpnId != 0) {
+ LOG.trace("Populate::Different srcDpnId {} and dpnIdForPrefix {} for prefix {}",
+ dpnId, dpnIdForPrefix, vrfEntry.getDestPrefix());
+ continue;
+ }
+ InstanceIdentifier<VrfEntry> vrfEntryId = getVrfEntryId(rd, vrfEntry.getDestPrefix());
+ List<String> newNextHopAddrList = vrfEntry.getNextHopAddressList();
+ newNextHopAddrList.add(localNextHopIp);
+ VrfEntry newVrfEntry =
+ new VrfEntryBuilder(vrfEntry).setNextHopAddressList(newNextHopAddrList).build();
+ // Just update the VrfEntry
+ FibUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ vrfEntryId, newVrfEntry);
+ // writeTransaction.put(LogicalDatastoreType.CONFIGURATION,
+ // vrfEntryId, newVrfEntry);
+ vrfEntry = getVrfEntry(dataBroker, rd, destPfx);
+ LOG.trace("updated vrfEntry after populate:: {}", vrfEntry);
}
- futures.add(writeTransaction.submit());
- LOG.trace("populate FIB ends on Dpn " + dpnId
- + "rd " + rd.toString()
- + "localNextHopIp " + localNextHopIp
- + "remoteNextHopIp" + remoteNextHopIp
- + "vpnId " + vpnId);
}
- return futures;
+ futures.add(writeTransaction.submit());
+ LOG.trace("populate FIB ends on Dpn " + dpnId
+ + "rd " + rd.toString()
+ + "localNextHopIp " + localNextHopIp
+ + "remoteNextHopIp" + remoteNextHopIp
+ + "vpnId " + vpnId);
}
- });
- }
+ return futures;
+ }
+ });
+ }
}
public void handleRemoteRoute(final boolean action, final BigInteger localDpnId, final BigInteger remoteDpnId,
LOG.trace("Remove dpn {} for vpn {} : cleanUpDpnForVpn", dpnId, rd);
InstanceIdentifier<VrfTables> id = buildVrfId(rd);
final VpnInstanceOpDataEntry vpnInstance = getVpnInstance(rd);
- final Optional<VrfTables> vrfTable = FibUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
- if (vrfTable.isPresent()) {
- DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
- dataStoreCoordinator.enqueueJob("FIB-" + vpnId + "-" + dpnId.toString(),
- new Callable<List<ListenableFuture<Void>>>() {
- @Override
- public List<ListenableFuture<Void>> call() throws Exception {
- List<ListenableFuture<Void>> futures = new ArrayList<>();
- synchronized (vpnInstance.getVpnInstanceName().intern()) {
- WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
- for (final VrfEntry vrfEntry : vrfTable.get().getVrfEntry()) {
- /* Handle subnet routes here */
- SubnetRoute subnetRoute = vrfEntry.getAugmentation(SubnetRoute.class);
- if (subnetRoute != null) {
- LOG.trace("Cleaning subnetroute {} on dpn {} for vpn {} : cleanUpDpnForVpn", vrfEntry.getDestPrefix(),
- dpnId, rd);
- makeConnectedRoute(dpnId, vpnId, vrfEntry, rd, null, NwConstants.DEL_FLOW, tx);
- makeLFibTableEntry(dpnId, vrfEntry.getLabel(), null, DEFAULT_FIB_FLOW_PRIORITY, NwConstants.DEL_FLOW, tx);
- LOG.trace("cleanUpDpnForVpn: Released subnetroute label {} for rd {} prefix {}", vrfEntry.getLabel(), rd,
- vrfEntry.getDestPrefix());
- continue;
- }
- // Passing null as we don't know the dpn
- // to which prefix is attached at this point
- deleteRemoteRoute(null, dpnId, vpnId, vrfTable.get().getKey(), vrfEntry, tx);
- }
- futures.add(tx.submit());
- if (callback != null) {
- ListenableFuture<List<Void>> listenableFuture = Futures.allAsList(futures);
- Futures.addCallback(listenableFuture, callback);
+ final Optional<VrfTables> vrfTable = FibUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ if (vrfTable.isPresent()) {
+ DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
+ dataStoreCoordinator.enqueueJob("FIB-" + vpnId + "-" + dpnId.toString(),
+ new Callable<List<ListenableFuture<Void>>>() {
+ @Override
+ public List<ListenableFuture<Void>> call() throws Exception {
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ synchronized (vpnInstance.getVpnInstanceName().intern()) {
+ WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
+ for (final VrfEntry vrfEntry : vrfTable.get().getVrfEntry()) {
+ /* Handle subnet routes here */
+ SubnetRoute subnetRoute = vrfEntry.getAugmentation(SubnetRoute.class);
+ if (subnetRoute != null) {
+ LOG.trace("Cleaning subnetroute {} on dpn {} for vpn {} : cleanUpDpnForVpn", vrfEntry.getDestPrefix(),
+ dpnId, rd);
+ makeConnectedRoute(dpnId, vpnId, vrfEntry, rd, null, NwConstants.DEL_FLOW, tx);
+ makeLFibTableEntry(dpnId, vrfEntry.getLabel(), null, DEFAULT_FIB_FLOW_PRIORITY, NwConstants.DEL_FLOW, tx);
+ LOG.trace("cleanUpDpnForVpn: Released subnetroute label {} for rd {} prefix {}", vrfEntry.getLabel(), rd,
+ vrfEntry.getDestPrefix());
+ continue;
}
+ // Passing null as we don't know the dpn
+ // to which prefix is attached at this point
+ deleteRemoteRoute(null, dpnId, vpnId, vrfTable.get().getKey(), vrfEntry, tx);
+ }
+ futures.add(tx.submit());
+ if (callback != null) {
+ ListenableFuture<List<Void>> listenableFuture = Futures.allAsList(futures);
+ Futures.addCallback(listenableFuture, callback);
}
- return futures;
}
+ return futures;
+ }
- });
-
+ });
}
}
final VpnInterface vpnInterface = VpnUtil.getConfiguredVpnInterface(dataBroker, interfaceName);
if (vpnInterface != null) {
LOG.debug("VPN Interface Name {}", vpnInterface);
- final BigInteger dpnId = InterfaceUtils.getDpIdFromInterface(intrf);
+ BigInteger intfDpnId = BigInteger.ZERO;
+ try {
+ intfDpnId = InterfaceUtils.getDpIdFromInterface(intrf);
+ } catch (Exception e){
+ LOG.error("Unable to retrieve dpnId for interface {}. Process vpn interface add fail with exception {}.",
+ intrf.getName(), e);
+ return;
+ }
+ final BigInteger dpnId = intfDpnId;
final int ifIndex = intrf.getIfIndex();
DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
dataStoreCoordinator.enqueueJob("VPNINTERFACE-" + intrf.getName(),
try {
final String interfaceName = intrf.getName();
LOG.info("Received port DOWN event for interface {} ", interfaceName);
- if (intrf != null && intrf.getType() != null && intrf.getType().equals(Tunnel.class)) {
- //withdraw all prefixes in all vpns for this dpn from bgp
- // FIXME: Blocked until tunnel event[vxlan/gre] support is available
- // vpnInterfaceManager.updatePrefixesForDPN(dpId, VpnInterfaceManager.UpdateRouteAction.WITHDRAW_ROUTE);
- } else {
+ if (intrf != null && intrf.getType() != null && !intrf.getType().equals(Tunnel.class)) {
BigInteger dpId = BigInteger.ZERO;
InstanceIdentifier<VpnInterface> id = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
Optional<VpnInterface> optVpnInterface = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
try {
dpId = InterfaceUtils.getDpIdFromInterface(intrf);
} catch (Exception e){
- LOG.warn("Unable to retrieve dpnId from interface operational data store for interface {}. Fetching from vpn interface op data store. ", intrf.getName(), e);
+ LOG.error("Unable to retrieve dpnId from interface operational data store for interface {}.Fetching from vpn interface op data store. ", intrf.getName(), e);
dpId = vpnInterface.getDpnId();
}
final BigInteger dpnId = dpId;
return;
}
final BigInteger dpnId = InterfaceUtils.getDpIdFromInterface(update);
+
final int ifIndex = update.getIfIndex();
- if (update != null) {
+ if (update != null && (update.getType() != null)) {
if (!update.getType().equals(Tunnel.class)) {
final VpnInterface vpnInterface = VpnUtil.getConfiguredVpnInterface(dataBroker, interfaceName);
if (vpnInterface != null) {
package org.opendaylight.netvirt.vpnmanager;
import java.math.BigInteger;
+
+import com.google.common.base.Optional;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.utilities.InterfaceUtils;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
@Override
protected void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
- LOG.trace("Received interface {} up event", intrf);
+ LOG.trace("SubnetRouteInterfaceListener add: Received interface {} up event", intrf);
try {
String interfaceName = intrf.getName();
- LOG.info("Received port UP event for interface {} ", interfaceName);
+ LOG.info("SubnetRouteInterfaceListener add: Received port UP event for interface {} ", interfaceName);
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface
configInterface = InterfaceUtils.getInterface(dataBroker, interfaceName);
- if (configInterface != null) {
+ if (configInterface != null && (configInterface.getType() != null)) {
if (!configInterface.getType().equals(Tunnel.class)) {
- BigInteger dpnId = InterfaceUtils.getDpIdFromInterface(intrf);
- vpnSubnetRouteHandler.onInterfaceUp(dpnId, intrf.getName());
+ final VpnInterface vpnInterface = VpnUtil.getConfiguredVpnInterface(dataBroker, interfaceName);
+ if (vpnInterface != null) {
+ BigInteger dpnId = BigInteger.ZERO;
+ try {
+ dpnId = InterfaceUtils.getDpIdFromInterface(intrf);
+ } catch (Exception e) {
+ LOG.error("SubnetRouteInterfaceListener add: Unable to obtain dpnId for interface {},",
+ " subnetroute inclusion for this interface failed with exception {}",
+ interfaceName, e);
+ return;
+ }
+ vpnSubnetRouteHandler.onInterfaceUp(dpnId, intrf.getName());
+ }
}
}
} catch (Exception e) {
- LOG.error("Exception observed in handling addition for VPN Interface {}. ", intrf.getName(), e);
+ LOG.error("SubnetRouteInterfaceListener add: Exception observed in handling addition for VPN Interface {}. ", intrf.getName(), e);
}
}
@Override
protected void remove(InstanceIdentifier<Interface> identifier, Interface intrf) {
- LOG.trace("Received interface {} down event", intrf);
+ LOG.trace("SubnetRouteInterfaceListener remove: Received interface {} down event", intrf);
try {
String interfaceName = intrf.getName();
BigInteger dpnId = BigInteger.ZERO;
- LOG.info("Received port DOWN event for interface {} ", interfaceName);
- if (intrf != null && intrf.getType() != null && intrf.getType().equals(Tunnel.class)) {
- //withdraw all prefixes in all vpns for this dpn from bgp
- // FIXME: Blocked until tunnel event[vxlan/gre] support is available
- // vpnInterfaceManager.updatePrefixesForDPN(dpId, VpnInterfaceManager.UpdateRouteAction.WITHDRAW_ROUTE);
- } else {
+ LOG.info("SubnetRouteInterfaceListener remove: Received port DOWN event for interface {} ", interfaceName);
+ if (intrf != null && intrf.getType() != null && (!intrf.getType().equals(Tunnel.class))) {
+ InstanceIdentifier<VpnInterface> id = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
+ Optional<VpnInterface> optVpnInterface = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ if (!optVpnInterface.isPresent()) {
+ LOG.debug("SubnetRouteInterfaceListener remove: Interface {} is not a vpninterface, ignoring.", intrf.getName());
+ return;
+ }
+ VpnInterface vpnInterface = optVpnInterface.get();
try {
dpnId = InterfaceUtils.getDpIdFromInterface(intrf);
- } catch (Exception e){
- LOG.error("Unable to retrieve dpnId from interface operational data store for interface {}. Fetching from vpn interface op data store. ", intrf.getName(), e);
+ } catch (Exception e) {
+ LOG.error("SubnetRouteInterfaceListener remove: Unable to retrieve dpnId for interface {}. " +
+ "Fetching from vpn interface itself due to exception {}",
+ intrf.getName(), e);
+ dpnId = vpnInterface.getDpnId();
}
vpnSubnetRouteHandler.onInterfaceDown(dpnId, intrf.getName());
}
} catch (Exception e) {
- LOG.error("Exception observed in handling deletion of VPN Interface {}. ", intrf.getName(), e);
+ LOG.error("SubnetRouteInterfaceListener remove: Exception observed in handling deletion of VPN Interface {}. ",
+ intrf.getName(), e);
}
}
@Override
protected void update(InstanceIdentifier<Interface> identifier,
Interface original, Interface update) {
- LOG.trace("Operation Interface update event - Old: {}, New: {}", original, update);
+ LOG.trace("SubnetRouteInterfaceListener update: Operation Interface update event - Old: {}, New: {}", original, update);
String interfaceName = update.getName();
- BigInteger dpId = InterfaceUtils.getDpIdFromInterface(update);
- if (update != null) {
+ BigInteger dpnId = BigInteger.ZERO;
+ if (update != null && (update.getType() != null)) {
if (!update.getType().equals(Tunnel.class)) {
- if (update.getOperStatus().equals(Interface.OperStatus.Up)) {
- vpnSubnetRouteHandler.onInterfaceUp(dpId, update.getName());
- } else if (update.getOperStatus().equals(Interface.OperStatus.Down)) {
- if (VpnUtil.isVpnInterfaceConfigured(dataBroker, interfaceName)) {
- vpnSubnetRouteHandler.onInterfaceDown(dpId, update.getName());
+ final VpnInterface vpnInterface = VpnUtil.getConfiguredVpnInterface(dataBroker, interfaceName);
+ if (vpnInterface != null) {
+ if (update.getOperStatus().equals(Interface.OperStatus.Up)) {
+ try {
+ dpnId = InterfaceUtils.getDpIdFromInterface(update);
+ } catch (Exception e) {
+ LOG.error("SubnetRouteInterfaceListener update: Unable to obtain dpnId for interface {} port up,",
+ " subnetroute inclusion for this interface failed with exception {}",
+ interfaceName, e);
+ return;
+ }
+ vpnSubnetRouteHandler.onInterfaceUp(dpnId, update.getName());
+ } else if (update.getOperStatus().equals(Interface.OperStatus.Down)) {
+ try {
+ dpnId = InterfaceUtils.getDpIdFromInterface(update);
+ } catch (Exception e) {
+ LOG.error("SubnetRouteInterfaceListener update: Unable to obtain dpnId for interface {} port down,",
+ " subnetroute exclusion for this interface failed with exception {}",
+ interfaceName, e);
+ return;
+ }
+ vpnSubnetRouteHandler.onInterfaceDown(dpnId, update.getName());
}
}
}
vpnId, rd, adjacency.getIpAddress(), srcTepIp, destTepIp);
}
if ((tunTypeVal == VpnConstants.ITMTunnelLocType.External.getValue()) &&
- (dcgwPresentStatus == VpnConstants.DCGWPresentStatus.Absent.getValue())) { bgpManager.withdrawPrefix(rd, adjacency.getIpAddress());
+ (dcgwPresentStatus == VpnConstants.DCGWPresentStatus.Absent.getValue())) {
+ bgpManager.withdrawPrefix(rd, adjacency.getIpAddress());
fibManager.cleanUpDpnForVpn(srcDpnId, vpnId, rd, srcTepIp, destTepIp, null);
}
}
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;
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.to.extraroute.Vpn;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
VpnInstanceOpDataEntry vpnOpEntry = null;
Long intfCount = 0L;
Long currentIntfCount = 0L;
- Integer retryCount = 2;
+ Integer retryCount = 3;
long timeout = VpnConstants.MIN_WAIT_TIME_IN_MILLISECONDS;
Optional<VpnInstanceOpDataEntry> vpnOpValue = null;
vpnOpValue = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
// Clean up VpnInstanceToVpnId from Config DS
VpnUtil.removeVpnIdToVpnInstance(broker, vpnId, writeTxn);
VpnUtil.removeVpnInstanceToVpnId(broker, vpnName, writeTxn);
-
- List<ListenableFuture<Void>> futures = new ArrayList<>();
- futures.add(writeTxn.submit());
LOG.trace("Removed vpnIdentifier for rd{} vpnname {}", rd, vpnName);
if (rd != null) {
synchronized (vpnName.intern()) {
}
// Clean up VPNExtraRoutes Operational DS
- VpnUtil.removeVpnExtraRouteForVpn(broker, rd, null);
+ InstanceIdentifier<Vpn> vpnToExtraroute = VpnUtil.getVpnToExtrarouteIdentifier(rd);
+ Optional<Vpn> optVpnToExtraroute = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, vpnToExtraroute);
+ if (optVpnToExtraroute.isPresent()) {
+ VpnUtil.removeVpnExtraRouteForVpn(broker, rd, writeTxn);
+ }
// Clean up VPNInstanceOpDataEntry
- VpnUtil.removeVpnOpInstance(broker, rd, null);
+ VpnUtil.removeVpnOpInstance(broker, rd, writeTxn);
} else {
// Clean up FIB Entries Config DS
synchronized (vpnName.intern()) {
fibManager.removeVrfTable(broker, vpnName, null);
}
// Clean up VPNExtraRoutes Operational DS
- VpnUtil.removeVpnExtraRouteForVpn(broker, vpnName, null);
+ InstanceIdentifier<Vpn> vpnToExtraroute = VpnUtil.getVpnToExtrarouteIdentifier(vpnName);
+ Optional<Vpn> optVpnToExtraroute = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, vpnToExtraroute);
+ if (optVpnToExtraroute.isPresent()) {
+ VpnUtil.removeVpnExtraRouteForVpn(broker, vpnName, writeTxn);
+ }
// Clean up VPNInstanceOpDataEntry
- VpnUtil.removeVpnOpInstance(broker, vpnName, null);
+ VpnUtil.removeVpnOpInstance(broker, vpnName, writeTxn);
}
// Clean up PrefixToInterface Operational DS
- VpnUtil.removePrefixToInterfaceForVpnId(broker, vpnId, null);
+ VpnUtil.removePrefixToInterfaceForVpnId(broker, vpnId, writeTxn);
// Clean up L3NextHop Operational DS
- VpnUtil.removeL3nexthopForVpnId(broker, vpnId, null);
+ VpnUtil.removeL3nexthopForVpnId(broker, vpnId, writeTxn);
// Release the ID used for this VPN back to IdManager
VpnUtil.releaseId(idManager, VpnConstants.VPN_IDPOOL_NAME, vpnName);
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ futures.add(writeTxn.submit());
return futures;
}
}
if (rd == null) {
VpnInstanceOpDataEntryBuilder builder =
new VpnInstanceOpDataEntryBuilder().setVrfId(vpnInstanceName).setVpnId(vpnId)
- .setVpnInstanceName(vpnInstanceName)
- .setVpnInterfaceCount(0L);
+ .setVpnInstanceName(vpnInstanceName);
if (writeOperTxn != null) {
writeOperTxn.merge(LogicalDatastoreType.OPERATIONAL,
VpnUtil.getVpnInstanceOpDataIdentifier(vpnInstanceName),
VpnUtil.getVpnInstanceOpDataIdentifier(vpnInstanceName),
builder.build(), TransactionUtil.DEFAULT_CALLBACK);
}
- synchronized (vpnInstanceName.intern()) {
- fibManager.addVrfTable(dataBroker, vpnInstanceName, null);
- }
} else {
VpnInstanceOpDataEntryBuilder builder = new VpnInstanceOpDataEntryBuilder()
- .setVrfId(rd).setVpnId(vpnId).setVpnInstanceName(vpnInstanceName).setVpnInterfaceCount(0L);
+ .setVrfId(rd).setVpnId(vpnId).setVpnInstanceName(vpnInstanceName);
if (writeOperTxn != null) {
writeOperTxn.merge(LogicalDatastoreType.OPERATIONAL,
VpnUtil.getVpnInstanceOpDataIdentifier(rd),
builder.build(), TransactionUtil.DEFAULT_CALLBACK);
}
- synchronized (vpnInstanceName.intern()) {
- fibManager.addVrfTable(dataBroker, rd, null);
- }
}
}
InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class)
.child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
Optional<VpnInstance> vpnInstance = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
- String rd = "";
+ String rd = null;
if(vpnInstance.isPresent()) {
VpnInstance instance = vpnInstance.get();
VpnAfConfig config = instance.getIpv4Family();
* After retries completed, rollbackworker is executed.
* If rollbackworker fails, this is a double-fault. Double fault is logged and ignored.
*/
-
@Override
public void onFailure(Throwable throwable) {
LOG.warn("Job: failed with exception: {}", throwable.getStackTrace());
vpnInterfaces = new ArrayList<>();
}
vpnInterfaces.add(vpnInterface);
- VpnToDpnListBuilder vpnToDpnListBuilder = new VpnToDpnListBuilder().setDpnId(dpnId);
+ VpnToDpnListBuilder vpnToDpnListBuilder = new VpnToDpnListBuilder(vpnToDpnList);
vpnToDpnListBuilder.setDpnState(VpnToDpnList.DpnState.Active).setVpnInterfaces(vpnInterfaces);
+
if (writeTxn != null) {
writeTxn.put(LogicalDatastoreType.OPERATIONAL, id, vpnToDpnListBuilder.build(), true);
} else {
LOG.error("Error adding to dpnToVpnList for vpn {} interface {} dpn {}", vpnName, intfName, dpnId);
throw new RuntimeException(e.getMessage());
}
-
}
/*
* Informing the Fib only after writeTxn is submitted successfuly.
if (newDpnOnVpn) {
LOG.debug("Sending populateFib event for new dpn {} in VPN {}", dpnId, vpnName);
fibManager.populateFibOnNewDpn(dpnId, vpnId, rd, new DpnEnterExitVpnWorker(dpnId, vpnName, rd, true /* entered */));
- publishAddNotification(dpnId, vpnName, rd);
}
}
if (lastDpnOnVpn) {
LOG.debug("Sending cleanup event for dpn {} in VPN {}", dpnId, vpnName);
fibManager.cleanUpDpnForVpn(dpnId, vpnId, rd, new DpnEnterExitVpnWorker(dpnId, vpnName, rd, false /* exited */));
- publishRemoveNotification(dpnId, vpnName, rd);
}
}
}
public synchronized void deleteSubnetRouteFibEntryFromDS(String rd, String prefix, String vpnName){
- fibManager.removeOrUpdateFibEntry(dataBroker, rd, prefix, null /* nextHopToRemove */, null);
+ fibManager.removeFibEntry(dataBroker, rd, prefix, null);
List<VpnInstance> vpnsToImportRoute = getVpnsImportingMyRoute(vpnName);
for (VpnInstance vpnInstance : vpnsToImportRoute) {
String importingRd = vpnInstance.getIpv4Family().getRouteDistinguisher();
LOG.info("Deleting imported subnet route rd {} prefix {} from vpn {}", rd, prefix, vpnInstance.getVpnInstanceName());
- fibManager.removeOrUpdateFibEntry(dataBroker, importingRd, prefix, null /* nextHopToRemove */, null);
+ fibManager.removeFibEntry(dataBroker, importingRd, prefix, null);
}
}
VpnInterface currVpnIntf = optVpnInterface.get();
String prefix = VpnUtil.getIpPrefix(adj.getIpAddress());
String rd = getRouteDistinguisher(currVpnIntf.getVpnInstanceName());
+ rd = (rd != null) ? rd : currVpnIntf.getVpnInstanceName();
InstanceIdentifier<Adjacencies> adjPath = identifier.augmentation(Adjacencies.class);
Optional<Adjacencies> optAdjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, adjPath);
long label =
VpnUtil.getUniqueId(idManager, VpnConstants.VPN_IDPOOL_NAME,
- VpnUtil.getNextHopLabelKey((rd != null) ? rd : currVpnIntf.getVpnInstanceName(), prefix));
+ VpnUtil.getNextHopLabelKey(rd, prefix));
List<Adjacency> adjacencies;
if (optAdjacencies.isPresent()) {
if (!adjacencies.isEmpty()) {
String rd = getRouteDistinguisher(currVpnIntf.getVpnInstanceName());
+ rd = (rd != null) ? rd :currVpnIntf.getVpnInstanceName();
LOG.trace("Adjacencies are " + adjacencies);
Iterator<Adjacency> adjIt = adjacencies.iterator();
while (adjIt.hasNext()) {
public List<ListenableFuture<Void>> call() throws Exception {
WriteTransaction writeOperTxn = dataBroker.newWriteOnlyTransaction();
postProcessVpnInterfaceRemoval(identifier, del, writeOperTxn);
- CheckedFuture<Void, TransactionCommitFailedException> futures = writeOperTxn.submit();
- try {
- futures.get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Error handling removal of oper data for interface {} from vpn {}", interfaceName,
- vpnName);
- throw new RuntimeException(e.getMessage());
- }
- return null;
+ List<ListenableFuture<Void>> futures = new ArrayList<ListenableFuture<Void>>();
+ futures.add(writeOperTxn.submit());
+ return futures;
}
});
}
String interfaceName = key.getName();
String vpnName = del.getVpnInstanceName();
- LOG.trace("VpnInterfaceOpListener removed: interface name {} vpnName {}", interfaceName, vpnName);
+ LOG.info("VpnInterfaceOpListener removed: interface name {} vpnName {}", interfaceName, vpnName);
//decrement the vpn interface count in Vpn Instance Op Data
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to
.vpn.id.VpnInstance>
//String rd = getRouteDistinguisher(del.getVpnInstanceName());
VpnInstanceOpDataEntry vpnInstOp = VpnUtil.getVpnInstanceOpData(dataBroker, rd);
- LOG.trace("VpnInterfaceOpListener removed: interface name {} rd {} vpnName {} in Vpn Op Instance {}",
- interfaceName, rd, vpnName, vpnInstOp);
+ LOG.trace("VpnInterfaceOpListener removed: interface name {} rd {} vpnName {}",
+ interfaceName, rd, vpnName);
if (vpnInstOp != null) {
// Vpn Interface removed => No more adjacencies from it.
for (Uuid port: portList) {
Interface intfState = InterfaceUtils.getInterfaceStateFromOperDS(dataBroker,port.getValue());
if (intfState != null) {
- dpnId = InterfaceUtils.getDpIdFromInterface(intfState);
- if (dpnId == null) {
+ try {
+ dpnId = InterfaceUtils.getDpIdFromInterface(intfState);
+ } catch (Exception e) {
+ logger.error("onSubnetAddedToVpn: Unable to obtain dpnId for interface {},",
+ " subnetroute inclusion for this interface failed with exception {}",
+ port.getValue(), e);
+ continue;
+ }
+ if (dpnId.equals(BigInteger.ZERO)) {
logger.info("onSubnetAddedToVpn: Port " + port.getValue() + " is not assigned DPN yet, ignoring ");
continue;
}
subOpDpnManager.addPortOpDataEntry(portId.getValue(), subnetId, null);
return;
}
- BigInteger dpnId = InterfaceUtils.getDpIdFromInterface(intfState);
- if (dpnId == null) {
+ BigInteger dpnId = BigInteger.ZERO;
+ try {
+ dpnId = InterfaceUtils.getDpIdFromInterface(intfState);
+ } catch (Exception e) {
+ logger.error("onSubnetAddedToVpn: Unable to obtain dpnId for interface {},",
+ " subnetroute inclusion for this interface failed with exception {}",
+ portId.getValue(), e);
+ return;
+ }
+ if (dpnId.equals(BigInteger.ZERO)) {
logger.info("onPortAddedToSubnet: Port " + portId.getValue() + " is not assigned DPN yet, ignoring ");
return;
}
.child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
}
- static VpnInstanceOpDataEntry getVpnInstanceOpDataBuilder(String rd, long vpnId, String vpnName) {
- return new VpnInstanceOpDataEntryBuilder().setVrfId(rd).setVpnId(vpnId).setVpnInstanceName(vpnName).build();
- }
-
- static VpnInstanceOpDataEntry updateIntfCntInVpnInstOpData(Long newCount, String vrfId) {
- return new VpnInstanceOpDataEntryBuilder().setVpnInterfaceCount(newCount).setVrfId(vrfId).build();
- }
-
static InstanceIdentifier<RouterInterface> getRouterInterfaceId(String interfaceName) {
return InstanceIdentifier.builder(RouterInterfaces.class)
.child(RouterInterface.class, new RouterInterfaceKey(interfaceName)).build();
Code Review / netvirt.git / commitdiff