*/
package org.opendaylight.netvirt.vpnmanager;
-import com.google.common.base.*;
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.Iterators;
-import com.google.common.util.concurrent.*;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.JdkFutureAdapters;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
+import org.opendaylight.genius.mdsalutil.AbstractDataChangeListener;
+import org.opendaylight.genius.mdsalutil.ActionInfo;
+import org.opendaylight.genius.mdsalutil.ActionType;
+import org.opendaylight.genius.mdsalutil.FlowEntity;
+import org.opendaylight.genius.mdsalutil.InstructionInfo;
+import org.opendaylight.genius.mdsalutil.InstructionType;
+import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.genius.mdsalutil.MatchFieldType;
+import org.opendaylight.genius.mdsalutil.MatchInfo;
+import org.opendaylight.genius.mdsalutil.MetaDataUtil;
+import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
-import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
+import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.netvirt.vpnmanager.utilities.InterfaceUtils;
-
-import org.opendaylight.controller.md.sal.binding.api.*;
-import org.opendaylight.genius.mdsalutil.*;
-import org.opendaylight.genius.mdsalutil.AbstractDataChangeListener;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
+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.af.config.VpnTargets;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTarget;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
+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.yang.types.rev130715.PhysAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
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;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
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.genius.itm.op.rev160406.TepTypeExternal;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeHwvtep;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeInternal;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelsState;
-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.rpcs.rev160406.IsDcgwPresentInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsDcgwPresentOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
+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.inventory.rev130819.NodeId;
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.inventory.rev130819.nodes.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.FibRpcService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.LabelRouteMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.SubnetRoute;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.SubnetRouteBuilder;
+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.VrfTablesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.label.route.map.LabelRouteInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.label.route.map.LabelRouteInfoBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.label.route.map.LabelRouteInfoKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.*;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
+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.VrfEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AddDpnEvent;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AddDpnEventBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.NeutronRouterDpns;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.RemoveDpnEvent;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.RemoveDpnEventBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.add.dpn.event.AddEventData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.add.dpn.event.AddEventDataBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyKey;
-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.neutron.router.dpns.RouterDpnList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns.RouterDpnListBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns.RouterDpnListKey;
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.remove.dpn.event.RemoveEventDataBuilder;
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.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListBuilder;
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.VpnInterfacesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfacesKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
-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.VrfTablesBuilder;
-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.VrfEntryBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-
-import java.math.BigInteger;
-import java.util.Collection;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.concurrent.*;
-
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
-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.rpcs.rev160406.ItmRpcService;
-import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronvpnService;
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.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.links.InterVpnLink;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyBuilder;
-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.VpnAfConfig;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface> implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(VpnInterfaceManager.class);
- private ListenerRegistration<DataChangeListener> listenerRegistration, opListenerRegistration, tunnelInterfaceStateListenerRegistration;
- private final DataBroker broker;
+ private ListenerRegistration<DataChangeListener> listenerRegistration;
+ private final DataBroker dataBroker;
private final IBgpManager bgpManager;
- private IFibManager fibManager;
- private IMdsalApiManager mdsalManager;
- private OdlInterfaceRpcService ifaceMgrRpcService;
- private ItmRpcService itmProvider;
- private IdManagerService idManager;
- private OdlArputilService arpManager;
- private NeutronvpnService neuService;
- private VpnSubnetRouteHandler vpnSubnetRouteHandler;
+ private final IFibManager fibManager;
+ private final IMdsalApiManager mdsalManager;
+ private final IdManagerService idManager;
+ private final OdlArputilService arpManager;
+ private final OdlInterfaceRpcService ifaceMgrRpcService;
+ private final NotificationPublishService notificationPublishService;
private ConcurrentHashMap<String, Runnable> vpnIntfMap = new ConcurrentHashMap<String, Runnable>();
private ExecutorService executorService = Executors.newSingleThreadExecutor();
- private InterfaceStateChangeListener interfaceListener;
- private SubnetRouteInterfaceStateChangeListener subnetRouteInterfaceListener;
- private TunnelInterfaceStateListener tunnelInterfaceStateListener;
- private VpnInterfaceOpListener vpnInterfaceOpListener;
- private ArpNotificationHandler arpNotificationHandler;
- private DpnInVpnChangeListener dpnInVpnChangeListener;
- private NotificationPublishService notificationPublishService;
- private FibRpcService fibService;
- /**
- * Responsible for listening to data change related to VPN Interface
- * Bind VPN Service on the interface and informs the BGP service
- *
- * @param db - dataBroker service reference
- * @param bgpManager Used to advertise routes to the BGP Router
- * @param notificationService Used to subscribe to notification events
- */
- public VpnInterfaceManager(final DataBroker db, final IBgpManager bgpManager, NotificationService notificationService) {
+ public VpnInterfaceManager(final DataBroker dataBroker,
+ final IBgpManager bgpManager,
+ final OdlArputilService arpManager,
+ final IdManagerService idManager,
+ final IMdsalApiManager mdsalManager,
+ final IFibManager fibManager,
+ final OdlInterfaceRpcService ifaceMgrRpcService,
+ final NotificationPublishService notificationPublishService) {
super(VpnInterface.class);
- broker = db;
+ this.dataBroker = dataBroker;
this.bgpManager = bgpManager;
- interfaceListener = new InterfaceStateChangeListener(db, this);
- subnetRouteInterfaceListener = new SubnetRouteInterfaceStateChangeListener(db, this);
- vpnInterfaceOpListener = new VpnInterfaceOpListener();
- arpNotificationHandler = new ArpNotificationHandler(this, broker);
- vpnSubnetRouteHandler = new VpnSubnetRouteHandler(broker, bgpManager, this);
- dpnInVpnChangeListener = new DpnInVpnChangeListener(broker);
- tunnelInterfaceStateListener = new TunnelInterfaceStateListener(broker, bgpManager, fibManager);
- notificationService.registerNotificationListener(vpnSubnetRouteHandler);
- notificationService.registerNotificationListener(arpNotificationHandler);
- notificationService.registerNotificationListener(dpnInVpnChangeListener);
- registerListener(db);
- }
-
- public void setMdsalManager(IMdsalApiManager mdsalManager) {
+ this.arpManager = arpManager;
+ this.idManager = idManager;
this.mdsalManager = mdsalManager;
- }
-
- public void setIfaceMgrRpcService(OdlInterfaceRpcService ifMgrRpcService) {
- this.ifaceMgrRpcService = ifMgrRpcService;
- interfaceListener.setIfaceMgrRpcService(ifMgrRpcService);
- }
-
- public void setFibManager(IFibManager fibManager) {
this.fibManager = fibManager;
- }
-
- public IFibManager getFibManager() {
- return this.fibManager;
- }
-
-
- public void setIdManager(IdManagerService idManager) {
- this.idManager = idManager;
- vpnSubnetRouteHandler.setIdManager(idManager);
- }
-
- public void setArpManager(OdlArputilService arpManager) {
- this.arpManager = arpManager;
- }
-
- void setNotificationPublishService(NotificationPublishService notificationPublishService) {
+ this.ifaceMgrRpcService = ifaceMgrRpcService;
this.notificationPublishService = notificationPublishService;
}
- public void setNeutronvpnManager(NeutronvpnService neuService) { this.neuService = neuService; }
-
- public void setFibRpcService(FibRpcService fibService) {
- this.fibService = fibService;
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
+ listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
+ getWildCardPath(), this, DataChangeScope.SUBTREE);
}
- public FibRpcService getFibRpcService() {
- return fibService;
- }
-
- public VpnSubnetRouteHandler getVpnSubnetRouteHandler() {
- return this.vpnSubnetRouteHandler;
+ private InstanceIdentifier<VpnInterface> getWildCardPath() {
+ return InstanceIdentifier.create(VpnInterfaces.class).child(VpnInterface.class);
}
@Override
public void close() throws Exception {
if (listenerRegistration != null) {
- try {
- listenerRegistration.close();
- opListenerRegistration.close();
- } catch (final Exception e) {
- LOG.error("Error when cleaning up DataChangeListener.", e);
- }
+ listenerRegistration.close();
listenerRegistration = null;
- opListenerRegistration = null;
}
- LOG.info("VPN Interface Manager Closed");
- }
-
- private void registerListener(final DataBroker db) {
- try {
- listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
- getWildCardPath(), VpnInterfaceManager.this, DataChangeScope.SUBTREE);
- opListenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- getWildCardPath(), vpnInterfaceOpListener, DataChangeScope.SUBTREE);
- tunnelInterfaceStateListenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- getTunnelInterfaceStateListenerPath(), tunnelInterfaceStateListener, DataChangeScope.SUBTREE);
- } catch (final Exception e) {
- LOG.error("VPN Service DataChange listener registration fail!", e);
- throw new IllegalStateException("VPN Service registration Listener failed.", e);
- }
- }
-
- private InstanceIdentifier<StateTunnelList> getTunnelInterfaceStateListenerPath() {
- return InstanceIdentifier.create(TunnelsState.class).child(StateTunnelList.class);
+ LOG.info("{} close", getClass().getSimpleName());
}
private InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> getInterfaceListenerPath() {
@Override
public void add(final InstanceIdentifier<VpnInterface> identifier, final VpnInterface vpnInterface) {
LOG.trace("VPN Interface add event - key: {}, value: {}" ,identifier, vpnInterface );
+ LOG.info("VPN Interface add event - intfName {}" ,vpnInterface.getName());
final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
final String interfaceName = key.getName();
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface interfaceState =
- InterfaceUtils.getInterfaceStateFromOperDS(broker, interfaceName);
+ InterfaceUtils.getInterfaceStateFromOperDS(dataBroker, interfaceName);
if(interfaceState != null){
try{
final BigInteger dpnId = InterfaceUtils.getDpIdFromInterface(interfaceState);
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
- WriteTransaction writeConfigTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeOperTxn = broker.newWriteOnlyTransaction();
- processVpnInterfaceUp(dpnId, vpnInterface, ifIndex, false, writeConfigTxn, writeOperTxn);
- CheckedFuture<Void, TransactionCommitFailedException> futures = writeOperTxn.submit();
- try {
- futures.get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Error adding oper data for interface {} to vpn {} on dpn {}", interfaceName,
- vpnInterface.getVpnInstanceName(), dpnId);
- throw new RuntimeException(e.getMessage());
- }
- futures = writeConfigTxn.submit();
- try {
- futures.get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Error adding config data for interface {} to vpn {} on dpn {}", interfaceName,
- vpnInterface.getVpnInstanceName(), dpnId);
- throw new RuntimeException(e.getMessage());
- }
- return null;
+ WriteTransaction writeConfigTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeOperTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeInvTxn = dataBroker.newWriteOnlyTransaction();
+ processVpnInterfaceUp(dpnId, vpnInterface, ifIndex, false, writeConfigTxn, writeOperTxn, writeInvTxn);
+ List<ListenableFuture<Void>> futures = new ArrayList<ListenableFuture<Void>>();
+ futures.add(writeOperTxn.submit());
+ futures.add(writeConfigTxn.submit());
+ futures.add(writeInvTxn.submit());
+ return futures;
}
});
}catch (Exception e){
protected void processVpnInterfaceUp(final BigInteger dpId, VpnInterface vpnInterface,
final int lPortTag, boolean isInterfaceUp,
WriteTransaction writeConfigTxn,
- WriteTransaction writeOperTxn) {
+ WriteTransaction writeOperTxn,
+ WriteTransaction writeInvTxn) {
final String interfaceName = vpnInterface.getName();
if (!isInterfaceUp) {
final String vpnName = vpnInterface.getVpnInstanceName();
LOG.info("Binding vpn service to interface {} ", interfaceName);
- long vpnId = VpnUtil.getVpnId(broker, vpnName);
+ long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
if (vpnId == VpnConstants.INVALID_ID) {
LOG.trace("VpnInstance to VPNId mapping is not yet available, bailing out now.");
return;
}
boolean waitForVpnInterfaceOpRemoval = false;
- VpnInterface opVpnInterface = VpnUtil.getOperationalVpnInterface(broker, vpnInterface.getName());
+ VpnInterface opVpnInterface = VpnUtil.getOperationalVpnInterface(dataBroker, vpnInterface.getName());
if (opVpnInterface != null ) {
String opVpnName = opVpnInterface.getVpnInstanceName();
String primaryInterfaceIp = null;
// If so, we have to process ADD, as this might be a DPN Restart with Remove and Add triggered
// back to back
// However, if the primary VRF Entry for this VPNInterface exists, please continue bailing out !
- List<Adjacency> adjs = VpnUtil.getAdjacenciesForVpnInterfaceFromConfig(broker, interfaceName);
+ List<Adjacency> adjs = VpnUtil.getAdjacenciesForVpnInterfaceFromConfig(dataBroker, interfaceName);
if (adjs == null) {
LOG.info("VPN Interface {} addition failed as adjacencies for this vpn interface could not be obtained", interfaceName);
return;
}
// Get the rd of the vpn instance
String rd = getRouteDistinguisher(opVpnName);
- VrfEntry vrf = VpnUtil.getVrfEntry(broker, rd, primaryInterfaceIp);
+ rd = (rd == null) ? opVpnName : rd;
+ VrfEntry vrf = VpnUtil.getVrfEntry(dataBroker, rd, primaryInterfaceIp);
if (vrf != null) {
LOG.info("VPN Interface {} already provisioned , bailing out from here.", interfaceName);
return;
}
if (!waitForVpnInterfaceOpRemoval) {
// Add the VPNInterface and quit
- updateDpnDbs(dpId, vpnName, interfaceName, true /* add */);
- bindService(dpId, vpnName, interfaceName, lPortTag, writeConfigTxn);
+ updateVpnToDpnMapping(dpId, vpnName, interfaceName, true /* add */);
+ bindService(dpId, vpnName, interfaceName, lPortTag, writeConfigTxn, writeInvTxn);
processVpnInterfaceAdjacencies(dpId, vpnName, interfaceName, writeConfigTxn, writeOperTxn);
return;
}
// FIB didn't get a chance yet to clean up this VPNInterface
// Let us give it a chance here !
- LOG.info("VPN Interface {} waiting for FIB to clean up! ", interfaceName);
+ LOG.info("Trying to add VPN Interface {}, but waiting for FIB to clean up! ", interfaceName);
try {
Runnable notifyTask = new VpnNotifyTask();
vpnIntfMap.put(interfaceName, notifyTask);
vpnIntfMap.remove(interfaceName);
}
- opVpnInterface = VpnUtil.getOperationalVpnInterface(broker, interfaceName);
+ opVpnInterface = VpnUtil.getOperationalVpnInterface(dataBroker, interfaceName);
if (opVpnInterface != null) {
LOG.error("VPN Interface {} removal by FIB did not complete on time, bailing addition ...", interfaceName);
return;
}
// VPNInterface got removed, proceed with Add
- updateDpnDbs(dpId, vpnName, interfaceName, true /* add */);
- bindService(dpId, vpnName, interfaceName, lPortTag, writeConfigTxn);
+ updateVpnToDpnMapping(dpId, vpnName, interfaceName, true /* add */);
+ bindService(dpId, vpnName, interfaceName, lPortTag, writeConfigTxn, writeInvTxn);
processVpnInterfaceAdjacencies(dpId, vpnName, interfaceName, writeConfigTxn, writeOperTxn);
} else {
// Interface is retained in the DPN, but its Link Up.
// public List<ListenableFuture<Void>> call() throws Exception {
// // If another renderer(for eg : CSS) needs to be supported, check can be performed here
// // to call the respective helpers.
-// WriteTransaction writeTxn = broker.newWriteOnlyTransaction();
+// WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
// updateDpnDbs(dpnId, vpnName, interfaceName, addToDpn, writeTxn);
// List<ListenableFuture<Void>> futures = new ArrayList<>();
// futures.add(writeTxn.submit());
// */
// @Override
// public void onSuccess(List<Void> voids) {
-// WriteTransaction writeTxn = broker.newWriteOnlyTransaction();
+// WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
// bindService(dpnId, vpnName, interfaceName, lPortTag, writeTxn);
// processVpnInterfaceAdjacencies(dpnId, vpnName, interfaceName, writeTxn);
// writeTxn.submit();
// }
+
+
private void advertiseAdjacenciesForVpnToBgp(BigInteger dpnId, final InstanceIdentifier<VpnInterface> identifier,
VpnInterface intf) {
//Read NextHops
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, path);
+ Optional<Adjacencies> adjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, path);
- String rd = VpnUtil.getVpnRd(broker, intf.getVpnInstanceName());
+ String rd = VpnUtil.getVpnRd(dataBroker, intf.getVpnInstanceName());
if (rd == null) {
LOG.error("advertiseAdjacenciesForVpnFromBgp: Unable to recover rd for interface {} in vpn {}",
intf.getName(), intf.getVpnInstanceName());
LOG.info("advertiseAdjacenciesForVpnToBgp: Advertising interface {} in vpn {} with rd {} ", intf.getName(),
intf.getVpnInstanceName(), rd);
- String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(broker, dpnId);
+ String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, dpnId);
if (nextHopIp == null){
LOG.trace("advertiseAdjacenciesForVpnToBgp: NextHop for interface {} is null, returning", intf.getName());
return;
private void withdrawAdjacenciesForVpnFromBgp(final InstanceIdentifier<VpnInterface> identifier, VpnInterface intf) {
//Read NextHops
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, path);
+ Optional<Adjacencies> adjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, path);
- String rd = VpnUtil.getVpnRd(broker, intf.getVpnInstanceName());
+ String rd = VpnUtil.getVpnRd(dataBroker, intf.getVpnInstanceName());
if (rd == null) {
LOG.error("withdrawAdjacenciesForVpnFromBgp: Unable to recover rd for interface {} in vpn {}",
intf.getName(), intf.getVpnInstanceName());
}
}
- private void updateDpnDbs(BigInteger dpId, String vpnName, String interfaceName, boolean add) {
- long vpnId = VpnUtil.getVpnId(broker, vpnName);
+ public void updateVpnToDpnMapping(BigInteger dpId, String vpnName, String interfaceName, boolean add) {
+ long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
if (dpId == null) {
dpId = InterfaceUtils.getDpnForInterface(ifaceMgrRpcService, interfaceName);
}
if(!dpId.equals(BigInteger.ZERO)) {
if(add)
- updateMappingDbs(vpnId, dpId, interfaceName, vpnName);
+ createOrUpdateVpnToDpnList(vpnId, dpId, interfaceName, vpnName);
else
- removeFromMappingDbs(vpnId, dpId, interfaceName, vpnName);
+ removeOrUpdateVpnToDpnList(vpnId, dpId, interfaceName, vpnName);
}
}
- private void bindService(BigInteger dpId, String vpnInstanceName, String vpnInterfaceName, int lPortTag,
- WriteTransaction writeConfigTxn) {
- int priority = VpnConstants.DEFAULT_FLOW_PRIORITY;
- long vpnId = VpnUtil.getVpnId(broker, vpnInstanceName);
-
- int instructionKey = 0;
- List<Instruction> instructions = new ArrayList<Instruction>();
-
- instructions.add(MDSALUtil.buildAndGetWriteMetadaInstruction(BigInteger.valueOf(vpnId), MetaDataUtil.METADATA_MASK_VRFID, ++instructionKey));
- instructions.add(MDSALUtil.buildAndGetGotoTableInstruction(NwConstants.L3_FIB_TABLE, ++instructionKey));
-
- BoundServices
- serviceInfo =
- InterfaceUtils.getBoundServices(String.format("%s.%s.%s", "vpn",vpnInstanceName, vpnInterfaceName),
- VpnConstants.L3VPN_SERVICE_IDENTIFIER, priority,
- VpnConstants.COOKIE_VM_INGRESS_TABLE, instructions);
- writeConfigTxn.put(LogicalDatastoreType.CONFIGURATION,
- InterfaceUtils.buildServiceId(vpnInterfaceName, VpnConstants.L3VPN_SERVICE_IDENTIFIER), serviceInfo, true);
- makeArpFlow(dpId, VpnConstants.L3VPN_SERVICE_IDENTIFIER, lPortTag, vpnInterfaceName,
- vpnId, ArpReplyOrRequest.REQUEST, NwConstants.ADD_FLOW, writeConfigTxn);
- makeArpFlow(dpId, VpnConstants.L3VPN_SERVICE_IDENTIFIER, lPortTag, vpnInterfaceName,
- vpnId, ArpReplyOrRequest.REPLY, NwConstants.ADD_FLOW, writeConfigTxn);
+ private void bindService(BigInteger dpId, final String vpnInstanceName, final String vpnInterfaceName,
+ int lPortTag, WriteTransaction writeConfigTxn, WriteTransaction writeInvTxn) {
+ final int priority = VpnConstants.DEFAULT_FLOW_PRIORITY;
+ final long vpnId = VpnUtil.getVpnId(dataBroker, vpnInstanceName);
+
+ DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
+ dataStoreCoordinator.enqueueJob(vpnInterfaceName,
+ new Callable<List<ListenableFuture<Void>>>() {
+ @Override
+ public List<ListenableFuture<Void>> call() throws Exception {
+ WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
+ int instructionKey = 0;
+ List<Instruction> instructions = new ArrayList<Instruction>();
+
+ instructions.add(MDSALUtil.buildAndGetWriteMetadaInstruction(
+ BigInteger.valueOf(vpnId), MetaDataUtil.METADATA_MASK_VRFID, ++instructionKey));
+ instructions.add(MDSALUtil.buildAndGetGotoTableInstruction(NwConstants.L3_FIB_TABLE, ++instructionKey));
+
+ BoundServices
+ serviceInfo =
+ InterfaceUtils.getBoundServices(String.format("%s.%s.%s", "vpn",vpnInstanceName, vpnInterfaceName),
+ NwConstants.L3VPN_SERVICE_INDEX, priority,
+ NwConstants.COOKIE_VM_INGRESS_TABLE, instructions);
+ writeTxn.put(LogicalDatastoreType.CONFIGURATION,
+ InterfaceUtils.buildServiceId(vpnInterfaceName, NwConstants.L3VPN_SERVICE_INDEX), serviceInfo, true);
+ List<ListenableFuture<Void>> futures = new ArrayList<ListenableFuture<Void>>();
+ futures.add(writeTxn.submit());
+ return futures;
+ }
+ });
+ makeArpFlow(dpId, NwConstants.L3VPN_SERVICE_INDEX, lPortTag, vpnInterfaceName,
+ vpnId, ArpReplyOrRequest.REQUEST, NwConstants.ADD_FLOW, writeInvTxn);
+ makeArpFlow(dpId, NwConstants.L3VPN_SERVICE_INDEX, lPortTag, vpnInterfaceName,
+ vpnId, ArpReplyOrRequest.REPLY, NwConstants.ADD_FLOW, writeInvTxn);
}
InstanceIdentifier<VpnInterface> identifier = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
// Read NextHops
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, path);
+ Optional<Adjacencies> adjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, path);
if (adjacencies.isPresent()) {
List<Adjacency> nextHops = adjacencies.get().getAdjacency();
// Get the rd of the vpn instance
String rd = getRouteDistinguisher(vpnName);
- String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(broker, dpnId);
+ String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, dpnId);
if (nextHopIp == null){
LOG.error("NextHop for interface {} is null", interfaceName);
return;
writeOperTxn.merge(
LogicalDatastoreType.OPERATIONAL,
VpnUtil.getPrefixToInterfaceIdentifier(
- VpnUtil.getVpnId(broker, vpnName), prefix),
+ VpnUtil.getVpnId(dataBroker, vpnName), prefix),
VpnUtil.getPrefixToInterface(dpnId, interfaceName, prefix), true);
} else {
//Extra route adjacency
VpnInterface opInterface = VpnUtil.getVpnInterface(interfaceName, vpnName, aug, dpnId, Boolean.FALSE);
InstanceIdentifier<VpnInterface> interfaceId = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
writeOperTxn.put(LogicalDatastoreType.OPERATIONAL, interfaceId, opInterface, true);
- long vpnId = VpnUtil.getVpnId(broker, vpnName);
+ long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
for (Adjacency nextHop : aug.getAdjacency()) {
long label = nextHop.getLabel();
- List<String> nextHopList = new ArrayList<>(nextHop.getNextHopIpList());
if (rd != null) {
- addToLabelMapper(label, dpnId, nextHop.getIpAddress(), nextHopList, vpnId,
+ addToLabelMapper(label, dpnId, nextHop.getIpAddress(), Arrays.asList(nextHopIp), vpnId,
interfaceName, null,false, rd, writeOperTxn);
addPrefixToBGP(rd, nextHop.getIpAddress(), nextHopIp, label, writeConfigTxn);
//TODO: ERT - check for VPNs importing my route
String vpnRd = vpn.getIpv4Family().getRouteDistinguisher();
if (vpnRd != null) {
LOG.debug("Exporting route with rd {} prefix {} nexthop {} label {} to VPN {}", vpnRd, nextHop.getIpAddress(), nextHopIp, label, vpn);
- fibManager.addOrUpdateFibEntry(broker, vpnRd, nextHop.getIpAddress(), Arrays.asList(nextHopIp), (int) label,
+ fibManager.addOrUpdateFibEntry(dataBroker, vpnRd, nextHop.getIpAddress(), Arrays.asList(nextHopIp), (int) label,
RouteOrigin.SELF_IMPORTED, writeConfigTxn);
}
}
} else {
// ### add FIB route directly
- fibManager.addOrUpdateFibEntry(broker, vpnName, nextHop.getIpAddress(), Arrays.asList(nextHopIp),
+ fibManager.addOrUpdateFibEntry(dataBroker, vpnName, nextHop.getIpAddress(), Arrays.asList(nextHopIp),
(int) label, RouteOrigin.STATIC, writeConfigTxn);
}
}
InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class)
.child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
- Optional<VpnInstance> optVpnInstance = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<VpnInstance> optVpnInstance = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
final VpnInstance vpnInstance;
if (optVpnInstance.isPresent()) {
vpnInstance = optVpnInstance.get();
}
};
- vpnsToImportRoute = FluentIterable.from(VpnUtil.getAllVpnInstance(broker)).
+ vpnsToImportRoute = FluentIterable.from(VpnUtil.getAllVpnInstance(dataBroker)).
filter(excludeVpn).
filter(matchRTs).toList();
return vpnsToImportRoute;
InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class)
.child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
- Optional<VpnInstance> optVpnInstance = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<VpnInstance> optVpnInstance = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
final VpnInstance vpnInstance;
if (optVpnInstance.isPresent()) {
vpnInstance = optVpnInstance.get();
}
};
- vpnsToExportRoute = FluentIterable.from(VpnUtil.getAllVpnInstance(broker)).
+ vpnsToExportRoute = FluentIterable.from(VpnUtil.getAllVpnInstance(dataBroker)).
filter(excludeVpn).
filter(matchRTs).toList();
return vpnsToExportRoute;
long vpnId, ArpReplyOrRequest replyOrRequest, int addOrRemoveFlow,
WriteTransaction writeConfigTxn){
List<MatchInfo> matches = new ArrayList<MatchInfo>();
- BigInteger metadata = MetaDataUtil.getMetaDataForLPortDispatcher(lPortTag, ++sIndex, BigInteger.valueOf(vpnId));
+ BigInteger metadata = MetaDataUtil.getMetaDataForLPortDispatcher(lPortTag, ++sIndex, MetaDataUtil.getVpnIdMetadata(vpnId));
BigInteger metadataMask = MetaDataUtil.getMetaDataMaskForLPortDispatcher(MetaDataUtil.METADATA_MASK_SERVICE_INDEX,
MetaDataUtil.METADATA_MASK_LPORT_TAG, MetaDataUtil.METADATA_MASK_VRFID);
private String getRouteDistinguisher(String vpnName) {
InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class)
.child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
- Optional<VpnInstance> vpnInstance = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<VpnInstance> vpnInstance = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
String rd = "";
if(vpnInstance.isPresent()) {
VpnInstance instance = vpnInstance.get();
return rd;
}
- private void updateMappingDbs(long vpnId, BigInteger dpnId, String intfName, String vpnName) {
+ /**
+ * JobCallback class is used as a future callback for
+ * main and rollback workers to handle success and failure.
+ */
+ private class DpnEnterExitVpnWorker implements FutureCallback<List<Void>> {
+ BigInteger dpnId;
+ String vpnName;
+ String rd;
+ boolean entered;
+
+ public DpnEnterExitVpnWorker(BigInteger dpnId, String vpnName, String rd, boolean entered) {
+ this.entered = entered;
+ this.dpnId = dpnId;
+ this.vpnName = vpnName;
+ this.rd = rd;
+ }
+
+ /**
+ * @param voids
+ * This implies that all the future instances have returned success. -- TODO: Confirm this
+ */
+ @Override
+ public void onSuccess(List<Void> voids) {
+ if (entered) {
+ publishAddNotification(dpnId, vpnName, rd);
+ } else {
+ publishRemoveNotification(dpnId, vpnName, rd);
+ }
+ }
+
+ /**
+ *
+ * @param throwable
+ * This method is used to handle failure callbacks.
+ * If more retry needed, the retrycount is decremented and mainworker is executed again.
+ * 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());
+ }
+ }
+
+ private void createOrUpdateVpnToDpnList(long vpnId, BigInteger dpnId, String intfName, String vpnName) {
String routeDistinguisher = getRouteDistinguisher(vpnName);
String rd = (routeDistinguisher == null) ? vpnName : routeDistinguisher;
+ Boolean newDpnOnVpn = Boolean.FALSE;
+
synchronized (vpnName.intern()) {
- WriteTransaction writeTxn = broker.newWriteOnlyTransaction();
+ WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
InstanceIdentifier<VpnToDpnList> id = VpnUtil.getVpnToDpnListIdentifier(rd, dpnId);
- Optional<VpnToDpnList> dpnInVpn = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<VpnToDpnList> dpnInVpn = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data
.entry.vpn.to.dpn.list.VpnInterfaces
vpnInterface = new VpnInterfacesBuilder().setInterfaceName(intfName).build();
if (dpnInVpn.isPresent()) {
- if (writeTxn != null) {
- writeTxn.put(LogicalDatastoreType.OPERATIONAL, id.child(
- org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance
- .op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces.class,
- new VpnInterfacesKey(intfName)), vpnInterface, true);
- } else {
- VpnUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, id.child(
- org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance
- .op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces.class,
- new VpnInterfacesKey(intfName)), vpnInterface);
+ VpnToDpnList vpnToDpnList = dpnInVpn.get();
+ List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data
+ .vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces> vpnInterfaces = vpnToDpnList.getVpnInterfaces();
+ if (vpnInterfaces == null) {
+ vpnInterfaces = new ArrayList<>();
}
- } else {
-
- /*
- * Increment the active dpn count in VpnInstanceOpData.
- * ActiveDpnCount will be decremented when all the VpnInt in that Dpn are removed.
- */
- InstanceIdentifier<VpnInstanceOpDataEntry> vpnInsOpDataId = VpnUtil.getVpnInstanceOpDataIdentifier(rd);
- Optional<VpnInstanceOpDataEntry> vpnInstOpData = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, vpnInsOpDataId);
-
- java.lang.Long activeDpnCnt = vpnInstOpData.get().getActiveDpnCount();
-
- VpnInstanceOpDataEntryBuilder builder =
- new VpnInstanceOpDataEntryBuilder(vpnInstOpData.get()).setVrfId(rd).setVpnId(vpnId).setVpnInstanceName(vpnName).setActiveDpnCount(++activeDpnCnt);
-
+ vpnInterfaces.add(vpnInterface);
+ VpnToDpnListBuilder vpnToDpnListBuilder = new VpnToDpnListBuilder().setDpnId(dpnId);
+ vpnToDpnListBuilder.setDpnState(VpnToDpnList.DpnState.Active).setVpnInterfaces(vpnInterfaces);
if (writeTxn != null) {
- writeTxn.merge(LogicalDatastoreType.OPERATIONAL,
- vpnInsOpDataId,
- builder.build(), true);
+ writeTxn.put(LogicalDatastoreType.OPERATIONAL, id, vpnToDpnListBuilder.build(), true);
} else {
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL,
- vpnInsOpDataId,
- builder.build());
+ VpnUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, id, vpnToDpnListBuilder.build());
}
-
- VpnToDpnListBuilder vpnToDpnList = new VpnToDpnListBuilder().setDpnId(dpnId).setDpnState(VpnToDpnList.DpnState.Active);
+ /* If earlier state was inactive, it is considered new DPN coming back to the
+ * same VPN
+ */
+ if (vpnToDpnList.getDpnState() == VpnToDpnList.DpnState.Inactive) {
+ newDpnOnVpn = Boolean.TRUE;
+ }
+ } else {
List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data
.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces> vpnInterfaces = new ArrayList<>();
vpnInterfaces.add(vpnInterface);
+ VpnToDpnListBuilder vpnToDpnListBuilder = new VpnToDpnListBuilder().setDpnId(dpnId);
+ vpnToDpnListBuilder.setDpnState(VpnToDpnList.DpnState.Active).setVpnInterfaces(vpnInterfaces);
+
if (writeTxn != null) {
- writeTxn.merge(LogicalDatastoreType.OPERATIONAL, id,
- vpnToDpnList.setVpnInterfaces(vpnInterfaces).build(), true);
+ writeTxn.put(LogicalDatastoreType.OPERATIONAL, id, vpnToDpnListBuilder.build(), true);
} else {
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, id,
- vpnToDpnList.setVpnInterfaces(vpnInterfaces).build());
+ VpnUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, id, vpnToDpnListBuilder.build());
}
- fibManager.populateFibOnNewDpn(dpnId, vpnId, (rd == null) ? vpnName : rd);
- publishAddNotification(dpnId, vpnName, rd);
- //TODO: IRT - import local routes to vpn. check for the VPNs exporting the routes
- //FIXME: do we need to handle here. since already routes are imported to this vpn
-
+ newDpnOnVpn = Boolean.TRUE;
}
CheckedFuture<Void, TransactionCommitFailedException> futures = writeTxn.submit();
try {
LOG.error("Error adding to dpnToVpnList for vpn {} interface {} dpn {}", vpnName, intfName, dpnId);
throw new RuntimeException(e.getMessage());
}
- }
- }
- void handleVpnsExportingRoutes(String vpnName, String vpnRd) {
- List<VpnInstance> vpnsToExportRoute = getVpnsExportingMyRoute(vpnName);
- for (VpnInstance vpn : vpnsToExportRoute) {
- String rd = vpn.getIpv4Family().getRouteDistinguisher();
- List<VrfEntry> vrfEntries = VpnUtil.getAllVrfEntries(broker, vpn.getIpv4Family().getRouteDistinguisher());
- WriteTransaction writeConfigTxn = broker.newWriteOnlyTransaction();
- if (vrfEntries != null) {
- for (VrfEntry vrfEntry : vrfEntries) {
- try {
- if (RouteOrigin.value(vrfEntry.getOrigin()) != RouteOrigin.STATIC) {
- continue;
- }
- String prefix = vrfEntry.getDestPrefix();
- long label = vrfEntry.getLabel();
- List<String> nextHops = vrfEntry.getNextHopAddressList();
- SubnetRoute route = vrfEntry.getAugmentation(SubnetRoute.class);
- for (String nh : nextHops) {
- if (route != null) {
- LOG.info("Importing subnet route fib entry rd {} prefix {} nexthop {} label {} to vpn {}", vpnRd, prefix, nh, label, vpn.getVpnInstanceName());
- importSubnetRouteForNewVpn(rd, prefix, nh, (int)label, route, writeConfigTxn);
- } else {
- LOG.info("Importing fib entry rd {} prefix {} nexthop {} label {} to vpn {}", vpnRd, prefix, nh, label, vpn.getVpnInstanceName());
- fibManager.addOrUpdateFibEntry(broker, vpnRd, prefix, Arrays.asList(nh), (int)label,
- RouteOrigin.SELF_IMPORTED, writeConfigTxn);
- }
- }
- } catch (Exception e) {
- LOG.error("Exception occurred while importing route with prefix {} label {} nexthop {} from vpn {} to vpn {}", vrfEntry.getDestPrefix(), vrfEntry.getLabel(), vrfEntry.getNextHopAddressList(), vpn.getVpnInstanceName(), vpnName);
- }
- }
- writeConfigTxn.submit();
- } else {
- LOG.info("No vrf entries to import from vpn {} with rd {}", vpn.getVpnInstanceName(), vpn.getIpv4Family().getRouteDistinguisher());
- }
+ }
+ /*
+ * 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);
}
}
- private void removeFromMappingDbs(long vpnId, BigInteger dpnId, String intfName, String vpnName) {
- //TODO: Delay 'DPN' removal so that other services can cleanup the entries for this dpn
+ private void removeOrUpdateVpnToDpnList(long vpnId, BigInteger dpnId, String intfName, String vpnName) {
+ Boolean lastDpnOnVpn = Boolean.FALSE;
+ String rd = VpnUtil.getVpnRd(dataBroker, vpnName);
synchronized (vpnName.intern()) {
- String rd = VpnUtil.getVpnRd(broker, vpnName);
InstanceIdentifier<VpnToDpnList> id = VpnUtil.getVpnToDpnListIdentifier(rd, dpnId);
- Optional<VpnToDpnList> dpnInVpn = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id);
- WriteTransaction writeTxn = broker.newWriteOnlyTransaction();
+ Optional<VpnToDpnList> dpnInVpn = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
if (dpnInVpn.isPresent()) {
List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data
.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces> vpnInterfaces = dpnInVpn.get().getVpnInterfaces();
- org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op
- .data.entry.vpn.to.dpn.list.VpnInterfaces
+ org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces
currVpnInterface = new VpnInterfacesBuilder().setInterfaceName(intfName).build();
if (vpnInterfaces.remove(currVpnInterface)) {
if (vpnInterfaces.isEmpty()) {
List<IpAddresses> ipAddresses = dpnInVpn.get().getIpAddresses();
if (ipAddresses == null || ipAddresses.isEmpty()) {
-
- /*
- * Mark the DPN state as Inactive as the Vpnintf list is empty.
- * This DPN will be removed in DpnToVpnChangeListner only if its
- * inactive and ActiveDpnCount is zero.
- */
- VpnToDpnListBuilder vpnToDpnList =
+ VpnToDpnListBuilder dpnInVpnBuilder =
new VpnToDpnListBuilder(dpnInVpn.get())
- .setDpnId(dpnId)
.setDpnState(VpnToDpnList.DpnState.Inactive)
- .setVpnInterfaces(vpnInterfaces);
-
+ .setVpnInterfaces(null);
if (writeTxn != null) {
- writeTxn.put(LogicalDatastoreType.OPERATIONAL, id , vpnToDpnList.build(), true);
+ writeTxn.put(LogicalDatastoreType.OPERATIONAL, id, dpnInVpnBuilder.build(), true);
} else {
- VpnUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, id, vpnToDpnList.build());
+ VpnUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, id, dpnInVpnBuilder.build());
}
-
- InstanceIdentifier<VpnInstanceOpDataEntry> vpnInstOpDataId = VpnUtil.getVpnInstanceOpDataIdentifier(rd);
- Optional<VpnInstanceOpDataEntry> vpnInstOpData = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, vpnInstOpDataId);
-
- java.lang.Long activeDpnCnt = vpnInstOpData.get().getActiveDpnCount();
-
- VpnInstanceOpDataEntryBuilder builder =
- new VpnInstanceOpDataEntryBuilder(vpnInstOpData.get()).setVrfId(rd).setVpnId(vpnId).setVpnInstanceName(vpnName).setActiveDpnCount(--activeDpnCnt);
-
- if (writeTxn != null) {
- writeTxn.merge(LogicalDatastoreType.OPERATIONAL, vpnInstOpDataId , builder.build(), true);
- } else {
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, vpnInstOpDataId, builder.build());
- }
-
- LOG.debug("Sending cleanup event for dpn {} in VPN {}", dpnId, vpnName);
- fibManager.cleanUpDpnForVpn(dpnId, vpnId, rd);
- publishRemoveNotification(dpnId, vpnName, rd);
+ lastDpnOnVpn = Boolean.TRUE;
} else {
- LOG.debug("vpn interfaces are empty but ip addresses are present for the vpn {} in dpn {}", vpnName, dpnId);
+ LOG.warn("vpn interfaces are empty but ip addresses are present for the vpn {} in dpn {}", vpnName, dpnId);
}
} else {
if (writeTxn != null) {
.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces.class,
new VpnInterfacesKey(intfName)));
} else {
- VpnUtil.delete(broker, LogicalDatastoreType.OPERATIONAL, id.child(
+ VpnUtil.delete(dataBroker, LogicalDatastoreType.OPERATIONAL, id.child(
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data
.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces.class,
new VpnInterfacesKey(intfName)), VpnUtil.DEFAULT_CALLBACK);
throw new RuntimeException(e.getMessage());
}
}
+ 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);
+ }
+ }
+
+ void handleVpnsExportingRoutes(String vpnName, String vpnRd) {
+ List<VpnInstance> vpnsToExportRoute = getVpnsExportingMyRoute(vpnName);
+ for (VpnInstance vpn : vpnsToExportRoute) {
+ String rd = vpn.getIpv4Family().getRouteDistinguisher();
+ List<VrfEntry> vrfEntries = VpnUtil.getAllVrfEntries(dataBroker, vpn.getIpv4Family().getRouteDistinguisher());
+ WriteTransaction writeConfigTxn = dataBroker.newWriteOnlyTransaction();
+ if (vrfEntries != null) {
+ for (VrfEntry vrfEntry : vrfEntries) {
+ try {
+ if (RouteOrigin.value(vrfEntry.getOrigin()) != RouteOrigin.STATIC) {
+ continue;
+ }
+ String prefix = vrfEntry.getDestPrefix();
+ long label = vrfEntry.getLabel();
+ List<String> nextHops = vrfEntry.getNextHopAddressList();
+ SubnetRoute route = vrfEntry.getAugmentation(SubnetRoute.class);
+ for (String nh : nextHops) {
+ if (route != null) {
+ LOG.info("Importing subnet route fib entry rd {} prefix {} nexthop {} label {} to vpn {}", vpnRd, prefix, nh, label, vpn.getVpnInstanceName());
+ importSubnetRouteForNewVpn(rd, prefix, nh, (int)label, route, writeConfigTxn);
+ } else {
+ LOG.info("Importing fib entry rd {} prefix {} nexthop {} label {} to vpn {}", vpnRd, prefix, nh, label, vpn.getVpnInstanceName());
+ fibManager.addOrUpdateFibEntry(dataBroker, vpnRd, prefix, Arrays.asList(nh), (int)label,
+ RouteOrigin.SELF_IMPORTED, writeConfigTxn);
+ }
+ }
+ } catch (Exception e) {
+ LOG.error("Exception occurred while importing route with prefix {} label {} nexthop {} from vpn {} to vpn {}", vrfEntry.getDestPrefix(), vrfEntry.getLabel(), vrfEntry.getNextHopAddressList(), vpn.getVpnInstanceName(), vpnName);
+ }
+ }
+ writeConfigTxn.submit();
+ } else {
+ LOG.info("No vrf entries to import from vpn {} with rd {}", vpn.getVpnInstanceName(), vpn.getIpv4Family().getRouteDistinguisher());
+ }
+ }
}
private void addPrefixToBGP(String rd, String prefix, String nextHopIp, long label, WriteTransaction writeConfigTxn) {
try {
LOG.info("ADD: Adding Fib entry rd {} prefix {} nextHop {} label {}", rd, prefix, nextHopIp, label);
- fibManager.addOrUpdateFibEntry(broker, rd, prefix, Arrays.asList(nextHopIp), (int)label, RouteOrigin.STATIC, writeConfigTxn);
+ fibManager.addOrUpdateFibEntry(dataBroker, rd, prefix, Arrays.asList(nextHopIp), (int)label, RouteOrigin.STATIC, writeConfigTxn);
bgpManager.advertisePrefix(rd, prefix, Arrays.asList(nextHopIp), (int)label);
LOG.info("ADD: Added Fib entry rd {} prefix {} nextHop {} label {}", rd, prefix, nextHopIp, label);
} catch(Exception e) {
}
}
-
- private InstanceIdentifier<VpnInterface> getWildCardPath() {
- return InstanceIdentifier.create(VpnInterfaces.class).child(VpnInterface.class);
- }
-
@Override
public void remove( InstanceIdentifier<VpnInterface> identifier, VpnInterface vpnInterface) {
LOG.trace("Remove event - key: {}, value: {}" ,identifier, vpnInterface );
+ LOG.info("VPN Interface remove event - intfName {}" ,vpnInterface.getName());
final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
final String interfaceName = key.getName();
InstanceIdentifier<VpnInterface> interfaceId = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
- final Optional<VpnInterface> optVpnInterface = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, interfaceId);
+ final Optional<VpnInterface> optVpnInterface = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, interfaceId);
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface interfaceState =
- InterfaceUtils.getInterfaceStateFromOperDS(broker, interfaceName);
+ InterfaceUtils.getInterfaceStateFromOperDS(dataBroker, interfaceName);
if (optVpnInterface.isPresent()){
BigInteger dpnId = BigInteger.ZERO;
Boolean dpnIdRetrieved = Boolean.FALSE;
new Callable<List<ListenableFuture<Void>>>() {
@Override
public List<ListenableFuture<Void>> call() throws Exception {
- WriteTransaction writeConfigTxn = broker.newWriteOnlyTransaction();
- WriteTransaction writeOperTxn = broker.newWriteOnlyTransaction();
-
- processVpnInterfaceDown(dpId, interfaceName, ifIndex, false, true, writeConfigTxn, writeOperTxn);
- CheckedFuture<Void, TransactionCommitFailedException> futures = writeOperTxn.submit();
- try {
- futures.get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Error removing interface {} from vpn {} on dpn {}", interfaceName,
- vpnOpInterface.getVpnInstanceName(), dpId);
- throw new RuntimeException(e.getMessage());
- }
- futures = writeConfigTxn.submit();
- try {
- futures.get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Error removing interface {} from vpn {} on dpn {}", interfaceName,
- vpnOpInterface.getVpnInstanceName(), dpId);
- throw new RuntimeException(e.getMessage());
- }
- return null;
+ WriteTransaction writeConfigTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeOperTxn = dataBroker.newWriteOnlyTransaction();
+ WriteTransaction writeInvTxn = dataBroker.newWriteOnlyTransaction();
+ processVpnInterfaceDown(dpId, interfaceName, ifIndex, false, true, writeConfigTxn, writeOperTxn, writeInvTxn);
+ List<ListenableFuture<Void>> futures = new ArrayList<ListenableFuture<Void>>();
+ futures.add(writeOperTxn.submit());
+ futures.add(writeConfigTxn.submit());
+ futures.add(writeInvTxn.submit());
+ return futures;
}
});
}
}
- protected void processVpnInterfaceDown(BigInteger dpId, String interfaceName, int lPortTag, boolean isInterfaceStateDown,
- boolean isConfigRemoval, WriteTransaction writeConfigTxn, WriteTransaction writeOperTxn) {
+ protected void processVpnInterfaceDown(BigInteger dpId,
+ String interfaceName,
+ int lPortTag,
+ boolean isInterfaceStateDown,
+ boolean isConfigRemoval,
+ WriteTransaction writeConfigTxn,
+ WriteTransaction writeOperTxn,
+ WriteTransaction writeInvTxn) {
InstanceIdentifier<VpnInterface> identifier = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
if (!isInterfaceStateDown) {
- VpnInterface vpnInterface = VpnUtil.getOperationalVpnInterface(broker, interfaceName);
+ VpnInterface vpnInterface = VpnUtil.getOperationalVpnInterface(dataBroker, interfaceName);
if(vpnInterface == null){
LOG.info("Unable to process delete/down for interface {} as it is not available in operational data store", interfaceName);
return;
}else{
final String vpnName = vpnInterface.getVpnInstanceName();
if(!vpnInterface.isScheduledForRemove()){
- VpnUtil.scheduleVpnInterfaceForRemoval(broker, interfaceName, dpId, vpnName, Boolean.TRUE, writeOperTxn);
+ VpnUtil.scheduleVpnInterfaceForRemoval(dataBroker, interfaceName, dpId, vpnName, Boolean.TRUE, writeOperTxn);
removeAdjacenciesFromVpn(dpId, interfaceName, vpnInterface.getVpnInstanceName(), writeConfigTxn);
LOG.info("Unbinding vpn service from interface {} ", interfaceName);
- unbindService(dpId, vpnName, interfaceName, lPortTag, isInterfaceStateDown, isConfigRemoval, writeConfigTxn);
+ unbindService(dpId, vpnName, interfaceName, lPortTag, isInterfaceStateDown, isConfigRemoval, writeConfigTxn, writeInvTxn);
}else{
LOG.info("Unbinding vpn service for interface {} has already been scheduled by a different event ", interfaceName);
return;
} else {
// Interface is retained in the DPN, but its Link Down.
// Only withdraw the prefixes for this interface from BGP
- VpnInterface vpnInterface = VpnUtil.getOperationalVpnInterface(broker, interfaceName);
+ VpnInterface vpnInterface = VpnUtil.getOperationalVpnInterface(dataBroker, interfaceName);
if(vpnInterface == null){
LOG.info("Unable to withdraw adjacencies for vpn interface {} from BGP as it is not available in operational data store", interfaceName);
return;
//Read NextHops
InstanceIdentifier<VpnInterface> identifier = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, path);
+ Optional<Adjacencies> adjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, path);
- String rd = VpnUtil.getVpnRd(broker, vpnName);
+ String rd = VpnUtil.getVpnRd(dataBroker, vpnName);
LOG.trace("removeAdjacenciesFromVpn: For interface {} RD recovered for vpn {} as rd {}", interfaceName,
vpnName, rd);
if (adjacencies.isPresent()) {
List<String> nhList = new ArrayList<String>();
if (nextHop.getMacAddress() == null || nextHop.getMacAddress().isEmpty()) {
// This is either an extra-route (or) a learned IP via subnet-route
- String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(broker, dpnId);
+ String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, dpnId);
if (nextHopIp == null || nextHopIp.isEmpty()) {
LOG.error("Unable to obtain nextHopIp for extra-route/learned-route in rd {} prefix {}",
rd, nextHop.getIpAddress());
//this is an internal vpn - the rd is assigned to the vpn instance name;
//remove from FIB directly
for(String nh : nhList) {
- fibManager.removeOrUpdateFibEntry(broker, vpnName, nextHop.getIpAddress(), nh, writeConfigTxn);
+ fibManager.removeOrUpdateFibEntry(dataBroker, vpnName, nextHop.getIpAddress(), nh, writeConfigTxn);
}
} else {
List<VpnInstance> vpnsToImportRoute = getVpnsImportingMyRoute(vpnName);
- for (String nh : nextHop.getNextHopIpList()) {
+ for (String nh : nhList) {
//IRT: remove routes from other vpns importing it
removePrefixFromBGP(rd, nextHop.getIpAddress(), nh, writeConfigTxn);
for (VpnInstance vpn : vpnsToImportRoute) {
String vpnRd = vpn.getIpv4Family().getRouteDistinguisher();
if (vpnRd != null) {
LOG.info("Removing Exported route with rd {} prefix {} from VPN {}", vpnRd, nextHop.getIpAddress(), vpn.getVpnInstanceName());
- fibManager.removeOrUpdateFibEntry(broker, vpnRd, nextHop.getIpAddress(), nh, writeConfigTxn);
+ fibManager.removeOrUpdateFibEntry(dataBroker, vpnRd, nextHop.getIpAddress(), nh, writeConfigTxn);
}
}
}
}
String ip = nextHop.getIpAddress().split("/")[0];
- VpnPortipToPort vpnPortipToPort = VpnUtil.getNeutronPortFromVpnPortFixedIp(broker,
+ VpnPortipToPort vpnPortipToPort = VpnUtil.getNeutronPortFromVpnPortFixedIp(dataBroker,
vpnName, ip);
if (vpnPortipToPort != null && !vpnPortipToPort.isConfig()) {
LOG.trace("VpnInterfaceManager removing adjacency for Interface {} ip {} from VpnPortData Entry",
vpnPortipToPort.getPortName(),ip);
- VpnUtil.removeVpnPortFixedIpToPort(broker, vpnName, ip);
+ VpnUtil.removeVpnPortFixedIpToPort(dataBroker, vpnName, ip);
}
}
}
}
- private void unbindService(BigInteger dpId, String vpnInstanceName, String vpnInterfaceName,
+ private void unbindService(BigInteger dpId, String vpnInstanceName, final String vpnInterfaceName,
int lPortTag, boolean isInterfaceStateDown, boolean isConfigRemoval,
- WriteTransaction writeConfigTxn) {
+ WriteTransaction writeConfigTxn, WriteTransaction writeInvTxn) {
+ short l3vpn_service_index = ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME, NwConstants.L3VPN_SERVICE_INDEX);
if (!isInterfaceStateDown && isConfigRemoval) {
- writeConfigTxn.delete(LogicalDatastoreType.CONFIGURATION,
- InterfaceUtils.buildServiceId(vpnInterfaceName,
- VpnConstants.L3VPN_SERVICE_IDENTIFIER));
+ DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
+ dataStoreCoordinator.enqueueJob(vpnInterfaceName,
+ new Callable<List<ListenableFuture<Void>>>() {
+ @Override
+ public List<ListenableFuture<Void>> call() throws Exception {
+ WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
+ writeTxn.delete(LogicalDatastoreType.CONFIGURATION,
+ InterfaceUtils.buildServiceId(vpnInterfaceName,
+ NwConstants.L3VPN_SERVICE_INDEX));
+
+ List<ListenableFuture<Void>> futures = new ArrayList<ListenableFuture<Void>>();
+ futures.add(writeTxn.submit());
+ return futures;
+ }
+ });
}
- long vpnId = VpnUtil.getVpnId(broker, vpnInstanceName);
- makeArpFlow(dpId, VpnConstants.L3VPN_SERVICE_IDENTIFIER, lPortTag, vpnInterfaceName,
- vpnId, ArpReplyOrRequest.REQUEST, NwConstants.DEL_FLOW, writeConfigTxn);
- makeArpFlow(dpId, VpnConstants.L3VPN_SERVICE_IDENTIFIER, lPortTag, vpnInterfaceName,
- vpnId, ArpReplyOrRequest.REPLY, NwConstants.DEL_FLOW, writeConfigTxn);
+ long vpnId = VpnUtil.getVpnId(dataBroker, vpnInstanceName);
+ makeArpFlow(dpId, l3vpn_service_index, lPortTag, vpnInterfaceName,
+ vpnId, ArpReplyOrRequest.REQUEST, NwConstants.DEL_FLOW, writeInvTxn);
+ makeArpFlow(dpId, l3vpn_service_index, lPortTag, vpnInterfaceName,
+ vpnId, ArpReplyOrRequest.REPLY, NwConstants.DEL_FLOW, writeInvTxn);
}
private void removePrefixFromBGP(String rd, String prefix, String nextHop, WriteTransaction writeConfigTxn) {
try {
LOG.info("VPN WITHDRAW: Removing Fib Entry rd {} prefix {}", rd, prefix);
- fibManager.removeOrUpdateFibEntry(broker, rd, prefix, nextHop, writeConfigTxn);
+ fibManager.removeOrUpdateFibEntry(dataBroker, rd, prefix, nextHop, writeConfigTxn);
bgpManager.withdrawPrefix(rd, prefix); // TODO: Might be needed to include nextHop here
LOG.info("VPN WITHDRAW: Removed Fib Entry rd {} prefix {}", rd, prefix);
} catch(Exception e) {
@Override
protected void update(InstanceIdentifier<VpnInterface> identifier, VpnInterface original, VpnInterface update) {
LOG.trace("Updating VPN Interface : key {}, original value={}, update value={}", identifier, original, update);
+ LOG.info("VPN Interface update event - intfName {}" ,update.getName());
String oldVpnName = original.getVpnInstanceName();
String newVpnName = update.getVpnInstanceName();
BigInteger dpnId = update.getDpnId();
lriBuilder.setVpnInterfaceName(vpnInterfaceName);
}
lriBuilder.setParentVpnRd(rd);
- VpnInstanceOpDataEntry vpnInstanceOpDataEntry = VpnUtil.getVpnInstanceOpData(broker, rd);
+ VpnInstanceOpDataEntry vpnInstanceOpDataEntry = VpnUtil.getVpnInstanceOpData(dataBroker, rd);
if (vpnInstanceOpDataEntry != null) {
List<String> vpnInstanceNames = Arrays.asList(vpnInstanceOpDataEntry.getVpnInstanceName());
lriBuilder.setVpnInstanceList(vpnInstanceNames);
if (writeOperTxn != null) {
writeOperTxn.merge(LogicalDatastoreType.OPERATIONAL, lriIid, lri, true);
} else {
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, lriIid, lri);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.OPERATIONAL, lriIid, lri);
}
} else {
LOG.trace("Can't add entry to label map for lable {},dpnId is null", label);
LOG.debug("Created vrfEntry for {} nexthop {} label {} and elantag {}", prefix, nextHop, label, elantag);
//TODO: What should be parentVpnId? Get it from RD?
- long vpnId = VpnUtil.getVpnId(broker, vpnName);
+ long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
addToLabelMapper((long)label, dpnId, prefix, Arrays.asList(nextHop), vpnId, null, elantag, true, rd, null);
List<VrfEntry> vrfEntryList = Arrays.asList(vrfEntry);
if (writeTxn != null) {
writeTxn.merge(LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew, true);
} else {
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew);
}
List<VpnInstance> vpnsToImportRoute = getVpnsImportingMyRoute(vpnName);
if (writeTxn != null) {
writeTxn.merge(LogicalDatastoreType.CONFIGURATION, importingVrfTableId, importingVrfTable, true);
} else {
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, importingVrfTableId, importingVrfTable);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, importingVrfTableId, importingVrfTable);
}
}
}
if (writeConfigTxn != null) {
writeConfigTxn.merge(LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew, true);
} else {
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfTableId, vrfTableNew);
}
}
public synchronized void deleteSubnetRouteFibEntryFromDS(String rd, String prefix, String vpnName){
- fibManager.removeOrUpdateFibEntry(broker, rd, prefix, null /* nextHopToRemove */, null);
+ fibManager.removeOrUpdateFibEntry(dataBroker, rd, prefix, null /* nextHopToRemove */, 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(broker, importingRd, prefix, null /* nextHopToRemove */, null);
+ fibManager.removeOrUpdateFibEntry(dataBroker, importingRd, prefix, null /* nextHopToRemove */, null);
}
}
protected void addNewAdjToVpnInterface(InstanceIdentifier<VpnInterface> identifier, Adjacency adj, BigInteger dpnId) {
- Optional<VpnInterface> optVpnInterface = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, identifier);
+ Optional<VpnInterface> optVpnInterface = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier);
if (optVpnInterface.isPresent()) {
VpnInterface currVpnIntf = optVpnInterface.get();
String prefix = VpnUtil.getIpPrefix(adj.getIpAddress());
String rd = getRouteDistinguisher(currVpnIntf.getVpnInstanceName());
InstanceIdentifier<Adjacencies> adjPath = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> optAdjacencies = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, adjPath);
+ 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));
Adjacencies aug = VpnUtil.getVpnInterfaceAugmentation(adjacencies);
VpnInterface newVpnIntf = VpnUtil.getVpnInterface(currVpnIntf.getName(), currVpnIntf.getVpnInstanceName(), aug, dpnId, currVpnIntf.isScheduledForRemove());
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, identifier, newVpnIntf);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier, newVpnIntf);
for (String nh : adj.getNextHopIpList()) {
addExtraRoute(adj.getIpAddress(), nh, rd, currVpnIntf.getVpnInstanceName(), (int) label,
currVpnIntf.getName());
}
protected void delAdjFromVpnInterface(InstanceIdentifier<VpnInterface> identifier, Adjacency adj, BigInteger dpnId) {
- Optional<VpnInterface> optVpnInterface = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, identifier);
+ Optional<VpnInterface> optVpnInterface = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier);
if (optVpnInterface.isPresent()) {
VpnInterface currVpnIntf = optVpnInterface.get();
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> optAdjacencies = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, path);
+ Optional<Adjacencies> optAdjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, path);
if (optAdjacencies.isPresent()) {
List<Adjacency> adjacencies = optAdjacencies.get().getAdjacency();
currVpnIntf.getVpnInstanceName(),
aug, dpnId, currVpnIntf.isScheduledForRemove());
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, identifier, newVpnIntf);
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier, newVpnIntf);
for (String nh : adj.getNextHopIpList()) {
delExtraRoute(adj.getIpAddress(), nh, rd, currVpnIntf.getVpnInstanceName(),
//add extra route to vpn mapping; advertise with nexthop as tunnel ip
VpnUtil.syncUpdate(
- broker,
+ dataBroker,
LogicalDatastoreType.OPERATIONAL,
VpnUtil.getVpnToExtrarouteIdentifier( (rd != null) ? rd : routerID, destination),
VpnUtil.getVpnToExtraroute(destination, Arrays.asList(nextHop)));
BigInteger dpnId = null;
if (intfName != null && !intfName.isEmpty()) {
dpnId = InterfaceUtils.getDpnForInterface(ifaceMgrRpcService, intfName);
- String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(broker, dpnId);
+ String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, dpnId);
if (nextHopIp == null || nextHopIp.isEmpty()) {
LOG.error("NextHop for interface {} is null / empty. Failed advertising extra route for prefix {}",
intfName, destination);
nextHop = nextHopIp;
}
List<String> nextHopIpList = Arrays.asList(nextHop);
- addToLabelMapper((long)label, dpnId, destination, nextHopIpList, VpnUtil.getVpnId(broker, routerID),
- intfName, null, false, rd, null);
+ if (rd != null) {
+ /* Label mapper is required only for BGP VPN and not for Internal VPN */
+ addToLabelMapper((long) label, dpnId, destination, nextHopIpList, VpnUtil.getVpnId(dataBroker, routerID),
+ intfName, null, false, rd, null);
+ }
// TODO (eperefr): This is a limitation to be stated in docs. When configuring static route to go to
// another VPN, there can only be one nexthop or, at least, the nexthop to the interVpnLink should be in
// first place.
- InterVpnLink interVpnLink = VpnUtil.getInterVpnLinkByEndpointIp(broker, nextHop);
+ InterVpnLink interVpnLink = VpnUtil.getInterVpnLinkByEndpointIp(dataBroker, nextHop);
if ( interVpnLink != null ) {
// If the nexthop is the endpoint of Vpn2, then prefix must be advertised to Vpn1 in DC-GW, with nexthops
// pointing to the DPNs where Vpn1 is instantiated. LFIB in these DPNS must have a flow entry, with lower
: interVpnLink.getFirstEndpoint().getVpnUuid().getValue();
String dstVpnUuid = (nexthopIsVpn2) ? interVpnLink.getFirstEndpoint().getVpnUuid().getValue()
: interVpnLink.getSecondEndpoint().getVpnUuid().getValue();
- String dstVpnRd = VpnUtil.getVpnRd(broker, dstVpnUuid);
+ String dstVpnRd = VpnUtil.getVpnRd(dataBroker, dstVpnUuid);
long newLabel = VpnUtil.getUniqueId(idManager, VpnConstants.VPN_IDPOOL_NAME,
VpnUtil.getNextHopLabelKey(dstVpnRd, destination));
- VpnUtil.leakRoute(broker, bgpManager, interVpnLink, srcVpnUuid, dstVpnUuid, destination, newLabel);
+ VpnUtil.leakRoute(dataBroker, bgpManager, interVpnLink, srcVpnUuid, dstVpnUuid, destination, newLabel);
} else {
if (rd != null) {
addPrefixToBGP(rd, destination, nextHop, label, null);
} else {
// ### add FIB route directly
- fibManager.addOrUpdateFibEntry(broker, routerID, destination, Arrays.asList(nextHop), label, RouteOrigin.STATIC, null);
+ fibManager.addOrUpdateFibEntry(dataBroker, routerID, destination, Arrays.asList(nextHop), label, RouteOrigin.STATIC, null);
}
}
}
protected void delExtraRoute(String destination, String nextHop, String rd, String routerID, String intfName) {
if (intfName != null && !intfName.isEmpty()) {
BigInteger dpnId = InterfaceUtils.getDpnForInterface(ifaceMgrRpcService, intfName);
- String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(broker, dpnId);
+ String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, dpnId);
if (nextHopIp == null || nextHopIp.isEmpty()) {
LOG.warn("NextHop for interface {} is null / empty. Failed advertising extra route for prefix {}",
intfName, destination);
removePrefixFromBGP(rd, destination, nextHop, null);
} else {
// ### add FIB route directly
- fibManager.removeOrUpdateFibEntry(broker, routerID, destination, nextHop, null);
- }
- }
-
- class VpnInterfaceOpListener extends org.opendaylight.genius.mdsalutil.AbstractDataChangeListener<VpnInterface> {
-
- public VpnInterfaceOpListener() {
- super(VpnInterface.class);
- }
-
- @Override
- protected void remove(final InstanceIdentifier<VpnInterface> identifier, final VpnInterface del) {
- final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
- final String interfaceName = key.getName();
- final String vpnName = del.getVpnInstanceName();
- DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
- dataStoreCoordinator.enqueueJob("VPNINTERFACE-" + interfaceName,
- new Callable<List<ListenableFuture<Void>>>() {
- @Override
- public List<ListenableFuture<Void>> call() throws Exception {
- WriteTransaction writeOperTxn = broker.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;
- }
- });
- }
-
- private void postProcessVpnInterfaceRemoval(InstanceIdentifier<VpnInterface> identifier, VpnInterface del,
- WriteTransaction writeOperTxn) {
- final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
- String interfaceName = key.getName();
- String vpnName = del.getVpnInstanceName();
-
- LOG.trace("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>
- id = VpnUtil.getVpnInstanceToVpnIdIdentifier(vpnName);
- Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
- .VpnInstance> vpnInstance
- = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
-
- if (vpnInstance.isPresent()) {
- String rd = null;
- rd = vpnInstance.get().getVrfId();
- //String rd = getRouteDistinguisher(del.getVpnInstanceName());
-
- VpnInstanceOpDataEntry vpnInstOp = VpnUtil.getVpnInstanceOpData(broker, rd);
- LOG.trace("VpnInterfaceOpListener removed: interface name {} rd {} vpnName {} in Vpn Op Instance {}",
- interfaceName, rd, vpnName, vpnInstOp);
-
- if (vpnInstOp != null) {
- // Vpn Interface removed => No more adjacencies from it.
- // Hence clean up interface from vpn-dpn-interface list.
- Adjacency adjacency = del.getAugmentation(Adjacencies.class).getAdjacency().get(0);
- List<Prefixes> prefixToInterface = new ArrayList<>();
- Optional<Prefixes> prefix = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(),
- VpnUtil.getIpPrefix(adjacency.getIpAddress())));
- if (prefix.isPresent()) {
- prefixToInterface.add(prefix.get());
- }
- if (prefixToInterface.isEmpty()) {
- for (String nh : adjacency.getNextHopIpList()) {
- prefix = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(),
- VpnUtil.getIpPrefix(nh)));
- if (prefix.isPresent())
- prefixToInterface.add(prefix.get());
- }
- }
- for (Prefixes pref : prefixToInterface) {
- if (writeOperTxn != null) {
- writeOperTxn.delete(LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(), pref.getIpAddress()));
- } else {
- VpnUtil.delete(broker, LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(), pref.getIpAddress()),
- VpnUtil.DEFAULT_CALLBACK);
- }
- updateDpnDbs(pref.getDpnId(), del.getVpnInstanceName(), interfaceName, false /* delete */);
- }
- }
- } else {
- LOG.error("rd not retrievable as vpninstancetovpnid for vpn {} is absent, trying rd as ", vpnName, vpnName);
- }
- notifyTaskIfRequired(interfaceName);
- }
-
- private void notifyTaskIfRequired(String intfName) {
- Runnable notifyTask = vpnIntfMap.remove(intfName);
- if (notifyTask == null) {
- LOG.trace("VpnInterfaceOpListener update: No Notify Task queued for vpnInterface {}", intfName);
- return;
- }
- executorService.execute(notifyTask);
- }
-
- @Override
- protected void update(final InstanceIdentifier<VpnInterface> identifier, final VpnInterface original,
- final VpnInterface update) {
- final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
- final String interfaceName = key.getName();
-
- if (original.getVpnInstanceName().equals(update.getVpnInstanceName())) {
- return;
- }
-
- final String vpnName = update.getVpnInstanceName();
- DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
- dataStoreCoordinator.enqueueJob("VPNINTERFACE-" + interfaceName,
- new Callable<List<ListenableFuture<Void>>>() {
- @Override
- public List<ListenableFuture<Void>> call() throws Exception {
- postProcessVpnInterfaceUpdate(identifier, original, update);
- return null;
- }
- });
- }
-
- private void postProcessVpnInterfaceUpdate(InstanceIdentifier<VpnInterface> identifier, VpnInterface original,
- VpnInterface update) {
- final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
- String interfaceName = key.getName();
-
- //increment the vpn interface count in Vpn Instance Op Data
- VpnInstanceOpDataEntry vpnInstOp = null;
- InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to
- .vpn.id.VpnInstance>
- origId = VpnUtil.getVpnInstanceToVpnIdIdentifier(original.getVpnInstanceName());
- Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
- .VpnInstance> origVpnInstance
- = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, origId);
-
- if (origVpnInstance.isPresent()) {
- String rd = null;
- rd = origVpnInstance.get().getVrfId();
-
- vpnInstOp = VpnUtil.getVpnInstanceOpData(broker, rd);
- LOG.trace("VpnInterfaceOpListener updated: interface name {} original rd {} original vpnName {}",
- interfaceName, rd, original.getVpnInstanceName());
-
- if (vpnInstOp != null) {
- Adjacency adjacency = original.getAugmentation(Adjacencies.class).getAdjacency().get(0);
- List<Prefixes> prefixToInterfaceList = new ArrayList<>();
- Optional<Prefixes> prefixToInterface = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(),
- VpnUtil.getIpPrefix(adjacency.getIpAddress())));
- if (prefixToInterface.isPresent()) {
- prefixToInterfaceList.add(prefixToInterface.get());
- } else {
- for (String adj : adjacency.getNextHopIpList()) {
- prefixToInterface = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnInstOp.getVpnId(),
- VpnUtil.getIpPrefix(adj)));
- if (prefixToInterface.isPresent()) {
- prefixToInterfaceList.add(prefixToInterface.get());
- }
- }
- }
- for (Prefixes prefix : prefixToInterfaceList) {
- updateDpnDbs(prefix.getDpnId(), original.getVpnInstanceName(), interfaceName, false /* delete */);
- }
- }
- }
- notifyTaskIfRequired(interfaceName);
- }
-
- @Override
- protected void add(InstanceIdentifier<VpnInterface> identifier, VpnInterface add) {
+ fibManager.removeOrUpdateFibEntry(dataBroker, routerID, destination, nextHop, null);
}
}
}
InstanceIdentifier<DpnVpninterfacesList> routerDpnListIdentifier = getRouterDpnId(routerName, dpId);
- Optional<DpnVpninterfacesList> optionalRouterDpnList = VpnUtil.read(broker, LogicalDatastoreType
+ Optional<DpnVpninterfacesList> optionalRouterDpnList = VpnUtil.read(dataBroker, LogicalDatastoreType
.OPERATIONAL, routerDpnListIdentifier);
RouterInterfaces routerInterface = new RouterInterfacesBuilder().setKey(new RouterInterfacesKey(vpnInterfaceName)).setInterface(vpnInterfaceName).build();
if (optionalRouterDpnList.isPresent()) {
return;
}
InstanceIdentifier<DpnVpninterfacesList> routerDpnListIdentifier = getRouterDpnId(routerName, dpId);
- Optional<DpnVpninterfacesList> optionalRouterDpnList = VpnUtil.read(broker, LogicalDatastoreType
+ Optional<DpnVpninterfacesList> optionalRouterDpnList = VpnUtil.read(dataBroker, LogicalDatastoreType
.OPERATIONAL, routerDpnListIdentifier);
if (optionalRouterDpnList.isPresent()) {
List<RouterInterfaces> routerInterfaces = optionalRouterDpnList.get().getRouterInterfaces();
if (writeOperTxn != null) {
writeOperTxn.delete(LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier);
} else {
- MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier);
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier);
}
} else {
if (writeOperTxn != null) {
RouterInterfaces.class,
new RouterInterfacesKey(vpnInterfaceName)));
} else {
- MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier.child(
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier.child(
RouterInterfaces.class,
new RouterInterfacesKey(vpnInterfaceName)));
}
return;
}
InstanceIdentifier<DpnVpninterfacesList> routerDpnListIdentifier = getRouterDpnId(routerName, dpId);
- Optional<DpnVpninterfacesList> optionalRouterDpnList = VpnUtil.read(broker, LogicalDatastoreType
+ Optional<DpnVpninterfacesList> optionalRouterDpnList = VpnUtil.read(dataBroker, LogicalDatastoreType
.OPERATIONAL, routerDpnListIdentifier);
if (optionalRouterDpnList.isPresent()) {
List<RouterInterfaces> routerInterfaces = optionalRouterDpnList.get().getRouterInterfaces();
LOG.trace("Adding {} adjacency to VPN Interface {} ",prefix,vpnInterface);
InstanceIdentifier<VpnInterface> vpnIfId = VpnUtil.getVpnInterfaceIdentifier(vpnInterface);
InstanceIdentifier<Adjacencies> path = vpnIfId.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, path);
+ Optional<Adjacencies> adjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, path);
String nextHopIpAddr = null;
String nextHopMacAddress = null;
String ip = prefix.getIpv4Address().getValue();
}
}
if (nextHopMacAddress != null && ip != null) {
- synchronized (vpnInterface.intern()) {
- String rd = VpnUtil.getVpnRd(broker, vpnName);
- long label =
- VpnUtil.getUniqueId(idManager, VpnConstants.VPN_IDPOOL_NAME,
- VpnUtil.getNextHopLabelKey((rd != null) ? rd : vpnName, ip));
- String nextHopIp = nextHopIpAddr.split("/")[0];
- Adjacency newAdj = new AdjacencyBuilder().setIpAddress(ip).setKey
- (new AdjacencyKey(ip)).setNextHopIpList(Arrays.asList(nextHopIp)).build();
- adjacencyList.add(newAdj);
- Adjacencies aug = VpnUtil.getVpnInterfaceAugmentation(adjacencyList);
- VpnInterface newVpnIntf = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(vpnInterface)).
- setName(vpnInterface).setVpnInstanceName(vpnName).addAugmentation(Adjacencies.class, aug).build();
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vpnIfId, newVpnIntf);
- }
+ String rd = VpnUtil.getVpnRd(dataBroker, vpnName);
+ long label =
+ VpnUtil.getUniqueId(idManager, VpnConstants.VPN_IDPOOL_NAME,
+ VpnUtil.getNextHopLabelKey((rd != null) ? rd : vpnName, ip));
+ String nextHopIp = nextHopIpAddr.split("/")[0];
+ Adjacency newAdj = new AdjacencyBuilder().setIpAddress(ip).setKey
+ (new AdjacencyKey(ip)).setNextHopIpList(Arrays.asList(nextHopIp)).build();
+ adjacencyList.add(newAdj);
+ Adjacencies aug = VpnUtil.getVpnInterfaceAugmentation(adjacencyList);
+ VpnInterface newVpnIntf = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(vpnInterface)).
+ setName(vpnInterface).setVpnInstanceName(vpnName).addAugmentation(Adjacencies.class, aug).build();
+ VpnUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfId, newVpnIntf);
LOG.debug(" Successfully stored subnetroute Adjacency into VpnInterface {}", vpnInterface);
}
}
LOG.trace("Removing {} adjacency from Old VPN Interface {} ",ip,vpnInterface);
InstanceIdentifier<VpnInterface> vpnIfId = VpnUtil.getVpnInterfaceIdentifier(vpnInterface);
InstanceIdentifier<Adjacencies> path = vpnIfId.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, path);
+ Optional<Adjacencies> adjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, path);
if (adjacencies.isPresent()) {
- synchronized (vpnInterface.intern()) {
- InstanceIdentifier<Adjacency> adjacencyIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
- child(VpnInterface.class, new VpnInterfaceKey(vpnInterface)).augmentation(Adjacencies.class)
- .child(Adjacency.class, new AdjacencyKey(ip)).build();
- MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier);
- }
+ InstanceIdentifier<Adjacency> adjacencyIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
+ child(VpnInterface.class, new VpnInterfaceKey(vpnInterface)).augmentation(Adjacencies.class)
+ .child(Adjacency.class, new AdjacencyKey(ip)).build();
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier);
LOG.trace("Successfully Deleted Adjacency into VpnInterface {}", vpnInterface);
}
}
+
+ void notifyTaskIfRequired(String intfName) {
+ Runnable notifyTask = vpnIntfMap.remove(intfName);
+ if (notifyTask == null) {
+ return;
+ }
+ executorService.execute(notifyTask);
+ }
}