summary |
shortlog |
log |
commit | commitdiff |
review |
tree
raw |
patch |
inline | side by side (from parent 1:
15c36c6)
Change-Id: I4198abf8edee93999a073e0364cdffa840662dba
Signed-off-by: Sasidharan Sambasivam <sasidharan.s.sambasivam@ericsson.com>
public void setVpnmanager(IVpnManager vpnmanager) {
this.vpnmanager = vpnmanager;
public void setVpnmanager(IVpnManager vpnmanager) {
this.vpnmanager = vpnmanager;
+ vpnmanager.setFibService(this);
<artifactId>model-bgp</artifactId>
<version>${model.bgp.version}</version>
</dependency>
<artifactId>model-bgp</artifactId>
<version>${model.bgp.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.vpnservice</groupId>
+ <artifactId>fibmanager-api</artifactId>
+ <version>${vpnservices.version}</version>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-api</artifactId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-api</artifactId>
import java.util.Collection;
import java.util.Collection;
+import org.opendaylight.fibmanager.api.IFibManager;
+
public interface IVpnManager {
Collection<Long> getDpnsForVpn(long vpnId);
public interface IVpnManager {
Collection<Long> getDpnsForVpn(long vpnId);
+ void setFibService(IFibManager fibManager);
public static final short LPORT_INGRESS_TABLE = 0;
public static final short FIB_TABLE = 21;
public static final short DEFAULT_FLOW_PRIORITY = 10;
public static final short LPORT_INGRESS_TABLE = 0;
public static final short FIB_TABLE = 21;
public static final short DEFAULT_FLOW_PRIORITY = 10;
+ public static final long INVALID_ID = -1;
import org.opendaylight.bgpmanager.api.IBgpManager;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.bgpmanager.api.IBgpManager;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.fibmanager.api.IFibManager;
import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
import org.opendaylight.vpnservice.mdsalutil.InstructionInfo;
import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
import org.opendaylight.vpnservice.mdsalutil.InstructionInfo;
private ListenerRegistration<DataChangeListener> listenerRegistration;
private final DataBroker broker;
private final IBgpManager bgpManager;
private ListenerRegistration<DataChangeListener> listenerRegistration;
private final DataBroker broker;
private final IBgpManager bgpManager;
+ private IFibManager fibManager;
private IMdsalApiManager mdsalManager;
private IInterfaceManager interfaceManager;
private IdManagerService idManager;
private IMdsalApiManager mdsalManager;
private IInterfaceManager interfaceManager;
private IdManagerService idManager;
this.interfaceManager = interfaceManager;
}
this.interfaceManager = interfaceManager;
}
+ public void setFibManager(IFibManager fibManager) {
+ this.fibManager = fibManager;
+ }
+
public void setIdManager(IdManagerService idManager) {
this.idManager = idManager;
}
public void setIdManager(IdManagerService idManager) {
this.idManager = idManager;
}
Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
if (port.isPresent()) {
Interface interf = port.get();
Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
if (port.isPresent()) {
Interface interf = port.get();
- bindServiceOnInterface(interf, getVpnId(vpnInterface.getVpnInstanceName()));
+ bindServiceOnInterface(interf, vpnInterface.getVpnInstanceName());
updateNextHops(identifier, vpnInterface);
}
}
updateNextHops(identifier, vpnInterface);
}
}
InstanceIdentifier<VpnInstance1> id = InstanceIdentifier.builder(VpnInstances.class)
.child(VpnInstance.class, new VpnInstanceKey(vpnName)).augmentation(VpnInstance1.class).build();
Optional<VpnInstance1> vpnInstance = read(LogicalDatastoreType.OPERATIONAL, id);
InstanceIdentifier<VpnInstance1> id = InstanceIdentifier.builder(VpnInstances.class)
.child(VpnInstance.class, new VpnInstanceKey(vpnName)).augmentation(VpnInstance1.class).build();
Optional<VpnInstance1> vpnInstance = read(LogicalDatastoreType.OPERATIONAL, id);
- //TODO: Default vpnid should be a constant.
- long vpnId = -1;
+
+ long vpnId = VpnConstants.INVALID_ID;
if(vpnInstance.isPresent()) {
vpnId = vpnInstance.get().getVpnId();
}
if(vpnInstance.isPresent()) {
vpnId = vpnInstance.get().getVpnId();
}
- private synchronized void updateMappingDbs(long vpnId, long dpnId, String intfName) {
+ private synchronized void updateMappingDbs(long vpnId, long dpnId, String intfName, String rd) {
Collection<Long> dpnIds = vpnToDpnsDb.get(vpnId);
if(dpnIds == null) {
dpnIds = new HashSet<>();
}
if(dpnIds.add(dpnId)) {
vpnToDpnsDb.put(vpnId, dpnIds);
Collection<Long> dpnIds = vpnToDpnsDb.get(vpnId);
if(dpnIds == null) {
dpnIds = new HashSet<>();
}
if(dpnIds.add(dpnId)) {
vpnToDpnsDb.put(vpnId, dpnIds);
- //TODO: Send an Event that new DPN added...
+ fibManager.populateFibOnNewDpn(dpnId, vpnId, rd);
}
Collection<String> intfNames = dpnToInterfaceDb.get(dpnId);
}
Collection<String> intfNames = dpnToInterfaceDb.get(dpnId);
dpnToInterfaceDb.put(dpnId, intfNames);
}
dpnToInterfaceDb.put(dpnId, intfNames);
}
- private synchronized void remoteFromMappingDbs(long vpnId, long dpnId, String inftName) {
+ private synchronized void remoteFromMappingDbs(long vpnId, long dpnId, String inftName, String rd) {
Collection<String> intfNames = dpnToInterfaceDb.get(dpnId);
if(intfNames == null) {
return;
}
intfNames.remove(inftName);
dpnToInterfaceDb.put(dpnId, intfNames);
Collection<String> intfNames = dpnToInterfaceDb.get(dpnId);
if(intfNames == null) {
return;
}
intfNames.remove(inftName);
dpnToInterfaceDb.put(dpnId, intfNames);
+ //TODO: Delay 'DPN' removal so that other services can cleanup the entries for this dpn
if(intfNames.isEmpty()) {
Collection<Long> dpnIds = vpnToDpnsDb.get(vpnId);
if(dpnIds == null) {
if(intfNames.isEmpty()) {
Collection<Long> dpnIds = vpnToDpnsDb.get(vpnId);
if(dpnIds == null) {
}
dpnIds.remove(dpnId);
vpnToDpnsDb.put(vpnId, dpnIds);
}
dpnIds.remove(dpnId);
vpnToDpnsDb.put(vpnId, dpnIds);
+ fibManager.cleanUpDpnForVpn(dpnId, vpnId, rd);
- private void bindServiceOnInterface(Interface intf, long vpnId) {
- LOG.trace("Bind service on interface {} for VPN: {}", intf, vpnId);
+ private void bindServiceOnInterface(Interface intf, String vpnName) {
+ LOG.trace("Bind service on interface {} for VPN: {}", intf, vpnName);
+ long vpnId = getVpnId(vpnName);
long dpId = interfaceManager.getDpnForInterface(intf.getName());
if(dpId == 0L) {
LOG.warn("DPN for interface {} not found. Bind service on this interface aborted.", intf.getName());
return;
} else {
long dpId = interfaceManager.getDpnForInterface(intf.getName());
if(dpId == 0L) {
LOG.warn("DPN for interface {} not found. Bind service on this interface aborted.", intf.getName());
return;
} else {
- updateMappingDbs(vpnId, dpId, intf.getName());
+ String rd = getRouteDistinguisher(vpnName);
+ updateMappingDbs(vpnId, dpId, intf.getName(), rd);
}
long portNo = interfaceManager.getPortForInterface(intf.getName());
}
long portNo = interfaceManager.getPortForInterface(intf.getName());
if (port.isPresent()) {
Interface interf = port.get();
removeNextHops(identifier, vpnInterface);
if (port.isPresent()) {
Interface interf = port.get();
removeNextHops(identifier, vpnInterface);
- unbindServiceOnInterface(interf, getVpnId(vpnInterface.getVpnInstanceName()));
+ unbindServiceOnInterface(interf, vpnInterface.getVpnInstanceName());
+ //InstanceIdentifier<VpnInterface> interfaceId = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
+ delete(LogicalDatastoreType.OPERATIONAL, identifier);
} else {
LOG.warn("No nexthops were available to handle remove event {}", interfaceName);
}
} else {
LOG.warn("No nexthops were available to handle remove event {}", interfaceName);
}
- InstanceIdentifier<VpnInterface> interfaceId = VpnUtil.getVpnInterfaceIdentifier(intfName);
- delete(LogicalDatastoreType.OPERATIONAL, interfaceId);
+// InstanceIdentifier<VpnInterface> interfaceId = VpnUtil.getVpnInterfaceIdentifier(intfName);
+// delete(LogicalDatastoreType.OPERATIONAL, interfaceId);
}
private <T extends DataObject> void delete(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
}
private <T extends DataObject> void delete(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
Futures.addCallback(tx.submit(), DEFAULT_CALLBACK);
}
Futures.addCallback(tx.submit(), DEFAULT_CALLBACK);
}
- private void unbindServiceOnInterface(Interface intf, long vpnId) {
- LOG.trace("Unbind service on interface {} for VPN: {}", intf, vpnId);
+ private void unbindServiceOnInterface(Interface intf, String vpnName) {
+ LOG.trace("Unbind service on interface {} for VPN: {}", intf, vpnName);
+ long vpnId = getVpnId(vpnName);
long dpId = interfaceManager.getDpnForInterface(intf.getName());
if(dpId == 0L) {
LOG.warn("DPN for interface {} not found. Unbind service on this interface aborted.", intf.getName());
return;
} else {
long dpId = interfaceManager.getDpnForInterface(intf.getName());
if(dpId == 0L) {
LOG.warn("DPN for interface {} not found. Unbind service on this interface aborted.", intf.getName());
return;
} else {
- remoteFromMappingDbs(vpnId, dpId, intf.getName());
+ String rd = getRouteDistinguisher(vpnName);
+ remoteFromMappingDbs(vpnId, dpId, intf.getName(), rd);
}
long portNo = interfaceManager.getPortForInterface(intf.getName());
}
long portNo = interfaceManager.getPortForInterface(intf.getName());
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
+import org.opendaylight.fibmanager.api.IFibManager;
import org.opendaylight.vpnmanager.api.IVpnManager;
import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.vpnmanager.api.IVpnManager;
import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
private VpnInterfaceManager vpnInterfaceManager;
private VpnManager vpnManager;
private IBgpManager bgpManager;
private VpnInterfaceManager vpnInterfaceManager;
private VpnManager vpnManager;
private IBgpManager bgpManager;
+ private IFibManager fibManager;
private IMdsalApiManager mdsalManager;
private IInterfaceManager interfaceManager;
private IdManagerService idManager;
private IMdsalApiManager mdsalManager;
private IInterfaceManager interfaceManager;
private IdManagerService idManager;
this.mdsalManager = mdsalManager;
}
this.mdsalManager = mdsalManager;
}
+ public void setFibManager(IFibManager fibManager) {
+ this.fibManager = fibManager;
+ }
+
public void setInterfaceManager(IInterfaceManager interfaceManager) {
this.interfaceManager = interfaceManager;
}
public void setInterfaceManager(IInterfaceManager interfaceManager) {
this.interfaceManager = interfaceManager;
}
public Collection<Long> getDpnsForVpn(long vpnId) {
return vpnInterfaceManager.getDpnsForVpn(vpnId);
}
public Collection<Long> getDpnsForVpn(long vpnId) {
return vpnInterfaceManager.getDpnsForVpn(vpnId);
}
+
+ @Override
+ public void setFibService(IFibManager fibManager) {
+ LOG.debug("Fib service reference is initialized in VPN Manager");
+ this.fibManager = fibManager;
+ vpnInterfaceManager.setFibManager(fibManager);
+ }