X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=vpnservice%2Fneutronvpn%2Fneutronvpn-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fnetvirt%2Fneutronvpn%2FNeutronvpnManager.java;h=c9433753c625d955a5b570d758b7a8e806039069;hb=3beb9903a1b344f90fb059ed2efad5691e790388;hp=ef42f6fd1c211458f49238305b596601bc4dbe29;hpb=57fee8c89fe4d37d9b237a76e01f449bac06de50;p=netvirt.git diff --git a/vpnservice/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/netvirt/neutronvpn/NeutronvpnManager.java b/vpnservice/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/netvirt/neutronvpn/NeutronvpnManager.java index ef42f6fd1c..c9433753c6 100644 --- a/vpnservice/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/netvirt/neutronvpn/NeutronvpnManager.java +++ b/vpnservice/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/netvirt/neutronvpn/NeutronvpnManager.java @@ -7,24 +7,27 @@ */ package org.opendaylight.netvirt.neutronvpn; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.SettableFuture; 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.Iterator; +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; @@ -41,16 +44,12 @@ import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev14081 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.natservice.rev160111.ext.routers.Routers; +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; @@ -79,9 +78,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev15060 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; @@ -106,7 +102,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.A import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveStaticRouteInput; import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveStaticRouteInputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.VpnRpcService; -import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.ext.rev150712.NetworkL3Extension; import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.l3.attributes.Routes; import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router; import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network; @@ -124,14 +119,18 @@ import org.opendaylight.yangtools.yang.common.RpcResultBuilder; import org.slf4j.Logger; 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; @@ -139,13 +138,19 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even /** * @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; @@ -153,7 +158,8 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even vpnRpcService = vpnRpcSrv; this.elanService = elanService; floatingIpMapListener = neutronFloatingToFixedIpMappingChangeListener; - this.lockManager = lockManager; + LOG.info("neutronvpnConfig: {}", neutronvpnConfig); + this.neutronvpnConfig = neutronvpnConfig; } @Override @@ -161,37 +167,36 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even 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 id = InstanceIdentifier.builder(Subnetmaps.class). child(Subnetmap.class, new SubnetmapKey(subnetId)).build(); try { - Optional 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); + synchronized (subnetId.getValue().intern()) { + Optional 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.setRouterInterfaceName(null); - } - if (routerIntfMacAddress != null) { - builder.setRouterIntfMacAddress(routerIntfMacAddress); - } 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 fixedIps = builder.getRouterInterfaceFixedIps(); if (fixedIps == null) { - fixedIps = new ArrayList(); + fixedIps = new ArrayList<>(); } fixedIps.add(fixedIp); builder.setRouterInterfaceFixedIps(fixedIps); @@ -199,17 +204,11 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even builder.setRouterInterfaceFixedIps(null); } subnetmap = builder.build(); - handleExternalSubnetPorts(subnetmap); - 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()); } } @@ -217,194 +216,172 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even Uuid vpnId) { Subnetmap subnetmap = null; SubnetmapBuilder builder = null; - boolean isLockAcquired = false; InstanceIdentifier id = InstanceIdentifier.builder(Subnetmaps.class) .child(Subnetmap.class, new SubnetmapKey(subnetId)) .build(); try { - Optional 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 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(); - handleExternalSubnetPorts(subnetmap); - 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 id = InstanceIdentifier.builder(Subnetmaps.class) .child(Subnetmap.class, new SubnetmapKey(subnetId)) .build(); try { - Optional 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 portList = builder.getPortList(); - portList.remove(portId); - builder.setPortList(portList); - } + synchronized (subnetId.getValue().intern()) { + Optional 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 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 id = InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class, new SubnetmapKey(subnetId)).build(); try { - Optional sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id); - if (sn.isPresent()) { - SubnetmapBuilder builder = new SubnetmapBuilder(sn.get()); - if (null != portId) { - List portList = builder.getPortList(); - if (null == portList) { - portList = new ArrayList<>(); + synchronized (subnetId.getValue().intern()) { + Optional sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id); + if (sn.isPresent()) { + SubnetmapBuilder builder = new SubnetmapBuilder(sn.get()); + if (null != portId) { + List portList = builder.getPortList(); + if (null == portList) { + portList = new ArrayList(); + } + 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 directPortList = builder.getDirectPortList(); - if (null == directPortList) { - directPortList = new ArrayList<>(); + if (null != directPortId) { + List directPortList = builder.getDirectPortList(); + if (null == directPortList) { + directPortList = new ArrayList(); + } + 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 id = InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class, new SubnetmapKey(subnetId)).build(); try { - Optional sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id); - if (sn.isPresent()) { - SubnetmapBuilder builder = new SubnetmapBuilder(sn.get()); - if (null != portId && null != builder.getPortList()) { - List 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 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 sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id); + if (sn.isPresent()) { + SubnetmapBuilder builder = new SubnetmapBuilder(sn.get()); + if (null != portId && null != builder.getPortList()) { + List 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 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 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()); - } } } @@ -413,8 +390,8 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even VpnInstanceBuilder builder = null; List vpnTargetList = new ArrayList<>(); boolean isLockAcquired = false; - InstanceIdentifier vpnIdentifier = - InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class,new VpnInstanceKey(vpnName)).build(); + InstanceIdentifier vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).child + (VpnInstance.class, new VpnInstanceKey(vpnName)).build(); try { Optional optionalVpn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier); @@ -465,14 +442,14 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even } 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); } } } @@ -484,13 +461,13 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even .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()); } } } @@ -528,7 +505,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even 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()); @@ -536,7 +513,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even LOG.error("UpdateVpnMaps failed for node: {} ", vpnId.getValue()); } finally { if (isLockAcquired) { - NeutronvpnUtils.unlock(lockManager, vpnId.getValue()); + NeutronvpnUtils.unlock(vpnId.getValue()); } } } @@ -555,14 +532,14 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even 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; @@ -583,7 +560,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even } 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()); @@ -591,7 +568,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even LOG.error("Clearing from vpnMaps node failed for vpn {}", vpnId.getValue()); } finally { if (isLockAcquired) { - NeutronvpnUtils.unlock(lockManager, vpnId.getValue()); + NeutronvpnUtils.unlock(vpnId.getValue()); } } } else { @@ -607,104 +584,89 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even 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 adjList = new ArrayList<>(); - InstanceIdentifier vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName); - - // find router associated to vpn - Uuid routerId = NeutronvpnUtils.getRouterforVpn(dataBroker, vpnId); + List 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 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 routeList = rtr.getRoutes(); - List erAdjList = addAdjacencyforExtraRoute(vpnId, routeList); + List erAdjList = getAdjacencyforExtraRoute(vpnId, routeList, ipValue); if (erAdjList != null && !erAdjList.isEmpty()) { adjList.addAll(erAdjList); } } - String ipValue = ip.getIpAddress().getIpv4Address().getValue(); - createVpnPortFixedIpToPort(vpnId.getValue(), ipValue, infName, port.getMacAddress().getValue(), false, - true, false); + NeutronvpnUtils.createVpnPortFixedIpToPort(dataBroker, vpnId.getValue(), ipValue, infName, port + .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 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 vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName); + try { + LOG.debug("Deleting vpn interface {}", infName); + wrtConfigTxn.delete(LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier); - List ips = port.getFixedIps(); - for (FixedIps ip : ips) { - String ipValue = ip.getIpAddress().getIpv4Address().getValue(); - removeVpnPortFixedIpToPort(vpnId.getValue(), ipValue); - } - } catch (Exception ex) { - LOG.error("Deletion of vpninterface {} failed due to {}", infName, ex); - } finally { - if (isLockAcquired) { - NeutronvpnUtils.unlock(lockManager, infName); - } + List 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; } @@ -712,57 +674,48 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even String infName = port.getUuid().getValue(); InstanceIdentifier vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName); try { - Optional optionalVpnInterface = NeutronvpnUtils.read(dataBroker, - LogicalDatastoreType.CONFIGURATION, - vpnIfIdentifier); + isLockAcquired = NeutronvpnUtils.lock(infName); + Optional optionalVpnInterface = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType + .CONFIGURATION, vpnIfIdentifier); if (optionalVpnInterface.isPresent()) { - VpnInterfaceBuilder vpnIfBuilder = new VpnInterfaceBuilder(optionalVpnInterface.get()); - VpnInterface vpnIf = vpnIfBuilder.setVpnInstanceName(vpnId.getValue()).build(); - isLockAcquired = NeutronvpnUtils.lock(lockManager, infName); - LOG.debug("Updating vpn interface {}", vpnIf); - InstanceIdentifier path = vpnIfIdentifier.augmentation(Adjacencies.class); - Optional optAdjacencies = NeutronvpnUtils.read(dataBroker, - LogicalDatastoreType.CONFIGURATION, path); - if (optAdjacencies.isPresent()) { - List adjacencies = optAdjacencies.get().getAdjacency(); - if (!adjacencies.isEmpty() && !isBeingAssociated) { - LOG.trace("Router dissasociate from old {} to new {} Vpn",oldVpnId,vpnId); - Iterator adjIt = adjacencies.iterator(); - while (adjIt.hasNext()) { - Adjacency adjElem = adjIt.next(); - String mipToQuery = adjElem.getIpAddress().split("/")[0]; - InstanceIdentifier id = NeutronvpnUtils.buildVpnPortipToPortIdentifier(oldVpnId.getValue(), mipToQuery); - Optional optionalVpnPort = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id); - if (optionalVpnPort.isPresent() && optionalVpnPort.get().isLearnt()) { - InstanceIdentifier adjacencyIdentifier = InstanceIdentifier.builder(VpnInterfaces.class). - child(VpnInterface.class, new VpnInterfaceKey(vpnIf.getName())).augmentation(Adjacencies.class) - .child(Adjacency.class, new AdjacencyKey(mipToQuery + "/32")).build(); - MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier); - removeVpnPortFixedIpToPort(oldVpnId.getValue(),mipToQuery); - LOG.trace("Removed the adjacency {} for VPN Interface {}",mipToQuery,vpnIf.getName()); - } - + VpnInterfaceBuilder vpnIfBuilder = new VpnInterfaceBuilder(optionalVpnInterface.get()) + .setVpnInstanceName(vpnId.getValue()); + LOG.debug("Updating vpn interface {}", infName); + if (!isBeingAssociated) { + Adjacencies adjs = vpnIfBuilder.getAugmentation(Adjacencies.class); + List adjacencyList = (adjs != null) ? adjs.getAdjacency() : new ArrayList(); + Iterator adjacencyIter = adjacencyList.iterator(); + while (adjacencyIter.hasNext()) { + Adjacency adjacency = adjacencyIter.next(); + String mipToQuery = adjacency.getIpAddress().split("/")[0]; + InstanceIdentifier id = NeutronvpnUtils.buildVpnPortipToPortIdentifier + (oldVpnId.getValue(), mipToQuery); + Optional optionalVpnPort = NeutronvpnUtils.read(dataBroker, + LogicalDatastoreType + .OPERATIONAL, id); + if (!optionalVpnPort.isPresent() || optionalVpnPort.get().isLearnt()) { + LOG.trace("Removing adjacencies from vpninterface {} upon dissociation of router {} " + + "from VPN " + "{}", infName, vpnId, oldVpnId); + adjacencyIter.remove(); + NeutronvpnUtils.removeVpnPortFixedIpToPort(dataBroker, oldVpnId.getValue(), mipToQuery); + LOG.trace("Entry for fixedIP {} for port {} on VPN removed from " + + "VpnPortFixedIPToPortData", mipToQuery, infName, vpnId.getValue()); } } + Adjacencies adjacencies = new AdjacenciesBuilder().setAdjacency(adjacencyList).build(); + vpnIfBuilder.addAugmentation(Adjacencies.class, adjacencies); } - if(!isBeingAssociated) { - MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf); - } - List ips = port.getFixedIps(); for (FixedIps ip : ips) { - String ipValue = ip.getIpAddress().getIpv4Address().getValue(); + String ipValue = String.valueOf(ip.getIpAddress().getValue()); if (oldVpnId != null) { - InstanceIdentifier id = NeutronvpnUtils.buildVpnPortipToPortIdentifier - (oldVpnId.getValue(), ipValue); - Optional optionalVpnPort = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id); - if (optionalVpnPort.isPresent()) { - removeVpnPortFixedIpToPort(oldVpnId.getValue(), ipValue); - } + NeutronvpnUtils.removeVpnPortFixedIpToPort(dataBroker, oldVpnId.getValue(), ipValue); } - createVpnPortFixedIpToPort(vpnId.getValue(), ipValue, infName, 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); } @@ -770,50 +723,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even LOG.error("Updation of vpninterface {} failed due to {}", infName, ex); } finally { if (isLockAcquired) { - NeutronvpnUtils.unlock(lockManager, infName); - } - } - } - - - protected void createVpnInterface(Uuid vpnId, String infName) { - if (vpnId == null || infName == null) { - return; - } - - boolean isLockAcquired = false; - InstanceIdentifier vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName); - VpnInterface vpnIf = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(infName)) - .setName(infName).setVpnInstanceName(vpnId.getValue()).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); - } - } - } - - protected void deleteVpnInterface(String vpnName, String infName) { - if (vpnName == null || infName == null) { - return; - } - - boolean isLockAcquired = false; - InstanceIdentifier 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); } } } @@ -830,26 +740,15 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even if (router != null) { Uuid existingVpn = NeutronvpnUtils.getVpnForRouter(dataBroker, router, true); if (existingVpn != null) { - List routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(dataBroker, router); - if (routerSubnets != null) { - // Update the router interfaces alone and exit - for (Uuid subnetId : routerSubnets) { - InstanceIdentifier id = InstanceIdentifier.builder(Subnetmaps.class). - child(Subnetmap.class, new SubnetmapKey(subnetId)).build(); - Optional snMap = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id); - if (snMap.isPresent()) { - Subnetmap sn = snMap.get(); - List 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); @@ -868,6 +767,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even * @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 rd, List irt, List ert, Uuid router, List networks) throws Exception { @@ -910,6 +810,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even List vpns = input.getL3vpn(); for (L3vpn vpn : vpns) { + List existingRDs = NeutronvpnUtils.getExistingRDs(dataBroker); RpcError error = null; String msg; if (vpn.getRouteDistinguisher() == null || vpn.getImportRT() == null || vpn.getExportRT() == null) { @@ -930,6 +831,15 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even 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", @@ -1134,7 +1044,8 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even InstanceIdentifier vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class, new VpnInstanceKey (vpn.getValue())).build(); - Optional optionalVpn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier); + Optional optionalVpn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType + .CONFIGURATION, vpnIdentifier); if (optionalVpn.isPresent()) { removeL3Vpn(vpn); } else { @@ -1173,45 +1084,29 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even 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 elanIdentifierId = - InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class, - new ElanInstanceKey(elanInstanceName)).build(); - Optional 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 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>>() { + @Override + public List> call() throws Exception { + WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction(); + List> futures = new ArrayList<>(); + createVpnInterface(vpnId, routerId, NeutronvpnUtils.getNeutronPort(dataBroker, portId), + wrtConfigTxn); + futures.add(wrtConfigTxn.submit()); + return futures; + } + }); } } } @@ -1229,90 +1124,67 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even oldVpnId = sn.getVpnId(); List ips = sn.getRouterInterfaceFixedIps(); for (String ipValue : ips) { - IpAddress ip = new IpAddress(ipValue.toCharArray()); - if (oldVpnId != null) { - InstanceIdentifier id = NeutronvpnUtils.buildVpnPortipToPortIdentifier(oldVpnId - .getValue(), ipValue); - Optional optionalVpnPort = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType - .CONFIGURATION, id); - if (optionalVpnPort.isPresent()) { - removeVpnPortFixedIpToPort(oldVpnId.getValue(), ipValue); - } - } - createVpnPortFixedIpToPort(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 elanIdentifierId = - InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class, - new ElanInstanceKey(elanInstanceName)).build(); - Optional 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 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 getRouterInterfacesId(Uuid routerId) { + public InstanceIdentifier getRouterInterfacesId(Uuid routerId) { return InstanceIdentifier.builder(RouterInterfacesMap.class) .child(RouterInterfaces.class, new RouterInterfacesKey(routerId)).build(); } - void addToNeutronRouterInterfacesMap(Uuid routerId, String interfaceName) { - InstanceIdentifier routerInterfacesId = getRouterInterfacesId(routerId); - Optional 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 = new ArrayList<>(); - interfaces.add(routerInterface); - MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId, builder.setInterfaces - (interfaces).build()); - } - } - void removeFromNeutronRouterInterfacesMap(Uuid routerId, String interfaceName) { - InstanceIdentifier routerInterfacesId = getRouterInterfacesId(routerId); - Optional 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 = 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 addToNeutronRouterInterfacesMap(Uuid routerId, String interfaceName) { + synchronized (routerId.getValue().intern()) { + InstanceIdentifier routerInterfacesId = getRouterInterfacesId(routerId); + Optional 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 = new ArrayList<>(); + interfaces.add(routerInterface); + MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId.child(Interfaces + .class, new InterfacesKey(interfaceName)), routerInterface); + } + } + } + + protected void removeFromNeutronRouterInterfacesMap(Uuid routerId, String interfaceName) { + synchronized (routerId.getValue().intern()) { + InstanceIdentifier routerInterfacesId = getRouterInterfacesId(routerId); + Optional 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 = 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))); + } } } } @@ -1350,7 +1222,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even 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. @@ -1403,8 +1275,8 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even && interVpnLink.getFirstEndpoint().getIpAddress().getValue().equals(nexthop)) ); } - protected List addAdjacencyforExtraRoute(Uuid vpnId, List routeList) { - List adjList = new ArrayList(); + protected List getAdjacencyforExtraRoute(Uuid vpnId, List routeList, String fixedIp) { + List adjList = new ArrayList<>(); Map> adjMap = new HashMap<>(); for (Routes route : routeList) { if (route == null || route.getNexthop() == null || route.getDestination() == null) { @@ -1412,22 +1284,20 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even } 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 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); + } } } @@ -1436,44 +1306,44 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even (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 vpnIfIdentifier = InstanceIdentifier.builder(VpnInterfaces.class) - .child(VpnInterface.class, new VpnInterfaceKey(infName)).build(); + protected void updateVpnInterfaceWithExtraRouteAdjacency(Uuid vpnId, List 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 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 identifier = InstanceIdentifier.builder(VpnInterfaces.class) + .child(VpnInterface.class, new VpnInterfaceKey(infName)).build(); + InstanceIdentifier 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 routeList) { @@ -1482,9 +1352,11 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even 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; @@ -1518,7 +1390,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even } try { - isLockAcquired = NeutronvpnUtils.lock(lockManager, infName); + isLockAcquired = NeutronvpnUtils.lock(infName); if (updateNextHops) { // An update must be done, not including the current next hop InstanceIdentifier vpnIfIdentifier = InstanceIdentifier.builder( @@ -1540,7 +1412,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even LOG.error("exception in deleting extra route: {}" + e); } finally { if (isLockAcquired) { - NeutronvpnUtils.unlock(lockManager, infName); + NeutronvpnUtils.unlock(infName); } } } else { @@ -1568,45 +1440,25 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even 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 elanIdentifierId = - InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class, - new ElanInstanceKey(elanInstanceName)).build(); - Optional 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 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> futures = new ArrayList<>(); + deleteVpnInterface(vpnId, routerId, NeutronvpnUtils.getNeutronPort(dataBroker, portId), + wrtConfigTxn); + futures.add(wrtConfigTxn.submit()); + return futures; + }); } } // update subnet-vpn association @@ -1620,7 +1472,6 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even updateVpnMaps(vpnId, null, routerId, null, null); LOG.debug("Updating association of subnets to external vpn {}", vpnId.getValue()); List routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(dataBroker, routerId); -// if (!vpnId.equals(routerId)) { if (routerSubnets != null) { for (Uuid subnetId : routerSubnets) { updateVpnForSubnet(vpnId, subnetId, true); @@ -1634,13 +1485,6 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even 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) { @@ -1700,8 +1544,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even } } } - if (network.getAugmentation(NetworkL3Extension.class) != null - && network.getAugmentation(NetworkL3Extension.class).isExternal()) { + if (NeutronvpnUtils.getIsExternal(network)) { nvpnNatManager.addExternalNetworkToVpn(network, vpn); } } @@ -1740,7 +1583,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even "of the one given as input", nw.getValue(), vpnId.getValue())); } } - if (network.getAugmentation(NetworkL3Extension.class).isExternal()) { + if (NeutronvpnUtils.getIsExternal(network)) { nvpnNatManager.removeExternalNetworkFromVpn(network); } } @@ -1814,10 +1657,10 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even 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 ") @@ -1870,7 +1713,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even if (port != null) { List 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"); @@ -2127,7 +1970,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even * 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 showVpnConfigCLI(Uuid vpnuuid) { List result = new ArrayList<>(); @@ -2196,55 +2039,89 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even return result; } - private String getshowVpnConfigCLIHelp() { - StringBuilder help = new StringBuilder("Usage:"); - help.append("display vpn-config [-vid/--vpnid ]"); - 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 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 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 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; + } - LOG.info("publish notification called"); + Boolean wrtConfigTxnPresent = true; + if (wrtConfigTxn == null) { + wrtConfigTxnPresent = false; + wrtConfigTxn = dataBroker.newWriteOnlyTransaction(); + } - builder.setSubnetId(subnetId); - builder.setSubnetIp(subnetIp); - builder.setVpnName(vpnName); - builder.setExternalVpn(isExternalvpn); - builder.setElanTag(elanTag); + InstanceIdentifier 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); + } + + if (!wrtConfigTxnPresent) { + wrtConfigTxn.submit(); + } + } - notificationPublishService.putNotification(builder.build()); + private String getshowVpnConfigCLIHelp() { + StringBuilder help = new StringBuilder("Usage:"); + help.append("display vpn-config [-vid/--vpnid ]"); + return help.toString(); } private void checkAndPublishRouterAssociatedtoVpnNotification(Uuid routerId, Uuid vpnId) throws @@ -2266,41 +2143,4 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, Even protected void dissociatefixedIPFromFloatingIP(String fixedNeutronPortName) { floatingIpMapListener.dissociatefixedIPFromFloatingIP(fixedNeutronPortName); } - - public void createVpnPortFixedIpToPort(String vpnName, String fixedIp,String portName, String macAddress, - boolean isSubnetIp, boolean isConfig, boolean isLearnt) { - NeutronvpnUtils.createVpnPortFixedIpToPort(dataBroker, vpnName, fixedIp, portName, macAddress, isSubnetIp,isConfig,isLearnt); - } - - public void removeVpnPortFixedIpToPort(String vpnName, String fixedIp) { - NeutronvpnUtils.removeVpnPortFixedIpToPort(dataBroker, vpnName, fixedIp); - } - - private void handleExternalSubnetPorts(Subnetmap subnetmap) { - Uuid routerId = subnetmap.getRouterId(); - Uuid subnetId = subnetmap.getId(); - if (routerId == null) { - LOG.trace("No router attached to subnet {}", subnetId); - return; - } - - InstanceIdentifier routersIdentifier = NeutronvpnUtils.buildExtRoutersIdentifier(routerId); - Optional optionalRouters = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, - routersIdentifier); - if (!optionalRouters.isPresent() || optionalRouters.get().getNetworkId() == null) { - LOG.trace("No external network attached to router {} subnet {}", routerId, subnetId); - return; - } - - Uuid extNetId = optionalRouters.get().getNetworkId(); - Collection extElanInterfaces = elanService.getExternalElanInterfaces(extNetId.getValue()); - if (extElanInterfaces == null || extElanInterfaces.isEmpty()) { - LOG.trace("No external ports attached to subnet {}", subnetmap.getId()); - return; - } - - for (String elanInterface : extElanInterfaces) { - createVpnInterface(subnetmap.getVpnId(), elanInterface); - } - } }