package org.opendaylight.vpnservice;
import java.math.BigInteger;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
import java.util.List;
import java.util.ArrayList;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.FutureCallback;
private IMdsalApiManager mdsalManager;
private IInterfaceManager interfaceManager;
private IdManagerService idManager;
+ private Map<Long, Collection<Long>> vpnToDpnsDb;
+ private Map<Long, Collection<String>> dpnToInterfaceDb;
private static final FutureCallback<Void> DEFAULT_CALLBACK =
new FutureCallback<Void>() {
super(VpnInterface.class);
broker = db;
this.bgpManager = bgpManager;
+ vpnToDpnsDb = new ConcurrentHashMap<>();
+ dpnToInterfaceDb = new ConcurrentHashMap<>();
registerListener(db);
}
return rd;
}
+ private synchronized void updateMappingDbs(long vpnId, long dpnId, String intfName) {
+ 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...
+ }
+
+ Collection<String> intfNames = dpnToInterfaceDb.get(dpnId);
+ if(intfNames == null) {
+ intfNames = new ArrayList<>();
+ }
+ intfNames.add(intfName);
+ dpnToInterfaceDb.put(dpnId, intfNames);
+ }
+
+ private synchronized void remoteFromMappingDbs(long vpnId, long dpnId, String inftName) {
+ Collection<String> intfNames = dpnToInterfaceDb.get(dpnId);
+ if(intfNames == null) {
+ return;
+ }
+ intfNames.remove(inftName);
+ dpnToInterfaceDb.put(dpnId, intfNames);
+ if(intfNames.isEmpty()) {
+ Collection<Long> dpnIds = vpnToDpnsDb.get(vpnId);
+ if(dpnIds == null) {
+ return;
+ }
+ dpnIds.remove(dpnId);
+ vpnToDpnsDb.put(vpnId, dpnIds);
+ }
+ }
+
private void bindServiceOnInterface(Interface intf, long vpnId) {
LOG.info("Bind service on interface {} for VPN: {}", intf, vpnId);
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());
}
long portNo = interfaceManager.getPortForInterface(intf.getName());
Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
if (port.isPresent()) {
Interface interf = port.get();
- unbindServiceOnInterface(interf, getVpnId(vpnInterface.getVpnInstanceName()));
removeNextHops(identifier, vpnInterface);
+ unbindServiceOnInterface(interf, getVpnId(vpnInterface.getVpnInstanceName()));
} else {
LOG.info("No nexthops were available to handle remove event {}", interfaceName);
}
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());
}
long portNo = interfaceManager.getPortForInterface(intf.getName());
tx.put(datastoreType, path, data, true);
Futures.addCallback(tx.submit(), callback);
}
+
+ synchronized Collection<Long> getDpnsForVpn(long vpnId) {
+ Collection<Long> dpnIds = vpnToDpnsDb.get(vpnId);
+ if(dpnIds != null) {
+ return ImmutableList.copyOf(dpnIds);
+ } else {
+ return Collections.emptyList();
+ }
+ }
}
package org.opendaylight.vpnservice;
import java.math.BigInteger;
+import java.util.Collection;
import java.util.Collections;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
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.vpnmanager.api.IVpnManager;
import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInput;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class VpnserviceProvider implements BindingAwareProvider,
+public class VpnserviceProvider implements BindingAwareProvider, IVpnManager,
AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(VpnserviceProvider.class);
vpnManager.close();
vpnInterfaceManager.close();
}
+
+ @Override
+ public Collection<Long> getDpnsForVpn(long vpnId) {
+ return vpnInterfaceManager.getDpnsForVpn(vpnId);
+ }
}