import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collection;
import java.util.EventListener;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
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.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
+import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronConstants;
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.interfaces.VpnInterfaceKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesBuilder;
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.neutronvpn.config.rev160806.NeutronvpnConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateNetworksInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateNetworksOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateNetworksOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterDisassociatedFromVpn;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterDisassociatedFromVpnBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterInterfacesMap;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.SubnetAddedToVpnBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.SubnetDeletedFromVpnBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.SubnetUpdatedInVpnBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.VpnMaps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.createl3vpn.input.L3vpn;
import org.slf4j.LoggerFactory;
import com.google.common.base.Optional;
+import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, EventListener {
private static final Logger LOG = LoggerFactory.getLogger(NeutronvpnManager.class);
private final DataBroker dataBroker;
- private final LockManagerService lockManager;
private final NeutronvpnNatManager nvpnNatManager;
private final NotificationPublishService notificationPublishService;
private final VpnRpcService vpnRpcService;
private final NeutronFloatingToFixedIpMappingChangeListener floatingIpMapListener;
+ private final NeutronvpnConfig neutronvpnConfig;
private final IMdsalApiManager mdsalUtil;
private final IElanService elanService;
Boolean isExternalVpn;
/**
* @param dataBroker DataBroker reference
* @param mdsalManager MDSAL Util API access
+ * @param notiPublishService notificationPublishService
+ * @param vpnNatMgr VPN NAT manager service
+ * @param vpnRpcSrv VPN RPC service
+ * @param elanService ELAN service
+ * @param neutronFloatingToFixedIpMappingChangeListener FIP to FixedIP listener
+ * @param neutronvpnConfig Neutronvpn configuration service
*/
public NeutronvpnManager(
final DataBroker dataBroker, final IMdsalApiManager mdsalManager,
final NotificationPublishService notiPublishService, final NeutronvpnNatManager vpnNatMgr,
- final LockManagerService lockManager, final VpnRpcService vpnRpcSrv,
- final IElanService elanService,
- final NeutronFloatingToFixedIpMappingChangeListener neutronFloatingToFixedIpMappingChangeListener) {
+ final VpnRpcService vpnRpcSrv, final IElanService elanService,
+ final NeutronFloatingToFixedIpMappingChangeListener neutronFloatingToFixedIpMappingChangeListener,
+ final NeutronvpnConfig neutronvpnConfig) {
this.dataBroker = dataBroker;
mdsalUtil = mdsalManager;
nvpnNatManager = vpnNatMgr;
vpnRpcService = vpnRpcSrv;
this.elanService = elanService;
floatingIpMapListener = neutronFloatingToFixedIpMappingChangeListener;
- this.lockManager = lockManager;
+ LOG.info("neutronvpnConfig: {}", neutronvpnConfig);
+ this.neutronvpnConfig = neutronvpnConfig;
}
@Override
LOG.info("{} close", getClass().getSimpleName());
}
+ public NeutronvpnConfig getNeutronvpnConfig() {
+ return neutronvpnConfig;
+ }
+
protected void updateSubnetNodeWithFixedIps(Uuid subnetId, Uuid routerId,
Uuid routerInterfaceName, String fixedIp,
String routerIntfMacAddress) {
Subnetmap subnetmap = null;
SubnetmapBuilder builder = null;
- boolean isLockAcquired = false;
InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
try {
- Optional<Subnetmap> sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
- if (sn.isPresent()) {
- builder = new SubnetmapBuilder(sn.get());
- if (routerId != null) {
- builder.setRouterId(routerId);
- } else {
- builder.setRouterId(null);
- }
- if (routerInterfaceName != null) {
- builder.setRouterInterfaceName(routerInterfaceName);
- } else {
- builder.setRouterInterfaceName(null);
- }
- if (routerIntfMacAddress != null) {
- builder.setRouterIntfMacAddress(routerIntfMacAddress);
+ synchronized (subnetId.getValue().intern()) {
+ Optional<Subnetmap> sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ if (sn.isPresent()) {
+ builder = new SubnetmapBuilder(sn.get());
+ LOG.debug("WithRouterFixedIPs: Updating existing subnetmap node for subnet ID {}", subnetId.getValue());
} else {
- builder.setRouterIntfMacAddress(null);
+ builder = new SubnetmapBuilder().setKey(new SubnetmapKey(subnetId)).setId(subnetId);
+ LOG.debug("WithRouterFixedIPs: creating new subnetmap node for subnet ID {}", subnetId.getValue());
}
+
+ builder.setRouterId(routerId);
+ builder.setRouterInterfaceName(routerInterfaceName);
+ builder.setRouterIntfMacAddress(routerIntfMacAddress);
+
if (fixedIp != null) {
List<String> fixedIps = builder.getRouterInterfaceFixedIps();
if (fixedIps == null) {
- fixedIps = new ArrayList<String>();
+ fixedIps = new ArrayList<>();
}
fixedIps.add(fixedIp);
builder.setRouterInterfaceFixedIps(fixedIps);
builder.setRouterInterfaceFixedIps(null);
}
subnetmap = builder.build();
- isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
- LOG.debug("Creating/Updating subnetMap node for FixedIps: {} ", subnetId.getValue());
+ LOG.debug("WithRouterFixedIPs Creating/Updating subnetMap node for Router FixedIps: {} ", subnetId.getValue());
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
}
} catch (Exception e) {
- LOG.error("Updation of subnetMap for FixedIps failed for node: {}", subnetId.getValue());
- } finally {
- if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
- }
+ LOG.error("WithRouterFixedIPs: Updation of subnetMap for Router FixedIps failed for node: {}", subnetId.getValue());
}
}
Uuid vpnId) {
Subnetmap subnetmap = null;
SubnetmapBuilder builder = null;
- boolean isLockAcquired = false;
InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class)
.child(Subnetmap.class, new SubnetmapKey(subnetId))
.build();
try {
- Optional<Subnetmap> sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
- LOG.debug("updating Subnet :read: ");
- if (sn.isPresent()) {
- builder = new SubnetmapBuilder(sn.get());
- LOG.debug("updating Subnet :existing: ");
- } else {
- builder = new SubnetmapBuilder().setKey(new SubnetmapKey(subnetId)).setId(subnetId);
- LOG.debug("updating Subnet :new: ");
- }
+ synchronized (subnetId.getValue().intern()) {
+ Optional<Subnetmap> sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ if (sn.isPresent()) {
+ builder = new SubnetmapBuilder(sn.get());
+ LOG.debug("updating existing subnetmap node for subnet ID {}", subnetId.getValue());
+ } else {
+ builder = new SubnetmapBuilder().setKey(new SubnetmapKey(subnetId)).setId(subnetId);
+ LOG.debug("creating new subnetmap node for subnet ID {}", subnetId.getValue());
+ }
- if (subnetIp != null) {
- builder.setSubnetIp(subnetIp);
- }
- if (routerId != null) {
- builder.setRouterId(routerId);
- }
- if (networkId != null) {
- builder.setNetworkId(networkId);
- }
- if (vpnId != null) {
- builder.setVpnId(vpnId);
- }
- if (tenantId != null) {
- builder.setTenantId(tenantId);
- }
+ if (subnetIp != null) {
+ builder.setSubnetIp(subnetIp);
+ }
+ if (routerId != null) {
+ builder.setRouterId(routerId);
+ }
+ if (networkId != null) {
+ builder.setNetworkId(networkId);
+ }
+ if (vpnId != null) {
+ builder.setVpnId(vpnId);
+ }
+ if (tenantId != null) {
+ builder.setTenantId(tenantId);
+ }
- subnetmap = builder.build();
- isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
- LOG.debug("Creating/Updating subnetMap node: {} ", subnetId.getValue());
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
+ subnetmap = builder.build();
+ LOG.debug("Creating/Updating subnetMap node: {} ", subnetId.getValue());
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
+ }
} catch (Exception e) {
LOG.error("Updation of subnetMap failed for node: {}", subnetId.getValue());
- } finally {
- if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
- }
}
return subnetmap;
}
protected Subnetmap removeFromSubnetNode(Uuid subnetId, Uuid networkId, Uuid routerId, Uuid vpnId, Uuid portId) {
Subnetmap subnetmap = null;
- boolean isLockAcquired = false;
InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class)
.child(Subnetmap.class, new SubnetmapKey(subnetId))
.build();
try {
- Optional<Subnetmap> sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
- if (sn.isPresent()) {
- SubnetmapBuilder builder = new SubnetmapBuilder(sn.get());
- if (routerId != null) {
- builder.setRouterId(null);
- }
- if (networkId != null) {
- builder.setNetworkId(null);
- }
- if (vpnId != null) {
- builder.setVpnId(null);
- }
- if (portId != null && builder.getPortList() != null) {
- List<Uuid> portList = builder.getPortList();
- portList.remove(portId);
- builder.setPortList(portList);
- }
+ synchronized (subnetId.getValue().intern()) {
+ Optional<Subnetmap> sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ if (sn.isPresent()) {
+ SubnetmapBuilder builder = new SubnetmapBuilder(sn.get());
+ if (routerId != null) {
+ builder.setRouterId(null);
+ }
+ if (networkId != null) {
+ builder.setNetworkId(null);
+ }
+ if (vpnId != null) {
+ builder.setVpnId(null);
+ }
+ if (portId != null && builder.getPortList() != null) {
+ List<Uuid> portList = builder.getPortList();
+ portList.remove(portId);
+ builder.setPortList(portList);
+ }
- subnetmap = builder.build();
- isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
- LOG.debug("Removing from existing subnetmap node: {} ", subnetId.getValue());
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
- } else {
- LOG.warn("removing from non-existing subnetmap node: {} ", subnetId.getValue());
+ subnetmap = builder.build();
+ LOG.debug("Removing from existing subnetmap node: {} ", subnetId.getValue());
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
+ } else {
+ LOG.warn("removing from non-existing subnetmap node: {} ", subnetId.getValue());
+ }
}
} catch (Exception e) {
LOG.error("Removal from subnetmap failed for node: {}", subnetId.getValue());
- } finally {
- if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
- }
}
return subnetmap;
}
protected Subnetmap updateSubnetmapNodeWithPorts(Uuid subnetId, Uuid portId, Uuid directPortId) {
Subnetmap subnetmap = null;
- boolean isLockAcquired = false;
InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class,
new SubnetmapKey(subnetId)).build();
try {
- Optional<Subnetmap> sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
- if (sn.isPresent()) {
- SubnetmapBuilder builder = new SubnetmapBuilder(sn.get());
- if (null != portId) {
- List<Uuid> portList = builder.getPortList();
- if (null == portList) {
- portList = new ArrayList<>();
+ synchronized (subnetId.getValue().intern()) {
+ Optional<Subnetmap> sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ if (sn.isPresent()) {
+ SubnetmapBuilder builder = new SubnetmapBuilder(sn.get());
+ if (null != portId) {
+ List<Uuid> portList = builder.getPortList();
+ if (null == portList) {
+ portList = new ArrayList<Uuid>();
+ }
+ portList.add(portId);
+ builder.setPortList(portList);
+ LOG.debug("Updating existing subnetmap node {} with port {}", subnetId.getValue(),
+ portId.getValue());
}
- portList.add(portId);
- builder.setPortList(portList);
- LOG.debug("Updating existing subnetmap node {} with port {}", subnetId.getValue(),
- portId.getValue());
- }
- if (null != directPortId) {
- List<Uuid> directPortList = builder.getDirectPortList();
- if (null == directPortList) {
- directPortList = new ArrayList<>();
+ if (null != directPortId) {
+ List<Uuid> directPortList = builder.getDirectPortList();
+ if (null == directPortList) {
+ directPortList = new ArrayList<Uuid>();
+ }
+ directPortList.add(directPortId);
+ builder.setDirectPortList(directPortList);
+ LOG.debug("Updating existing subnetmap node {} with port {}", subnetId.getValue(),
+ directPortId.getValue());
}
- directPortList.add(directPortId);
- builder.setDirectPortList(directPortList);
- LOG.debug("Updating existing subnetmap node {} with port {}", subnetId.getValue(),
- directPortId.getValue());
+ subnetmap = builder.build();
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
+ } else {
+ LOG.error("Trying to update non-existing subnetmap node {} ", subnetId.getValue());
}
- subnetmap = builder.build();
- isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
- } else {
- LOG.error("Trying to update non-existing subnetmap node {} ", subnetId.getValue());
}
} catch (Exception e) {
LOG.error("Updating port list of a given subnetMap failed for node: {} with exception{}",
subnetId.getValue(), e);
- } finally {
- if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
- }
}
return subnetmap;
}
protected Subnetmap removePortsFromSubnetmapNode(Uuid subnetId, Uuid portId, Uuid directPortId) {
Subnetmap subnetmap = null;
- boolean isLockAcquired = false;
InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class,
new SubnetmapKey(subnetId)).build();
try {
- Optional<Subnetmap> sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
- if (sn.isPresent()) {
- SubnetmapBuilder builder = new SubnetmapBuilder(sn.get());
- if (null != portId && null != builder.getPortList()) {
- List<Uuid> portList = builder.getPortList();
- portList.remove(portId);
- builder.setPortList(portList);
- LOG.debug("Removing port {} from existing subnetmap node: {} ", portId.getValue(),
- subnetId.getValue());
- }
- if (null != directPortId && null != builder.getDirectPortList()) {
- List<Uuid> directPortList = builder.getDirectPortList();
- directPortList.remove(directPortId);
- builder.setDirectPortList(directPortList);
- LOG.debug("Removing direct port {} from existing subnetmap node: {} ", directPortId.getValue(),
- subnetId.getValue());
+ synchronized (subnetId.getValue().intern()) {
+ Optional<Subnetmap> sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ if (sn.isPresent()) {
+ SubnetmapBuilder builder = new SubnetmapBuilder(sn.get());
+ if (null != portId && null != builder.getPortList()) {
+ List<Uuid> portList = builder.getPortList();
+ portList.remove(portId);
+ builder.setPortList(portList);
+ LOG.debug("Removing port {} from existing subnetmap node: {} ", portId.getValue(),
+ subnetId.getValue());
+ }
+ if (null != directPortId && null != builder.getDirectPortList()) {
+ List<Uuid> directPortList = builder.getDirectPortList();
+ directPortList.remove(directPortId);
+ builder.setDirectPortList(directPortList);
+ LOG.debug("Removing direct port {} from existing subnetmap node: {} ", directPortId
+ .getValue(), subnetId.getValue());
+ }
+ subnetmap = builder.build();
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
+ } else {
+ LOG.error("Trying to remove port from non-existing subnetmap node {}", subnetId.getValue());
}
- subnetmap = builder.build();
- isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
- } else {
- LOG.error("Trying to remove port from non-existing subnetmap node {}", subnetId.getValue());
}
} catch (Exception e) {
LOG.error("Removing a port from port list of a subnetmap failed for node: {} with expection {}",
subnetId.getValue(), e);
- } finally {
- if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
- }
}
return subnetmap;
}
protected void deleteSubnetMapNode(Uuid subnetId) {
- boolean isLockAcquired = false;
InstanceIdentifier<Subnetmap> subnetMapIdentifier =
InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class,new SubnetmapKey(subnetId)).build();
LOG.debug("removing subnetMap node: {} ", subnetId.getValue());
try {
- isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
- MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, subnetMapIdentifier);
+ synchronized (subnetId.getValue().intern()) {
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, subnetMapIdentifier);
+ }
} catch (Exception e) {
LOG.error("Delete subnetMap node failed for subnet : {} ", subnetId.getValue());
- } finally {
- if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
- }
}
}
VpnInstanceBuilder builder = null;
List<VpnTarget> vpnTargetList = new ArrayList<>();
boolean isLockAcquired = false;
- InstanceIdentifier<VpnInstance> vpnIdentifier =
- InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class,new VpnInstanceKey(vpnName)).build();
+ InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).child
+ (VpnInstance.class, new VpnInstanceKey(vpnName)).build();
try {
Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
vpnIdentifier);
}
VpnInstance newVpn = builder.setIpv4Family(ipv4vpnBuilder.build()).build();
- isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnName);
+ isLockAcquired = NeutronvpnUtils.lock(vpnName);
LOG.debug("Creating/Updating vpn-instance for {} ", vpnName);
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier, newVpn);
} catch (Exception e) {
LOG.error("Update VPN Instance node failed for node: {} {} {} {}", vpnName, rd, irt, ert);
} finally {
if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, vpnName);
+ NeutronvpnUtils.unlock(vpnName);
}
}
}
.build();
LOG.debug("removing vpnMaps node: {} ", vpnid.getValue());
try {
- isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnid.getValue());
+ isLockAcquired = NeutronvpnUtils.lock(vpnid.getValue());
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
} catch (Exception e) {
LOG.error("Delete vpnMaps node failed for vpn : {} ", vpnid.getValue());
} finally {
if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, vpnid.getValue());
+ NeutronvpnUtils.unlock(vpnid.getValue());
}
}
}
builder.setNetworkIds(nwList);
}
- isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
+ isLockAcquired = NeutronvpnUtils.lock(vpnId.getValue());
LOG.debug("Creating/Updating vpnMaps node: {} ", vpnId.getValue());
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier, builder.build());
LOG.debug("VPNMaps DS updated for VPN {} ", vpnId.getValue());
LOG.error("UpdateVpnMaps failed for node: {} ", vpnId.getValue());
} finally {
if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
+ NeutronvpnUtils.unlock(vpnId.getValue());
}
}
}
if (vpnMap.getNetworkIds() == null && routerId.equals(vpnMap.getVpnId())) {
try {
// remove entire node in case of internal VPN
- isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
+ isLockAcquired = NeutronvpnUtils.lock(vpnId.getValue());
LOG.debug("removing vpnMaps node: {} ", vpnId);
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
} catch (Exception e) {
LOG.error("Deletion of vpnMaps node failed for vpn {}", vpnId.getValue());
} finally {
if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
+ NeutronvpnUtils.unlock(vpnId.getValue());
}
}
return;
}
try {
- isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
+ isLockAcquired = NeutronvpnUtils.lock(vpnId.getValue());
LOG.debug("clearing from vpnMaps node: {} ", vpnId.getValue());
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier,
vpnMapBuilder.build());
LOG.error("Clearing from vpnMaps node failed for vpn {}", vpnId.getValue());
} finally {
if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
+ NeutronvpnUtils.unlock(vpnId.getValue());
}
}
} else {
new VpnInstanceKey(vpnId.getValue()))
.build();
try {
- isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
+ isLockAcquired = NeutronvpnUtils.lock(vpnId.getValue());
LOG.debug("Deleting vpnInstance {}", vpnId.getValue());
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier);
} catch (Exception e) {
LOG.error("Deletion of VPNInstance node failed for VPN {}", vpnId.getValue());
} finally {
if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
+ NeutronvpnUtils.unlock(vpnId.getValue());
}
}
}
- protected void createVpnInterface(Uuid vpnId, Port port) {
- boolean isLockAcquired = false;
- if (vpnId == null || port == null) {
- return;
- }
+ protected void createVpnInterface(Uuid vpnId, Uuid routerId, Port port,
+ WriteTransaction wrtConfigTxn) {
String infName = port.getUuid().getValue();
List<Adjacency> adjList = new ArrayList<>();
- InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
-
- // find router associated to vpn
- Uuid routerId = NeutronvpnUtils.getRouterforVpn(dataBroker, vpnId);
+ List<FixedIps> ips = port.getFixedIps();
+ Boolean isRouterInterface = false;
+ if (port.getDeviceOwner() != null) {
+ isRouterInterface = port.getDeviceOwner().equals(NeutronConstants.DEVICE_OWNER_ROUTER_INF);
+ }
+ LOG.trace("createVpnInterface - isRouterInterface:{}", isRouterInterface);
Router rtr = null;
if (routerId != null) {
rtr = NeutronvpnUtils.getNeutronRouter(dataBroker, routerId);
}
- // find all subnets to which this port is associated
- List<FixedIps> ips = port.getFixedIps();
// create adjacency list
for (FixedIps ip : ips) {
// create vm adjacency
- StringBuilder IpPrefixBuild = new StringBuilder(ip.getIpAddress().getIpv4Address().getValue());
- String IpPrefix = IpPrefixBuild.append("/32").toString();
- Adjacency vmAdj = new AdjacencyBuilder().setKey(new AdjacencyKey(IpPrefix)).setIpAddress(IpPrefix)
- .setMacAddress(port.getMacAddress().getValue()).build();
+ String ipValue = String.valueOf(ip.getIpAddress().getValue());
+ String ipPrefix = (ip.getIpAddress().getIpv4Address() != null) ? ipValue + "/32" : ipValue + "/128";
+ Adjacency vmAdj = new AdjacencyBuilder().setKey(new AdjacencyKey(ipPrefix)).setIpAddress(ipPrefix)
+ .setMacAddress(port.getMacAddress().getValue()).setPrimaryAdjacency(true)
+ .setSubnetId(ip.getSubnetId()).build();
adjList.add(vmAdj);
// create extra route adjacency
if (rtr != null && rtr.getRoutes() != null) {
List<Routes> routeList = rtr.getRoutes();
- List<Adjacency> erAdjList = addAdjacencyforExtraRoute(vpnId, routeList);
+ List<Adjacency> erAdjList = getAdjacencyforExtraRoute(vpnId, routeList, ipValue);
if (erAdjList != null && !erAdjList.isEmpty()) {
adjList.addAll(erAdjList);
}
}
- String ipValue = ip.getIpAddress().getIpv4Address().getValue();
NeutronvpnUtils.createVpnPortFixedIpToPort(dataBroker, vpnId.getValue(), ipValue, infName, port
- .getMacAddress()
- .getValue(), false, true, false);
+ .getMacAddress().getValue(), isRouterInterface, true, false);
}
// create vpn-interface on this neutron port
Adjacencies adjs = new AdjacenciesBuilder().setAdjacency(adjList).build();
- VpnInterfaceBuilder vpnb = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(infName))
- .setName(infName)
- .setVpnInstanceName(vpnId.getValue())
- .addAugmentation(Adjacencies.class, adjs);
- VpnInterface vpnIf = vpnb.build();
-
- try {
- isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
- LOG.debug("Creating vpn interface {}", vpnIf);
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
- } catch (Exception ex) {
- LOG.error("Creation of vpninterface {} failed due to {}", infName, ex);
- } finally {
- if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, infName);
- }
+ writeVpnInterfaceToDs(vpnId, infName, adjs, isRouterInterface, wrtConfigTxn);
+ if (routerId != null) {
+ addToNeutronRouterInterfacesMap(routerId, infName);
}
}
- protected void deleteVpnInterface(Uuid vpnId, Port port) {
-
- if (port != null) {
- boolean isLockAcquired = false;
- String infName = port.getUuid().getValue();
- InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
-
- try {
- isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
- LOG.debug("Deleting vpn interface {}", infName);
- MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
+ protected void deleteVpnInterface(Uuid vpnId, Uuid routerId, Port port, WriteTransaction wrtConfigTxn) {
+ Boolean wrtConfigTxnPresent = true;
+ if (wrtConfigTxn == null) {
+ wrtConfigTxnPresent = false;
+ wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
+ }
+ String infName = port.getUuid().getValue();
+ InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
+ try {
+ LOG.debug("Deleting vpn interface {}", infName);
+ wrtConfigTxn.delete(LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
- List<FixedIps> ips = port.getFixedIps();
- for (FixedIps ip : ips) {
- String ipValue = ip.getIpAddress().getIpv4Address().getValue();
- NeutronvpnUtils.removeVpnPortFixedIpToPort(dataBroker, vpnId.getValue(), ipValue);
- }
- } catch (Exception ex) {
- LOG.error("Deletion of vpninterface {} failed due to {}", infName, ex);
- } finally {
- if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, infName);
- }
+ List<FixedIps> ips = port.getFixedIps();
+ for (FixedIps ip : ips) {
+ String ipValue = String.valueOf(ip.getIpAddress().getValue());
+ NeutronvpnUtils.removeVpnPortFixedIpToPort(dataBroker, vpnId.getValue(), ipValue);
}
+ } catch (Exception ex) {
+ LOG.error("Deletion of vpninterface {} failed due to {}", infName, ex);
+ }
+ if (routerId != null) {
+ removeFromNeutronRouterInterfacesMap(routerId, infName);
+ }
+ if (!wrtConfigTxnPresent) {
+ wrtConfigTxn.submit();
}
}
- protected void updateVpnInterface(Uuid vpnId, Uuid oldVpnId, Port port, boolean isBeingAssociated) {
+ protected void updateVpnInterface(Uuid vpnId, Uuid oldVpnId, Port port, boolean isBeingAssociated, boolean isSubnetIp) {
if (vpnId == null || port == null) {
return;
}
String infName = port.getUuid().getValue();
InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
try {
- isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
+ isLockAcquired = NeutronvpnUtils.lock(infName);
Optional<VpnInterface> optionalVpnInterface = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType
.CONFIGURATION, vpnIfIdentifier);
if (optionalVpnInterface.isPresent()) {
.setVpnInstanceName(vpnId.getValue());
LOG.debug("Updating vpn interface {}", infName);
if (!isBeingAssociated) {
- List<Adjacency> adjacencyList = vpnIfBuilder.getAugmentation(Adjacencies.class).getAdjacency();
+ Adjacencies adjs = vpnIfBuilder.getAugmentation(Adjacencies.class);
+ List<Adjacency> adjacencyList = (adjs != null) ? adjs.getAdjacency() : new ArrayList<Adjacency>();
Iterator<Adjacency> adjacencyIter = adjacencyList.iterator();
while (adjacencyIter.hasNext()) {
Adjacency adjacency = adjacencyIter.next();
Optional<VpnPortipToPort> optionalVpnPort = NeutronvpnUtils.read(dataBroker,
LogicalDatastoreType
.OPERATIONAL, id);
- if (optionalVpnPort.isPresent() && optionalVpnPort.get().isLearnt()) {
+ if (!optionalVpnPort.isPresent() || optionalVpnPort.get().isLearnt()) {
LOG.trace("Removing adjacencies from vpninterface {} upon dissociation of router {} " +
"from VPN " + "{}", infName, vpnId, oldVpnId);
adjacencyIter.remove();
Adjacencies adjacencies = new AdjacenciesBuilder().setAdjacency(adjacencyList).build();
vpnIfBuilder.addAugmentation(Adjacencies.class, adjacencies);
}
- MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIfBuilder
- .build());
-
List<FixedIps> ips = port.getFixedIps();
for (FixedIps ip : ips) {
- String ipValue = ip.getIpAddress().getIpv4Address().getValue();
+ String ipValue = String.valueOf(ip.getIpAddress().getValue());
if (oldVpnId != null) {
NeutronvpnUtils.removeVpnPortFixedIpToPort(dataBroker, oldVpnId.getValue(), ipValue);
}
- NeutronvpnUtils.createVpnPortFixedIpToPort(dataBroker, vpnId.getValue(), ipValue, port.getUuid()
- .getValue(), port.getMacAddress().getValue(), false, true, false);
+ NeutronvpnUtils.createVpnPortFixedIpToPort(dataBroker, vpnId.getValue(), ipValue, infName, port
+ .getMacAddress().getValue(), isSubnetIp, true, false);
}
+ MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIfBuilder
+ .build());
} else {
LOG.error("VPN Interface {} not found", infName);
}
LOG.error("Updation of vpninterface {} failed due to {}", infName, ex);
} finally {
if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, infName);
- }
- }
- }
-
- protected void deleteVpnInterface(String vpnName, String infName) {
- if (vpnName == null || infName == null) {
- return;
- }
-
- boolean isLockAcquired = false;
- InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
- try {
- isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
- LOG.debug("Deleting vpn interface {}", infName);
- MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
- } catch (Exception ex) {
- LOG.error("Deletion of vpninterface {} failed due to {}", infName, ex);
- } finally {
- if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, infName);
+ NeutronvpnUtils.unlock(infName);
}
}
}
if (router != null) {
Uuid existingVpn = NeutronvpnUtils.getVpnForRouter(dataBroker, router, true);
if (existingVpn != null) {
- List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(dataBroker, router);
- if (routerSubnets != null) {
- // Update the router interfaces alone and exit
- for (Uuid subnetId : routerSubnets) {
- InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
- child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
- Optional<Subnetmap> snMap = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
- if (snMap.isPresent()) {
- Subnetmap sn = snMap.get();
- List<Uuid> portList = sn.getPortList();
- if (portList != null) {
- for (Uuid port : sn.getPortList()) {
- addToNeutronRouterInterfacesMap(router, port.getValue());
- }
- }
- }
- }
- }
- LOG.info("Creation of Internal L3VPN skipped for VPN {} due to router {} already associated to " +
- "external VPN {}", vpn.getValue(), router.getValue(), existingVpn.getValue());
+ // use case when a cluster is rebooted and router add DCN is received, triggering #createL3InternalVpn
+
+ // if before reboot, router was already associated to VPN, should not proceed associating router to
+ // internal VPN. Adding to RouterInterfacesMap is also not needed since it's a config DS and will be
+ // preserved upon reboot.
+ // For a non-reboot case #associateRouterToInternalVPN already takes care of adding to
+ // RouterInterfacesMap via #createVPNInterface call.
+ LOG.info("Associating router to Internal VPN skipped for VPN {} due to router {} already associated " +
+ "to external VPN {}", vpn.getValue(), router.getValue(), existingVpn.getValue());
return;
}
associateRouterToInternalVpn(vpn, router);
* @param ert A list of Export Route Targets
* @param router UUID of the neutron router the VPN may be associated to
* @param networks UUID of the neutron network the VPN may be associated to
+ * @throws Exception if association of L3VPN failed
*/
public void createL3Vpn(Uuid vpn, String name, Uuid tenant, List<String> rd, List<String> irt, List<String> ert,
Uuid router, List<Uuid> networks) throws Exception {
List<L3vpn> vpns = input.getL3vpn();
for (L3vpn vpn : vpns) {
+ List<String> existingRDs = NeutronvpnUtils.getExistingRDs(dataBroker);
RpcError error = null;
String msg;
if (vpn.getRouteDistinguisher() == null || vpn.getImportRT() == null || vpn.getExportRT() == null) {
warningcount++;
continue;
}
+ if (existingRDs.contains(vpn.getRouteDistinguisher().get(0))) {
+ msg = String.format("Creation of L3VPN failed for VPN %s as another VPN with the same RD %s is already configured",
+ vpn.getId().getValue(), vpn.getRouteDistinguisher().get(0));
+ LOG.warn(msg);
+ error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
+ errorList.add(error);
+ warningcount++;
+ continue;
+ }
if (vpn.getRouterId() != null) {
if (NeutronvpnUtils.getNeutronRouter(dataBroker, vpn.getRouterId()) == null) {
msg = String.format("Creation of L3VPN failed for VPN %s due to router not found %s",
InstanceIdentifier<VpnInstance> vpnIdentifier =
InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class, new VpnInstanceKey
(vpn.getValue())).build();
- Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier);
+ Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType
+ .CONFIGURATION, vpnIdentifier);
if (optionalVpn.isPresent()) {
removeL3Vpn(vpn);
} else {
return result;
}
- protected void addSubnetToVpn(Uuid vpnId, Uuid subnet) {
+ protected void addSubnetToVpn(final Uuid vpnId, Uuid subnet) {
LOG.debug("Adding subnet {} to vpn {}", subnet.getValue(), vpnId.getValue());
Subnetmap sn = updateSubnetNode(subnet, null, null, null, null, vpnId);
- boolean isLockAcquired = false;
- String lockName = vpnId.getValue() + subnet.getValue();
- String elanInstanceName = sn.getNetworkId().getValue();
- InstanceIdentifier<ElanInstance> elanIdentifierId =
- InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class,
- new ElanInstanceKey(elanInstanceName)).build();
- Optional<ElanInstance> elanInstance = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- elanIdentifierId);
- long elanTag = elanInstance.get().getElanTag();
- Uuid routerId = NeutronvpnUtils.getVpnMap(dataBroker, vpnId).getRouterId();
- if (vpnId.equals(routerId)) {
- isExternalVpn = false;
- } else {
- isExternalVpn = true;
- }
- try {
- isLockAcquired = NeutronvpnUtils.lock(lockManager, lockName);
- checkAndPublishSubnetAddNotification(subnet, sn.getSubnetIp(), vpnId.getValue(), isExternalVpn, elanTag);
- LOG.debug("Subnet added to Vpn notification sent");
- } catch (Exception e) {
- LOG.error("Subnet added to Vpn notification failed", e);
- } finally {
- if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, lockName);
- }
- }
+ final Uuid routerId = NeutronvpnUtils.getVpnMap(dataBroker, vpnId).getRouterId();
// Check if there are ports on this subnet and add corresponding
// vpn-interfaces
List<Uuid> portList = sn.getPortList();
if (portList != null) {
- for (Uuid port : sn.getPortList()) {
- LOG.debug("adding vpn-interface for port {}", port.getValue());
- createVpnInterface(vpnId, NeutronvpnUtils.getNeutronPort(dataBroker, port));
- if (routerId != null) {
- addToNeutronRouterInterfacesMap(routerId, port.getValue());
- }
+ for (final Uuid portId : sn.getPortList()) {
+ LOG.debug("adding vpn-interface for port {}", portId.getValue());
+ final DataStoreJobCoordinator portDataStoreCoordinator = DataStoreJobCoordinator.getInstance();
+ portDataStoreCoordinator.enqueueJob("PORT-" + portId.getValue(), new
+ Callable<List<ListenableFuture<Void>>>() {
+ @Override
+ public List<ListenableFuture<Void>> call() throws Exception {
+ WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ createVpnInterface(vpnId, routerId, NeutronvpnUtils.getNeutronPort(dataBroker, portId),
+ wrtConfigTxn);
+ futures.add(wrtConfigTxn.submit());
+ return futures;
+ }
+ });
}
}
}
oldVpnId = sn.getVpnId();
List<String> ips = sn.getRouterInterfaceFixedIps();
for (String ipValue : ips) {
- IpAddress ip = new IpAddress(ipValue.toCharArray());
- if (oldVpnId != null) {
- NeutronvpnUtils.removeVpnPortFixedIpToPort(dataBroker, oldVpnId.getValue(), ipValue);
- }
- NeutronvpnUtils.createVpnPortFixedIpToPort(dataBroker, vpnId.getValue(), ipValue, sn
- .getRouterInterfaceName().getValue(), sn.getRouterIntfMacAddress(), true, true, false);
+ // Update the association of router-interface to external vpn
+ String PortName = NeutronvpnUtils.getNeutronPortNameFromVpnPortFixedIp(dataBroker, oldVpnId.getValue(), ipValue);
+ updateVpnInterface(vpnId, oldVpnId, NeutronvpnUtils.getNeutronPort(dataBroker, new Uuid(PortName)),
+ isBeingAssociated, true);
}
}
sn = updateSubnetNode(subnet, null, null, null, null, vpnId);
- boolean isLockAcquired = false;
- String lockName = vpnId.getValue() + subnet.getValue();
- String elanInstanceName = sn.getNetworkId().getValue();
- InstanceIdentifier<ElanInstance> elanIdentifierId =
- InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class,
- new ElanInstanceKey(elanInstanceName)).build();
- Optional<ElanInstance> elanInstance = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- elanIdentifierId);
- long elanTag = elanInstance.get().getElanTag();
- try {
- isLockAcquired = NeutronvpnUtils.lock(lockManager, lockName);
- checkAndPublishSubnetUpdNotification(subnet, sn.getSubnetIp(), vpnId.getValue(), isBeingAssociated,
- elanTag);
- LOG.debug("Subnet updated in Vpn notification sent");
- } catch (Exception e) {
- LOG.error("Subnet updated in Vpn notification failed", e);
- } finally {
- if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, lockName);
- }
- }
// Check for ports on this subnet and update association of
// corresponding vpn-interfaces to external vpn
List<Uuid> portList = sn.getPortList();
if (portList != null) {
for (Uuid port : sn.getPortList()) {
- LOG.debug("Updating vpn-interface for port {}", port.getValue());
- updateVpnInterface(vpnId, oldVpnId, NeutronvpnUtils.getNeutronPort(dataBroker, port), isBeingAssociated);
+ LOG.debug("Updating vpn-interface for port {} isBeingAssociated {}", port.getValue(), isBeingAssociated);
+ updateVpnInterface(vpnId, oldVpnId, NeutronvpnUtils.getNeutronPort(dataBroker, port),
+ isBeingAssociated, false);
}
}
}
- InstanceIdentifier<RouterInterfaces> getRouterInterfacesId(Uuid routerId) {
+ public InstanceIdentifier<RouterInterfaces> getRouterInterfacesId(Uuid routerId) {
return InstanceIdentifier.builder(RouterInterfacesMap.class)
.child(RouterInterfaces.class, new RouterInterfacesKey(routerId)).build();
}
- void addToNeutronRouterInterfacesMap(Uuid routerId, String interfaceName) {
- InstanceIdentifier<RouterInterfaces> routerInterfacesId = getRouterInterfacesId(routerId);
- Optional<RouterInterfaces> optRouterInterfaces = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType
- .CONFIGURATION, routerInterfacesId);
- Interfaces routerInterface = new InterfacesBuilder().setKey(new InterfacesKey(interfaceName)).setInterfaceId
- (interfaceName).build();
- if (optRouterInterfaces.isPresent()) {
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId.child(Interfaces
- .class, new InterfacesKey(interfaceName)), routerInterface);
- } else {
- RouterInterfacesBuilder builder = new RouterInterfacesBuilder().setRouterId(routerId);
- List<Interfaces> interfaces = new ArrayList<>();
- interfaces.add(routerInterface);
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId, builder.setInterfaces
- (interfaces).build());
+
+ protected void addToNeutronRouterInterfacesMap(Uuid routerId, String interfaceName) {
+ synchronized (routerId.getValue().intern()) {
+ InstanceIdentifier<RouterInterfaces> routerInterfacesId = getRouterInterfacesId(routerId);
+ Optional<RouterInterfaces> optRouterInterfaces = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType
+ .CONFIGURATION, routerInterfacesId);
+ Interfaces routerInterface = new InterfacesBuilder().setKey(new InterfacesKey(interfaceName)).setInterfaceId
+ (interfaceName).build();
+ if (optRouterInterfaces.isPresent()) {
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId.child(Interfaces
+ .class, new InterfacesKey(interfaceName)), routerInterface);
+ } else {
+ RouterInterfacesBuilder builder = new RouterInterfacesBuilder().setRouterId(routerId);
+ List<Interfaces> interfaces = new ArrayList<>();
+ interfaces.add(routerInterface);
+ MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId.child(Interfaces
+ .class, new InterfacesKey(interfaceName)), routerInterface);
+ }
}
}
- void removeFromNeutronRouterInterfacesMap(Uuid routerId, String interfaceName) {
- InstanceIdentifier<RouterInterfaces> routerInterfacesId = getRouterInterfacesId(routerId);
- Optional<RouterInterfaces> optRouterInterfaces = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType
- .CONFIGURATION, routerInterfacesId);
- Interfaces routerInterface = new InterfacesBuilder().setKey(new InterfacesKey(interfaceName)).setInterfaceId
- (interfaceName).build();
- if (optRouterInterfaces.isPresent()) {
- RouterInterfaces routerInterfaces = optRouterInterfaces.get();
- List<Interfaces> interfaces = routerInterfaces.getInterfaces();
- if (interfaces != null && interfaces.remove(routerInterface)) {
- if (interfaces.isEmpty()) {
- MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId);
- } else {
- MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION,
- routerInterfacesId.child(Interfaces.class, new InterfacesKey(interfaceName)));
+ protected void removeFromNeutronRouterInterfacesMap(Uuid routerId, String interfaceName) {
+ synchronized (routerId.getValue().intern()) {
+ InstanceIdentifier<RouterInterfaces> routerInterfacesId = getRouterInterfacesId(routerId);
+ Optional<RouterInterfaces> optRouterInterfaces = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType
+ .CONFIGURATION, routerInterfacesId);
+ Interfaces routerInterface = new InterfacesBuilder().setKey(new InterfacesKey(interfaceName)).setInterfaceId
+ (interfaceName).build();
+ if (optRouterInterfaces.isPresent()) {
+ RouterInterfaces routerInterfaces = optRouterInterfaces.get();
+ List<Interfaces> interfaces = routerInterfaces.getInterfaces();
+ if (interfaces != null && interfaces.remove(routerInterface)) {
+ if (interfaces.isEmpty()) {
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId);
+ } else {
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ routerInterfacesId.child(Interfaces.class, new InterfacesKey(interfaceName)));
+ }
}
}
}
destination, nexthop, rpcResult.getErrors());
}
} catch (InterruptedException | ExecutionException e) {
- LOG.warn("Error happened while invoking addStaticRoute RPC: {}", e);
+ LOG.warn("Error happened while invoking addStaticRoute RPC: ", e);
}
} else {
// Any other case is a fault.
&& interVpnLink.getFirstEndpoint().getIpAddress().getValue().equals(nexthop)) );
}
- protected List<Adjacency> addAdjacencyforExtraRoute(Uuid vpnId, List<Routes> routeList) {
- List<Adjacency> adjList = new ArrayList<Adjacency>();
+ protected List<Adjacency> getAdjacencyforExtraRoute(Uuid vpnId, List<Routes> routeList, String fixedIp) {
+ List<Adjacency> adjList = new ArrayList<>();
Map<String, List<String>> adjMap = new HashMap<>();
for (Routes route : routeList) {
if (route == null || route.getNexthop() == null || route.getDestination() == null) {
} else {
String nextHop = String.valueOf(route.getNexthop().getValue());
String destination = String.valueOf(route.getDestination().getValue());
- String infName = NeutronvpnUtils.getNeutronPortNameFromVpnPortFixedIp(dataBroker, vpnId.getValue(), nextHop);
- if (infName == null) {
- LOG.error("Unable to find VPN NextHop interface to apply extra-route destination {} on VPN {} with nexthop {}",
- destination, vpnId.getValue(), nextHop);
- // Proceed to process the next extra-route
+ if (!nextHop.equals(fixedIp)) {
+ LOG.trace("FixedIP {} is not extra route nexthop for destination {}", fixedIp, destination);
continue;
}
- LOG.trace("Adding extra route for destination {} onto vpn {} with nexthop {} and infName {}", destination,
- vpnId.getValue(), nextHop, infName);
+ LOG.trace("Adding extra route for destination {} onto vpn {} with nexthop {} ", destination,
+ vpnId.getValue(), nextHop);
List<String> hops = adjMap.get(destination);
- if (hops == null){
+ if (hops == null) {
hops = new ArrayList<>();
adjMap.put(destination, hops);
}
- if (! hops.contains(nextHop))
+ if (!hops.contains(nextHop)) {
hops.add(nextHop);
+ }
}
}
(destination)).setKey(new AdjacencyKey(destination)).build();
adjList.add(erAdj);
}
+ return adjList;
+ }
- for (Adjacency adj : adjList) {
- for(String nextHop : adj.getNextHopIpList()) {
- String infName = NeutronvpnUtils.getNeutronPortNameFromVpnPortFixedIp(dataBroker, vpnId.getValue(), nextHop);
- if ( infName != null ) {
- InstanceIdentifier<VpnInterface> vpnIfIdentifier = InstanceIdentifier.builder(VpnInterfaces.class)
- .child(VpnInterface.class, new VpnInterfaceKey(infName)).build();
+ protected void updateVpnInterfaceWithExtraRouteAdjacency(Uuid vpnId, List<Routes> routeList) {
+ for (Routes route : routeList) {
+ if (route == null || route.getNexthop() == null || route.getDestination() == null) {
+ LOG.error("Incorrect input received for extra route. {}", route);
+ } else {
+ String nextHop = String.valueOf(route.getNexthop().getValue());
+ String destination = String.valueOf(route.getDestination().getValue());
+ String infName = NeutronvpnUtils.getNeutronPortNameFromVpnPortFixedIp(dataBroker, vpnId.getValue(),
+ nextHop);
+ if (infName != null) {
+ LOG.trace("Updating extra route for destination {} onto vpn {} with nexthop {} and infName {}", destination,
+ vpnId.getValue(), nextHop, infName);
boolean isLockAcquired = false;
try {
- Optional<VpnInterface> optionalVpnInterface =
- NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
- if (optionalVpnInterface.isPresent()) {
- Adjacency newAdj = new AdjacencyBuilder(adj).setNextHopIpList(Arrays.asList(nextHop))
- .build();
- Adjacencies erAdjs = new AdjacenciesBuilder().setAdjacency(Arrays.asList(newAdj)).build();
- VpnInterface vpnIf = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(infName))
- .addAugmentation(Adjacencies.class, erAdjs).build();
- isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
- MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
- } else {
- LOG.error("VM adjacency for interface {} not present; cannot add extra route adjacency",
- infName);
- }
+ InstanceIdentifier<VpnInterface> identifier = InstanceIdentifier.builder(VpnInterfaces.class)
+ .child(VpnInterface.class, new VpnInterfaceKey(infName)).build();
+ InstanceIdentifier<Adjacency> path = identifier.augmentation(Adjacencies.class).
+ child(Adjacency.class, new AdjacencyKey(destination));
+ Adjacency erAdj = new AdjacencyBuilder().setIpAddress(destination).setNextHopIpList(Arrays.asList(nextHop)).
+ setKey(new AdjacencyKey(destination)).build();
+ isLockAcquired = NeutronvpnUtils.lock(infName);
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, path, erAdj);
} catch (Exception e) {
- LOG.error("exception in adding extra route with destination: {}, next hop: {}", adj
- .getIpAddress(), nextHop, e);
+ LOG.error("exception in adding extra route with destination: {}, next hop: {}", destination, nextHop, e);
} finally {
if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, infName);
+ NeutronvpnUtils.unlock(infName);
}
}
} else {
- LOG.warn("Could not find suitable Interface for {}", nextHop);
+ LOG.debug("Unable to find VPN NextHop interface to apply extra-route destination {} on VPN {} " +
+ "with nexthop {}", destination, vpnId.getValue(), nextHop);
}
-
}
}
- return adjList;
}
protected void removeAdjacencyforExtraRoute(Uuid vpnId, List<Routes> routeList) {
boolean isLockAcquired = false;
String nextHop = String.valueOf(route.getNexthop().getValue());
String destination = String.valueOf(route.getDestination().getValue());
- String infName = NeutronvpnUtils.getNeutronPortNameFromVpnPortFixedIp(dataBroker, vpnId.getValue(), nextHop);
+ String infName = NeutronvpnUtils.getNeutronPortNameFromVpnPortFixedIp(dataBroker, vpnId.getValue(),
+ nextHop);
if (infName == null) {
- LOG.error("Unable to find VPN NextHop interface to remove extra-route destination {} on VPN {} with nexthop {}",
+ LOG.error("Unable to find VPN NextHop interface to remove extra-route destination {} on VPN {} " +
+ "with nexthop {}",
destination, vpnId.getValue(), nextHop);
// Proceed to remove the next extra-route
continue;
}
try {
- isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
+ isLockAcquired = NeutronvpnUtils.lock(infName);
if (updateNextHops) {
// An update must be done, not including the current next hop
InstanceIdentifier<VpnInterface> vpnIfIdentifier = InstanceIdentifier.builder(
LOG.error("exception in deleting extra route: {}" + e);
} finally {
if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, infName);
+ NeutronvpnUtils.unlock(infName);
}
}
} else {
deleteVpnInstance(id);
}
- protected void removeSubnetFromVpn(Uuid vpnId, Uuid subnet) {
+ protected void removeSubnetFromVpn(final Uuid vpnId, Uuid subnet) {
LOG.debug("Removing subnet {} from vpn {}", subnet.getValue(), vpnId.getValue());
+ final Uuid routerId = NeutronvpnUtils.getVpnMap(dataBroker, vpnId).getRouterId();
Subnetmap sn = NeutronvpnUtils.getSubnetmap(dataBroker, subnet);
- boolean isLockAcquired = false;
- String lockName = vpnId.getValue() + subnet.getValue();
- String elanInstanceName = sn.getNetworkId().getValue();
- InstanceIdentifier<ElanInstance> elanIdentifierId =
- InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class,
- new ElanInstanceKey(elanInstanceName)).build();
- Optional<ElanInstance> elanInstance = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- elanIdentifierId);
- long elanTag = elanInstance.get().getElanTag();
- Uuid routerId = NeutronvpnUtils.getVpnMap(dataBroker, vpnId).getRouterId();
- if (vpnId.equals(routerId)) {
- isExternalVpn = false;
- } else {
- isExternalVpn = true;
- }
- try {
- isLockAcquired = NeutronvpnUtils.lock(lockManager, lockName);
- checkAndPublishSubnetDelNotification(subnet, sn.getSubnetIp(), vpnId.getValue(), isExternalVpn, elanTag);
- LOG.debug("Subnet removed from Vpn notification sent");
- } catch (Exception e) {
- LOG.error("Subnet removed from Vpn notification failed", e);
- } finally {
- if (isLockAcquired) {
- NeutronvpnUtils.unlock(lockManager, lockName);
- }
- }
if (sn != null) {
// Check if there are ports on this subnet; remove corresponding vpn-interfaces
List<Uuid> portList = sn.getPortList();
if (portList != null) {
- for (Uuid port : sn.getPortList()) {
- LOG.debug("removing vpn-interface for port {}", port.getValue());
- deleteVpnInterface(vpnId, NeutronvpnUtils.getNeutronPort(dataBroker, port));
- if (routerId != null) {
- removeFromNeutronRouterInterfacesMap(routerId, port.getValue());
- }
+ for (final Uuid portId : sn.getPortList()) {
+ LOG.debug("removing vpn-interface for port {}", portId.getValue());
+ final DataStoreJobCoordinator portDataStoreCoordinator = DataStoreJobCoordinator.getInstance();
+ portDataStoreCoordinator.enqueueJob("PORT-" + portId.getValue(), () -> {
+ WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ deleteVpnInterface(vpnId, routerId, NeutronvpnUtils.getNeutronPort(dataBroker, portId),
+ wrtConfigTxn);
+ futures.add(wrtConfigTxn.submit());
+ return futures;
+ });
}
}
// update subnet-vpn association
updateVpnMaps(vpnId, null, routerId, null, null);
LOG.debug("Updating association of subnets to external vpn {}", vpnId.getValue());
List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(dataBroker, routerId);
-// if (!vpnId.equals(routerId)) {
if (routerSubnets != null) {
for (Uuid subnetId : routerSubnets) {
updateVpnForSubnet(vpnId, subnetId, true);
LOG.error("publishing of notification upon association of router {} to VPN {} failed : ", routerId
.getValue(), vpnId.getValue(), e);
}
-// }
-// else {
-// LOG.debug("Adding subnets to internal vpn {}", vpnId.getValue());
-// for (Uuid subnet : routerSubnets) {
-// addSubnetToVpn(vpnId, subnet);
-// }
-// }
}
protected void associateRouterToInternalVpn(Uuid vpnId, Uuid routerId) {
Uuid vpnId = input.getVpnId();
Uuid routerId = input.getRouterId();
try {
- if (routerId != null && vpnId != null) {
- Router rtr = NeutronvpnUtils.getNeutronRouter(dataBroker, routerId);
- VpnMap vpnMap = NeutronvpnUtils.getVpnMap(dataBroker, vpnId);
- if (rtr != null && vpnMap != null) {
+ VpnMap vpnMap = NeutronvpnUtils.getVpnMap(dataBroker, vpnId);
+ Router rtr = NeutronvpnUtils.getNeutronRouter(dataBroker, routerId);
+ if (vpnMap != null) {
+ if (rtr != null) {
Uuid extVpnId = NeutronvpnUtils.getVpnForRouter(dataBroker, routerId, true);
if (vpnMap.getRouterId() != null) {
returnMsg.append("vpn ").append(vpnId.getValue()).append(" already associated to router ")
if (port != null) {
List<FixedIps> fixedIPs = port.getFixedIps();
for (FixedIps ip : fixedIPs) {
- fixedIPList.add(ip.getIpAddress().getIpv4Address().getValue());
+ fixedIPList.add(String.valueOf(ip.getIpAddress().getValue()));
}
} else {
returnMsg.append("neutron port: ").append(portId.getValue()).append(" not found");
* Implementation of the "vpnservice:l3vpn-config-show" karaf CLI command
*
* @param vpnuuid Uuid of the VPN whose config must be shown
- * @return
+ * @return formatted output list
*/
public List<String> showVpnConfigCLI(Uuid vpnuuid) {
List<String> result = new ArrayList<>();
return result;
}
- private String getshowVpnConfigCLIHelp() {
- StringBuilder help = new StringBuilder("Usage:");
- help.append("display vpn-config [-vid/--vpnid <id>]");
- return help.toString();
- }
-
- private void checkAndPublishSubnetAddNotification(Uuid subnetId, String subnetIp, String vpnName,
- Boolean isExternalvpn, Long elanTag) throws InterruptedException {
- SubnetAddedToVpnBuilder builder = new SubnetAddedToVpnBuilder();
-
- LOG.info("publish notification called");
+ protected void createExternalVpnInterfaces(Uuid extNetId) {
+ if (extNetId == null) {
+ LOG.trace("external network is null");
+ return;
+ }
- builder.setSubnetId(subnetId);
- builder.setSubnetIp(subnetIp);
- builder.setVpnName(vpnName);
- builder.setExternalVpn(isExternalvpn);
- builder.setElanTag(elanTag);
+ Collection<String> extElanInterfaces = elanService.getExternalElanInterfaces(extNetId.getValue());
+ if (extElanInterfaces == null || extElanInterfaces.isEmpty()) {
+ LOG.trace("No external ports attached to external network {}", extNetId.getValue());
+ return;
+ }
- notificationPublishService.putNotification(builder.build());
+ WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
+ for (String elanInterface : extElanInterfaces) {
+ createExternalVpnInterface(extNetId, elanInterface, wrtConfigTxn);
+ }
+ wrtConfigTxn.submit();
}
- private void checkAndPublishSubnetDelNotification(Uuid subnetId, String subnetIp, String vpnName,
- Boolean isExternalvpn, Long elanTag) throws InterruptedException {
- SubnetDeletedFromVpnBuilder builder = new SubnetDeletedFromVpnBuilder();
+ protected void removeExternalVpnInterfaces(Uuid extNetId) {
+ Collection<String> extElanInterfaces = elanService.getExternalElanInterfaces(extNetId.getValue());
+ if (extElanInterfaces == null || extElanInterfaces.isEmpty()) {
+ LOG.trace("No external ports attached for external network {}", extNetId);
+ return;
+ }
+ try {
- LOG.info("publish notification called");
+ WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
+ for (String elanInterface : extElanInterfaces) {
+ InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils
+ .buildVpnInterfaceIdentifier(elanInterface);
+ LOG.info("Removing vpn interface {}", elanInterface);
+ wrtConfigTxn.delete(LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
+ }
+ wrtConfigTxn.submit();
- builder.setSubnetId(subnetId);
- builder.setSubnetIp(subnetIp);
- builder.setVpnName(vpnName);
- builder.setExternalVpn(isExternalvpn);
- builder.setElanTag(elanTag);
+ } catch (Exception ex) {
+ LOG.error("Removal of vpninterfaces {} failed due to {}", extElanInterfaces, ex);
+ }
+ }
- notificationPublishService.putNotification(builder.build());
+ private void createExternalVpnInterface(Uuid vpnId, String infName, WriteTransaction wrtConfigTxn) {
+ writeVpnInterfaceToDs(vpnId, infName, null, false /* not a router iface */, wrtConfigTxn);
}
- private void checkAndPublishSubnetUpdNotification(Uuid subnetId, String subnetIp, String vpnName,
- Boolean isExternalvpn, Long elanTag) throws InterruptedException {
- SubnetUpdatedInVpnBuilder builder = new SubnetUpdatedInVpnBuilder();
+ private void writeVpnInterfaceToDs(Uuid vpnId, String infName, Adjacencies adjacencies,
+ Boolean isRouterInterface, WriteTransaction wrtConfigTxn) {
+ if (vpnId == null || infName == null) {
+ LOG.debug("vpn id or interface is null");
+ return;
+ }
+
+ Boolean wrtConfigTxnPresent = true;
+ if (wrtConfigTxn == null) {
+ wrtConfigTxnPresent = false;
+ wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
+ }
- LOG.info("publish notification called");
+ InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
+ VpnInterfaceBuilder vpnb = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(infName))
+ .setName(infName)
+ .setVpnInstanceName(vpnId.getValue())
+ .setIsRouterInterface(isRouterInterface);
+ if (adjacencies != null) {
+ vpnb.addAugmentation(Adjacencies.class, adjacencies);
+ }
+ VpnInterface vpnIf = vpnb.build();
+ try {
+ LOG.info("Creating vpn interface {}", vpnIf);
+ wrtConfigTxn.put(LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
+ } catch (Exception ex) {
+ LOG.error("Creation of vpninterface {} failed due to {}", infName, ex);
+ }
- builder.setSubnetId(subnetId);
- builder.setSubnetIp(subnetIp);
- builder.setVpnName(vpnName);
- builder.setExternalVpn(isExternalvpn);
- builder.setElanTag(elanTag);
+ if (!wrtConfigTxnPresent) {
+ wrtConfigTxn.submit();
+ }
+ }
- notificationPublishService.putNotification(builder.build());
+ private String getshowVpnConfigCLIHelp() {
+ StringBuilder help = new StringBuilder("Usage:");
+ help.append("display vpn-config [-vid/--vpnid <id>]");
+ return help.toString();
}
private void checkAndPublishRouterAssociatedtoVpnNotification(Uuid routerId, Uuid vpnId) throws
Code Review / netvirt.git / blobdiff