import com.google.common.base.Optional;
import com.google.common.util.concurrent.SettableFuture;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.Adjacency;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.AdjacencyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.AdjacencyKey;
+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.ports.rev150712.port.attributes.FixedIps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
logger.info("Neutron VPN Manager Closed");
}
- protected Subnetmap updateSubnetNode(Uuid subnetId, Uuid tenantId, Uuid networkId, Uuid routerId, Uuid vpnId,
- Uuid portId) {
-
+ protected Subnetmap updateSubnetNode(Uuid subnetId, String subnetIp, Uuid tenantId, Uuid networkId, Uuid routerId,
+ Uuid vpnId, Uuid portId) {
+ Subnetmap subnetmap = null;
+ SubnetmapBuilder builder = null;
+ boolean isLockAcquired = false;
+ InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
+ child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
try {
- SubnetmapBuilder builder = null;
-
- InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
- child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
Optional<Subnetmap> sn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, id);
logger.debug("updating Subnet :read: ");
if (sn.isPresent()) {
logger.debug("updating Subnet :new: ");
}
+ if (subnetIp != null) {
+ builder.setSubnetIp(subnetIp);
+ }
if (routerId != null) {
builder.setRouterId(routerId);
}
builder.setPortList(portList);
}
- Subnetmap subnetmap = builder.build();
+ subnetmap = builder.build();
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
+ logger.debug("Creating/Updating subnetMap node: {} ", subnetId.getValue());
MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
- logger.debug("Created/Updated subnetmap node: {} ", subnetId.getValue());
-
- return subnetmap;
} catch (Exception e) {
- logger.error("Update local subnetmap failed for node: {} {} {} {} {} {} ",
- subnetId.getValue(), tenantId.getValue(), networkId.getValue(), routerId.getValue(), vpnId
- .getValue(), portId.getValue());
- throw new RuntimeException(e);
+ logger.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 {
- InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
- child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
Optional<Subnetmap> sn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, id);
-
if (sn.isPresent()) {
SubnetmapBuilder builder = new SubnetmapBuilder(sn.get());
-
if (routerId != null) {
builder.setRouterId(null);
}
}
subnetmap = builder.build();
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
logger.debug("Removing from existing subnetmap node: {} ", subnetId.getValue());
MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
} else {
- logger.warn("remove from non-existing subnetmap node: {} ", subnetId.getValue());
+ logger.warn("removing from non-existing subnetmap node: {} ", subnetId.getValue());
}
} catch (Exception e) {
- logger.error("Remove from subnetmap failed for node: {} {} {} {} {} {} ", subnetId.getValue(), networkId
- .getValue(), routerId.getValue(), vpnId.getValue(), portId.getValue());
- throw new RuntimeException(e);
+ logger.error("Removal from subnetmap failed for node: {}", subnetId.getValue());
+ } finally {
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
+ }
}
-
return subnetmap;
}
- private void updateVpnInstanceNode(String name, List<String> rd, List<String> irt, List<String> ert) {
+ protected void deleteSubnetMapNode(Uuid subnetId) {
+ boolean isLockAcquired = false;
+ InstanceIdentifier<Subnetmap> subnetMapIdentifier = InstanceIdentifier.builder(Subnetmaps.class)
+ .child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
+ logger.debug("removing subnetMap node: {} ", subnetId.getValue());
+ try {
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
+ MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, subnetMapIdentifier);
+ } catch (Exception e) {
+ logger.error("Delete subnetMap node failed for subnet : {} ", subnetId.getValue());
+ } finally {
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
+ }
+ }
+ }
+
+ private void updateVpnInstanceNode(String vpnName, List<String> rd, List<String> irt, List<String> ert) {
+ VpnInstanceBuilder builder = null;
+ List<VpnTarget> vpnTargetList = new ArrayList<VpnTarget>();
+ boolean isLockAcquired = false;
+ InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).
+ child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
try {
- VpnInstanceBuilder builder = null;
- List<VpnTarget> vpnTargetList = new ArrayList<VpnTarget>();
- InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).
- child(VpnInstance.class, new VpnInstanceKey(name)).build();
Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
vpnIdentifier);
- logger.debug("Creating/Updating a new vpn-instance node: {} ", name);
+ logger.debug("Creating/Updating a new vpn-instance node: {} ", vpnName);
if (optionalVpn.isPresent()) {
builder = new VpnInstanceBuilder(optionalVpn.get());
logger.debug("updating existing vpninstance node");
} else {
- builder = new VpnInstanceBuilder().setKey(new VpnInstanceKey(name)).setVpnInstanceName(name);
+ builder = new VpnInstanceBuilder().setKey(new VpnInstanceKey(vpnName)).setVpnInstanceName(vpnName);
}
-
if (irt != null && !irt.isEmpty()) {
if (ert != null && !ert.isEmpty()) {
List<String> commonRT = new ArrayList<String>(irt);
}
VpnInstance newVpn = builder.setIpv4Family(ipv4vpnBuilder.build()).build();
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnName);
+ logger.debug("Creating/Updating vpn-instance for {} ", vpnName);
MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier, newVpn);
- logger.debug("Created/Updated vpn-instance for {} ", name);
} catch (Exception e) {
- logger.error("Update VPN Instance node failed for node: {} {} {} {}", name, rd, irt, ert);
- throw new RuntimeException(e);
+ logger.error("Update VPN Instance node failed for node: {} {} {} {}", vpnName, rd, irt, ert);
+ } finally {
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, vpnName);
+ }
}
}
private void deleteVpnMapsNode(Uuid vpnid) {
+ boolean isLockAcquired = false;
InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
.child(VpnMap.class, new VpnMapKey(vpnid)).build();
logger.debug("removing vpnMaps node: {} ", vpnid.getValue());
- MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
+ try {
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnid.getValue());
+ MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
+ } catch (Exception e) {
+ logger.error("Delete vpnMaps node failed for vpn : {} ", vpnid.getValue());
+ } finally {
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, vpnid.getValue());
+ }
+ }
}
private void updateVpnMaps(Uuid vpnId, String name, Uuid router, Uuid tenantId, List<Uuid> networks) {
VpnMapBuilder builder;
+ boolean isLockAcquired = false;
InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
.child(VpnMap.class, new VpnMapKey(vpnId)).build();
- Optional<VpnMap> optionalVpnMap = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
- vpnMapIdentifier);
- if (optionalVpnMap.isPresent()) {
- builder = new VpnMapBuilder(optionalVpnMap.get());
- } else {
- builder = new VpnMapBuilder().setKey(new VpnMapKey(vpnId)).setVpnId(vpnId);
- }
+ try {
+ Optional<VpnMap> optionalVpnMap = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
+ vpnMapIdentifier);
+ if (optionalVpnMap.isPresent()) {
+ builder = new VpnMapBuilder(optionalVpnMap.get());
+ } else {
+ builder = new VpnMapBuilder().setKey(new VpnMapKey(vpnId)).setVpnId(vpnId);
+ }
- if (name != null) {
- builder.setName(name);
- }
- if (tenantId != null) {
- builder.setTenantId(tenantId);
- }
- if (router != null) {
- builder.setRouterId(router);
- }
- if (networks != null) {
- List<Uuid> nwList = builder.getNetworkIds();
- if (nwList == null) {
- nwList = new ArrayList<Uuid>();
+ if (name != null) {
+ builder.setName(name);
+ }
+ if (tenantId != null) {
+ builder.setTenantId(tenantId);
+ }
+ if (router != null) {
+ builder.setRouterId(router);
+ }
+ if (networks != null) {
+ List<Uuid> nwList = builder.getNetworkIds();
+ if (nwList == null) {
+ nwList = new ArrayList<Uuid>();
+ }
+ nwList.addAll(networks);
+ builder.setNetworkIds(nwList);
}
- nwList.addAll(networks);
- builder.setNetworkIds(nwList);
- }
- logger.debug("Creating/Updating vpnMaps node: {} ", vpnId.getValue());
- MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier, builder.build());
- logger.debug("VPNMaps DS updated for VPN {} ", vpnId.getValue());
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
+ logger.debug("Creating/Updating vpnMaps node: {} ", vpnId.getValue());
+ MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier, builder.build());
+ logger.debug("VPNMaps DS updated for VPN {} ", vpnId.getValue());
+ } catch (Exception e) {
+ logger.error("UpdateVpnMaps failed for node: {} ", vpnId.getValue());
+ } finally {
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
+ }
+ }
}
- private void clearFromVpnMaps(Uuid id, Uuid router, List<Uuid> networks) {
+ private void clearFromVpnMaps(Uuid vpnId, Uuid routerId, List<Uuid> networkIds) {
+ boolean isLockAcquired = false;
InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
- .child(VpnMap.class, new VpnMapKey(id)).build();
+ .child(VpnMap.class, new VpnMapKey(vpnId)).build();
Optional<VpnMap> optionalVpnMap = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
vpnMapIdentifier);
if (optionalVpnMap.isPresent()) {
VpnMap vpnMap = optionalVpnMap.get();
VpnMapBuilder vpnMapBuilder = new VpnMapBuilder(vpnMap);
- if (router != null) {
- if (vpnMap.getNetworkIds() == null && router.equals(vpnMap.getVpnId())) {
- // remove entire node in case of internal VPN
- logger.debug("removing vpnMaps node: {} ", id);
- MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
+ if (routerId != null) {
+ if (vpnMap.getNetworkIds() == null && routerId.equals(vpnMap.getVpnId())) {
+ try {
+ // remove entire node in case of internal VPN
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
+ logger.debug("removing vpnMaps node: {} ", vpnId);
+ MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
+ } catch (Exception e) {
+ logger.error("Deletion of vpnMaps node failed for vpn {}", vpnId.getValue());
+ } finally {
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
+ }
+ }
return;
}
vpnMapBuilder.setRouterId(null);
}
- if (networks != null) {
+ if (networkIds != null) {
List<Uuid> vpnNw = vpnMap.getNetworkIds();
- for (Uuid nw : networks) {
+ for (Uuid nw : networkIds) {
vpnNw.remove(nw);
}
if (vpnNw.isEmpty()) {
- logger.debug("setting networks null in vpnMaps node: {} ", id.getValue());
+ logger.debug("setting networks null in vpnMaps node: {} ", vpnId.getValue());
vpnMapBuilder.setNetworkIds(null);
} else {
vpnMapBuilder.setNetworkIds(vpnNw);
}
}
- logger.debug("clearing from vpnMaps node: {} ", id.getValue());
- MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier, vpnMapBuilder.build());
+ try {
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
+ logger.debug("clearing from vpnMaps node: {} ", vpnId.getValue());
+ MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier, vpnMapBuilder.build
+ ());
+ } catch (Exception e) {
+ logger.error("Clearing from vpnMaps node failed for vpn {}", vpnId.getValue());
+ } finally {
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
+ }
+ }
} else {
- logger.error("VPN : {} not found", id.getValue());
+ logger.error("VPN : {} not found", vpnId.getValue());
}
- logger.debug("VPNMaps DS clear success for VPN {} ", id.getValue());
+ logger.debug("Clear from VPNMaps DS successful for VPN {} ", vpnId.getValue());
}
private void deleteVpnInstance(Uuid vpnId) {
-
+ boolean isLockAcquired = false;
InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).
child(VpnInstance.class, new VpnInstanceKey(vpnId.getValue())).build();
- logger.debug("removing vpn Instance {}", vpnId.getValue());
- MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier);
+ try {
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
+ logger.debug("Deleting vpnInstance {}", vpnId.getValue());
+ MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier);
+ } catch (Exception e) {
+ logger.error("Deletion of VPNInstance node failed for VPN {}", vpnId.getValue());
+ } finally {
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
+ }
+ }
}
-
protected void createVpnInterface(Uuid vpnId, Port port) {
-
+ boolean isLockAcquired = false;
if (vpnId == null || port == null) {
return;
}
- String portname = NeutronvpnUtils.uuidToTapPortName(port.getUuid());
- String name = new StringBuilder(portname).append(":0").toString();
+ String infName = port.getUuid().getValue();
List<Adjacency> adjList = new ArrayList<Adjacency>();
- InstanceIdentifier<VpnInterface> vpnIfIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
- child(VpnInterface.class, new VpnInterfaceKey(name)).build();
+ InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
+
// find router associated to vpn
Uuid routerId = NeutronvpnUtils.getRouterforVpn(broker, vpnId);
Router rtr = null;
adjList.add(vmAdj);
// create extra route adjacency
if (rtr != null && rtr.getRoutes() != null) {
- List<String> routeList = rtr.getRoutes();
- List<Adjacency> erAdjList = addAdjacencyforExtraRoute(routeList, false, name);
- if (erAdjList != null) {
+ List<Routes> routeList = rtr.getRoutes();
+ List<Adjacency> erAdjList = addAdjacencyforExtraRoute(routeList, false, infName);
+ if (erAdjList != null && !erAdjList.isEmpty()) {
adjList.addAll(erAdjList);
}
}
}
// create vpn-interface on this neutron port
Adjacencies adjs = new AdjacenciesBuilder().setAdjacency(adjList).build();
- VpnInterfaceBuilder vpnb = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(name)).
- setName(name).setVpnInstanceName(vpnId.getValue()).addAugmentation(Adjacencies.class, adjs);
+ VpnInterfaceBuilder vpnb = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(infName)).
+ setName(infName).setVpnInstanceName(vpnId.getValue()).addAugmentation(Adjacencies.class, adjs);
VpnInterface vpnIf = vpnb.build();
- NeutronvpnUtils.lockVpnInterface(lockManager, name);
try {
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
logger.debug("Creating vpn interface {}", vpnIf);
MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
} catch (Exception ex) {
- logger.error("Creation of vpninterface {} failed due to {}", name, ex);
+ logger.error("Creation of vpninterface {} failed due to {}", infName, ex);
} finally {
- NeutronvpnUtils.unlockVpnInterface(lockManager, name);
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, infName);
+ }
}
}
protected void deleteVpnInterface(Port port) {
if (port != null) {
- String pname = NeutronvpnUtils.uuidToTapPortName(port.getUuid());
- String name = new StringBuilder(pname).append(":0").toString();
- InstanceIdentifier<VpnInterface> vpnIfIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
- child(VpnInterface.class, new VpnInterfaceKey(name)).build();
+ boolean isLockAcquired = false;
+ String infName = port.getUuid().getValue();
+ InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
- NeutronvpnUtils.lockVpnInterface(lockManager, name);
try {
- logger.debug("Deleting vpn interface {}", name);
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
+ logger.debug("Deleting vpn interface {}", infName);
MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
} catch (Exception ex) {
- logger.error("Deletion of vpninterface {} failed due to {}", name, ex);
+ logger.error("Deletion of vpninterface {} failed due to {}", infName, ex);
} finally {
- NeutronvpnUtils.unlockVpnInterface(lockManager, name);
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, infName);
+ }
+ }
+ }
+ }
+
+ protected void updateVpnInterface(Uuid vpnId, Port port) {
+ if (vpnId == null || port == null) {
+ return;
+ }
+ boolean isLockAcquired = false;
+ String infName = port.getUuid().getValue();
+ InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
+ try {
+ Optional<VpnInterface> optionalVpnInterface = NeutronvpnUtils.read(broker, LogicalDatastoreType
+ .CONFIGURATION, vpnIfIdentifier);
+ if (optionalVpnInterface.isPresent()) {
+ VpnInterfaceBuilder vpnIfBuilder = new VpnInterfaceBuilder(optionalVpnInterface.get());
+ VpnInterface vpnIf = vpnIfBuilder.setVpnInstanceName(vpnId.getValue()).build();
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
+ logger.debug("Updating vpn interface {}", vpnIf);
+ MDSALUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
+ } else {
+ logger.error("VPN Interface {} not found", infName);
+ }
+ } catch (Exception ex) {
+ logger.error("Updation of vpninterface {} failed due to {}", infName, ex);
+ } finally {
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, infName);
}
}
}
vpn.getImportRT(), vpn.getExportRT(), vpn.getRouterId(), vpn.getNetworkIds());
} catch (Exception ex) {
msg = String.format("Creation of L3VPN failed for VPN %s", vpn.getId().getValue());
- logger.error(msg, ex.getMessage());
+ logger.error(msg, ex);
error = RpcResultBuilder.newError(ErrorType.APPLICATION, msg, ex.getMessage());
errorList.add(error);
failurecount++;
InstanceIdentifier.builder(VpnInstances.class).build();
Optional<VpnInstances> optionalVpns = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
vpnsIdentifier);
- if (optionalVpns.isPresent()) {
+ if (optionalVpns.isPresent() && optionalVpns.get().getVpnInstance() != null) {
for (VpnInstance vpn : optionalVpns.get().getVpnInstance()) {
- vpns.add(vpn);
+ // eliminating internal VPNs from getL3VPN output
+ if (vpn.getIpv4Family().getRouteDistinguisher() != null) {
+ vpns.add(vpn);
+ }
}
} else {
// No VPN present
for (VpnInstance vpnInstance : vpns) {
Uuid vpnId = new Uuid(vpnInstance.getVpnInstanceName());
// create VpnMaps id
- InstanceIdentifier<VpnMap> vpnMapIdentifier =
- InstanceIdentifier.builder(VpnMaps.class)
- .child(VpnMap.class, new VpnMapKey(vpnId)).build();
+ InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class).child(VpnMap
+ .class, new VpnMapKey(vpnId)).build();
L3vpnInstancesBuilder l3vpn = new L3vpnInstancesBuilder();
List<String> rd = Arrays.asList(vpnInstance.getIpv4Family().getRouteDistinguisher().split(","));
} catch (Exception ex) {
String message = String.format("GetL3VPN failed due to %s", ex.getMessage());
- logger.error(message);
+ logger.error(message, ex);
result.set(RpcResultBuilder.<GetL3VPNOutput>failed().withError(ErrorType.APPLICATION, message).build());
}
-
return result;
}
}
} catch (Exception ex) {
msg = String.format("Deletion of L3VPN failed when deleting for uuid %s", vpn.getValue());
- logger.error(msg, ex.getMessage());
+ logger.error(msg, ex);
error = RpcResultBuilder.newError(ErrorType.APPLICATION, msg, ex.getMessage());
errorList.add(error);
failurecount++;
protected void addSubnetToVpn(Uuid vpnId, Uuid subnet) {
logger.debug("Adding subnet {} to vpn {}", subnet.getValue(), vpnId.getValue());
- Subnetmap sn = updateSubnetNode(subnet, null, null, null, vpnId, null);
+ Subnetmap sn = updateSubnetNode(subnet, null, null, null, null, vpnId, null);
// Check if there are ports on this subnet and add corresponding vpn-interfaces
List<Uuid> portList = sn.getPortList();
if (portList != null) {
}
}
- protected List<Adjacency> addAdjacencyforExtraRoute(List<String> routeList, boolean rtrUp, String vpnifname) {
- try {
- List<Adjacency> adjList = new ArrayList<Adjacency>();
- for (String route : routeList) {
- // assuming extra route is strictly in the format "nexthop destination" > "10.1.1.10 40.0.1.0/24"
- String[] parts = route.split(" ");
- if (parts.length == 2) {
- String nextHop = parts[0];
- String destination = parts[1];
-
- String tapPortName = NeutronvpnUtils.getNeutronPortNamefromPortFixedIp(broker, nextHop);
- String ifname = new StringBuilder(tapPortName).append(":0").toString();
- logger.trace("Adding extra route with nexthop {}, destination {}, ifName {}", nextHop,
- destination, ifname);
- Adjacency erAdj = new AdjacencyBuilder().setIpAddress(destination).setNextHopIp(nextHop).setKey
- (new AdjacencyKey(destination)).build();
- if (rtrUp == false) {
- if (ifname.equals(vpnifname)) {
- adjList.add(erAdj);
- }
- continue;
+ protected void updateVpnForSubnet(Uuid vpnId, Uuid subnet) {
+ logger.debug("Updating VPN {} for subnet {}", vpnId.getValue(), subnet.getValue());
+ Subnetmap sn = updateSubnetNode(subnet, null, null, null, null, vpnId, null);
+ // 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()) {
+ logger.debug("Updating vpn-interface for port {}", port.getValue());
+ updateVpnInterface(vpnId, getNeutronPort(port));
+ }
+ }
+ }
+
+ protected List<Adjacency> addAdjacencyforExtraRoute(List<Routes> routeList, boolean rtrUp, String vpnifname) {
+ List<Adjacency> adjList = new ArrayList<Adjacency>();
+ for (Routes route : routeList) {
+ if (route != null && route.getNexthop() != null && route.getDestination() != null) {
+ boolean isLockAcquired = false;
+ String nextHop = String.valueOf(route.getNexthop().getValue());
+ String destination = String.valueOf(route.getDestination().getValue());
+
+ String infName = NeutronvpnUtils.getNeutronPortNamefromPortFixedIp(broker, nextHop);
+ logger.trace("Adding extra route with nexthop {}, destination {}, infName {}", nextHop,
+ destination, infName);
+ Adjacency erAdj = new AdjacencyBuilder().setIpAddress(destination).setNextHopIp(nextHop).setKey
+ (new AdjacencyKey(destination)).build();
+ if (rtrUp == false) {
+ if (infName.equals(vpnifname)) {
+ adjList.add(erAdj);
}
- InstanceIdentifier<VpnInterface> vpnIfIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
- child(VpnInterface.class, new VpnInterfaceKey(ifname)).build();
+ continue;
+ }
+ InstanceIdentifier<VpnInterface> vpnIfIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
+ child(VpnInterface.class, new VpnInterfaceKey(infName)).build();
+ try {
Optional<VpnInterface> optionalVpnInterface = NeutronvpnUtils.read(broker, LogicalDatastoreType
.CONFIGURATION, vpnIfIdentifier);
if (optionalVpnInterface.isPresent()) {
Adjacencies erAdjs = new AdjacenciesBuilder().setAdjacency(Arrays.asList(erAdj)).build();
- VpnInterface vpnIf = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(ifname))
+ VpnInterface vpnIf = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(infName))
.addAugmentation(Adjacencies.class, erAdjs).build();
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
+ logger.debug("Adding extra route {}", route);
MDSALUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
- logger.trace("extra route {} added successfully", route);
} else {
logger.error("VM adjacency for interface {} not present ; cannot add extra route adjacency",
- ifname);
+ infName);
+ }
+ } catch (Exception e) {
+ logger.error("exception in adding extra route: {}" + e);
+ } finally {
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, infName);
}
- } else {
- logger.error("Incorrect input received for extra route. {}", parts);
}
+ } else {
+ logger.error("Incorrect input received for extra route. {}", route);
}
- return adjList;
- } catch (Exception e) {
- logger.error("exception in adding extra route: {}" + e);
}
- return null;
+ return adjList;
}
- protected void removeAdjacencyforExtraRoute(List<String> routeList) {
- try {
- for (String route : routeList) {
- // assuming extra route is strictly in the format "nexthop destination" > "10.1.1.10 40.0.1.0/24"
- String[] parts = route.split(" ");
- if (parts.length == 2) {
- String nextHop = parts[0];
- String destination = parts[1];
-
- String tapPortName = NeutronvpnUtils.getNeutronPortNamefromPortFixedIp(broker, nextHop);
- String ifname = new StringBuilder(tapPortName).append(":0").toString();
- logger.trace("Removing extra route with nexthop {}, destination {}, ifName {}", nextHop,
- destination, ifname);
- InstanceIdentifier<Adjacency> adjacencyIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
- child(VpnInterface.class, new VpnInterfaceKey(ifname)).augmentation(Adjacencies.class)
- .child(Adjacency.class, new AdjacencyKey(destination)).build();
+ protected void removeAdjacencyforExtraRoute(List<Routes> routeList) {
+ for (Routes route : routeList) {
+ if (route != null && route.getNexthop() != null && route.getDestination() != null) {
+ boolean isLockAcquired = false;
+ String nextHop = String.valueOf(route.getNexthop().getValue());
+ String destination = String.valueOf(route.getDestination().getValue());
+
+ String infName = NeutronvpnUtils.getNeutronPortNamefromPortFixedIp(broker, nextHop);
+ logger.trace("Removing extra route with nexthop {}, destination {}, infName {}", nextHop,
+ destination, infName);
+ InstanceIdentifier<Adjacency> adjacencyIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
+ child(VpnInterface.class, new VpnInterfaceKey(infName)).augmentation(Adjacencies.class)
+ .child(Adjacency.class, new AdjacencyKey(destination)).build();
+ try {
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier);
logger.trace("extra route {} deleted successfully", route);
- } else {
- logger.error("Incorrect input received for extra route. {}", parts);
+ } catch (Exception e) {
+ logger.error("exception in deleting extra route: {}" + e);
+ } finally {
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, infName);
+ }
}
+ } else {
+ logger.error("Incorrect input received for extra route. {}", route);
}
- } catch (Exception e) {
- logger.error("exception in deleting extra route: {}" + e);
}
}
}
protected void removeL3Vpn(Uuid id) {
- // read VPN networks
+ // read VPNMaps
VpnMap vpnMap = NeutronvpnUtils.getVpnMap(broker, id);
Uuid router = vpnMap.getRouterId();
// dissociate router
}
}
- protected void associateRouterToVpn(Uuid vpn, Uuid router) {
-
- // remove existing Router-VPN
- if (!vpn.equals(router)) {
- removeL3Vpn(router);
- }
- updateVpnMaps(vpn, null, router, null, null);
-
- List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, router);
- logger.debug("Adding subnets...");
- for (Uuid subnet : routerSubnets) {
- addSubnetToVpn(vpn, subnet);
+ protected void associateRouterToVpn(Uuid vpnId, Uuid routerId) {
+ updateVpnMaps(vpnId, null, routerId, null, null);
+ List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
+ if (!vpnId.equals(routerId)) {
+ logger.debug("Updating association of subnets to external vpn {}", vpnId.getValue());
+ if (routerSubnets != null) {
+ for (Uuid subnetId : routerSubnets) {
+ updateVpnForSubnet(vpnId, subnetId);
+ }
+ }
+ } else {
+ logger.debug("Adding subnets to internal vpn {}", vpnId.getValue());
+ for (Uuid subnet : routerSubnets) {
+ addSubnetToVpn(vpnId, subnet);
+ }
}
}
- protected void dissociateRouterFromVpn(Uuid vpn, Uuid router) {
- clearFromVpnMaps(vpn, router, null);
+ protected void dissociateRouterFromVpn(Uuid vpnId, Uuid routerId) {
- // fetching sn from SubnetmapDS for internal VPN because sn already deleted from RouterIf DS on router deletion
- List<Uuid> routerSubnets = (vpn.equals(router)) ? getSubnetsforVpn(vpn) :
- NeutronvpnUtils.getNeutronRouterSubnetIds(broker, router);
-
- logger.debug("dissociateRouter vpn {} router {} Removing subnets...", vpn.getValue(), router.getValue());
+ List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
if (routerSubnets != null) {
- for (Uuid subnet : routerSubnets) {
- removeSubnetFromVpn(vpn, subnet);
+ for (Uuid subnetId : routerSubnets) {
+ logger.debug("Updating association of subnets to internal vpn {}", routerId.getValue());
+ updateVpnForSubnet(routerId, subnetId);
}
}
- // create Router-VPN for this router
- if (!vpn.equals(router)) {
- logger.debug("Re-creating vpn-router...");
- createL3Vpn(router, null, null, null, null, null, router, null);
- }
+ clearFromVpnMaps(vpnId, routerId, null);
}
protected List<String> associateNetworksToVpn(Uuid vpn, List<Uuid> networks) {
} catch (Exception ex) {
String message = String.format("associate Networks to vpn %s failed due to %s", input.getVpnId().getValue(),
ex.getMessage());
- logger.error(message);
+ logger.error(message, ex);
result.set(RpcResultBuilder.<AssociateNetworksOutput>failed().withError(ErrorType.APPLICATION, message)
.build());
}
} catch (Exception ex) {
String message = String.format("associate router %s to vpn %s failed due to %s", routerId.getValue(),
vpnId.getValue(), ex.getMessage());
- logger.error(message);
+ logger.error(message, ex);
result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, message).build());
}
logger.debug("associateRouter returns..");
returnMsg.append("VPN not found : ").append(vpnId.getValue());
}
if (returnMsg.length() != 0) {
- String message = String.format("disssociate Networks to vpn %s failed due to %s", vpnId.getValue(),
+ String message = String.format("dissociate Networks to vpn %s failed due to %s", vpnId.getValue(),
returnMsg);
logger.error(message);
String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: " +
} catch (Exception ex) {
String message = String.format("dissociate Networks to vpn %s failed due to %s", input.getVpnId().
getValue(), ex.getMessage());
- logger.error(message);
+ logger.error(message, ex);
result.set(RpcResultBuilder.<DissociateNetworksOutput>failed().withError(ErrorType.APPLICATION, message)
.build());
}
returnMsg.append("VPN not found : ").append(vpnId.getValue());
}
if (returnMsg.length() != 0) {
- String message = String.format("disssociate router %s to vpn %s failed due to %s", routerId.getValue(),
+ String message = String.format("dissociate router %s to vpn %s failed due to %s", routerId.getValue(),
vpnId.getValue(), returnMsg);
logger.error(message);
String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: " +
} catch (Exception ex) {
String message = String.format("disssociate router %s to vpn %s failed due to %s", routerId.getValue(),
vpnId.getValue(), ex.getMessage());
- logger.error(message);
+ logger.error(message, ex);
result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, message).build());
}
logger.debug("dissociateRouter returns..");
return result;
}
+ protected void handleNeutronRouterDeleted(Uuid routerId, List<Uuid> routerSubnetIds) {
+ // check if the router is associated to some VPN
+ Uuid vpnId = NeutronvpnUtils.getVpnForRouter(broker, routerId, true);
+ if (vpnId != null) {
+ // remove existing external vpn interfaces
+ for (Uuid subnetId : routerSubnetIds) {
+ removeSubnetFromVpn(vpnId, subnetId);
+ }
+ clearFromVpnMaps(vpnId, routerId, null);
+ } else {
+ // remove existing internal vpn interfaces
+ for (Uuid subnetId : routerSubnetIds) {
+ removeSubnetFromVpn(routerId, subnetId);
+ }
+ }
+ // delete entire vpnMaps node for internal VPN
+ deleteVpnMapsNode(routerId);
+
+ // delete vpn-instance for internal VPN
+ deleteVpnInstance(routerId);
+ }
+
protected Subnet getNeutronSubnet(Uuid subnetId) {
InstanceIdentifier<Subnet> inst = InstanceIdentifier.create(Neutron.class).
child(Subnets.class).child(Subnet.class, new SubnetKey(subnetId));
InstanceIdentifier<Subnetmaps> subnetmapsid = InstanceIdentifier.builder(Subnetmaps.class).build();
Optional<Subnetmaps> subnetmaps = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
subnetmapsid);
- if (subnetmaps.isPresent()) {
- Subnetmaps smaps = subnetmaps.get();
- List<Subnetmap> subnetMapList = smaps.getSubnetmap();
+ if (subnetmaps.isPresent() && subnetmaps.get().getSubnetmap() != null) {
+ List<Subnetmap> subnetMapList = subnetmaps.get().getSubnetmap();
for (Subnetmap subnetMap : subnetMapList) {
if (subnetMap.getVpnId() != null && subnetMap.getVpnId().equals(vpnid)) {
subnets.add(subnetMap.getId());
public List<String> showNeutronPortsCLI() {
List<String> result = new ArrayList<String>();
- result.add(String.format(" %-22s %-22s %-22s %-6s ", "PortName", "Mac Address", "IP Address",
+ result.add(String.format(" %-34s %-22s %-22s %-6s ", "PortName", "Mac Address", "IP Address",
"Prefix Length"));
result.add("---------------------------------------------------------------------------------------");
InstanceIdentifier<Ports> portidentifier = InstanceIdentifier.create(Neutron.class).child(Ports.class);
try {
Optional<Ports> ports = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, portidentifier);
- if (ports.isPresent()) {
+ if (ports.isPresent() && ports.get().getPort() != null) {
List<Port> portList = ports.get().getPort();
for (Port port : portList) {
- result.add(String.format(" %-22s %-22s %-22s %-6s ", NeutronvpnUtils.uuidToTapPortName(port
- .getUuid()), port.getMacAddress(), port.getFixedIps().get(0).getIpAddress().getIpv4Address()
- .getValue(), NeutronvpnUtils.getIPPrefixFromPort(broker, port)));
+ result.add(String.format(" %-34s %-22s %-22s %-6s ", port.getUuid().getValue(), port
+ .getMacAddress(), port.getFixedIps().get(0).getIpAddress().getIpv4Address().getValue(),
+ NeutronvpnUtils.getIPPrefixFromPort(broker, port)));
}
}
} catch (Exception e) {
- logger.trace("Failed to retrieve neutronPorts info : ", e);
+ logger.error("Failed to retrieve neutronPorts info : ", e);
System.out.println("Failed to retrieve neutronPorts info : " + e.getMessage());
}
return result;
}
}
} catch (InterruptedException | ExecutionException e) {
- logger.trace("error getting VPN info : ", e);
+ logger.error("error getting VPN info : ", e);
System.out.println("error getting VPN info : " + e.getMessage());
}
return result;