2 * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.vpnservice.neutronvpn;
10 import com.google.common.base.Optional;
11 import com.google.common.util.concurrent.SettableFuture;
12 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
13 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
14 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
15 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
16 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
17 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
18 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.VpnTargets;
19 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.VpnTargetsBuilder;
20 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTarget;
21 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets
23 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTargetKey;
24 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
25 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceBuilder;
26 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
27 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.vpn.instance
29 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
30 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
31 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.Adjacencies;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.AdjacenciesBuilder;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.Adjacency;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.AdjacencyBuilder;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.AdjacencyKey;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.l3.attributes.Routes;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.Subnets;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.SubnetKey;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.lockmanager.rev150819.LockManagerService;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.AssociateNetworksInput;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.AssociateNetworksOutput;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.AssociateNetworksOutputBuilder;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.AssociateRouterInput;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.CreateL3VPNInput;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.CreateL3VPNOutput;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.CreateL3VPNOutputBuilder;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DeleteL3VPNInput;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DeleteL3VPNOutput;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DeleteL3VPNOutputBuilder;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DissociateNetworksInput;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DissociateNetworksOutput;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DissociateNetworksOutputBuilder;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DissociateRouterInput;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.GetFixedIPsForNeutronPortInput;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.GetFixedIPsForNeutronPortOutput;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602
67 .GetFixedIPsForNeutronPortOutputBuilder;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.GetL3VPNInput;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.GetL3VPNInputBuilder;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.GetL3VPNOutput;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.GetL3VPNOutputBuilder;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.L3vpnInstance;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.NeutronvpnService;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.Subnetmaps;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.VpnMaps;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.createl3vpn.input.L3vpn;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.getl3vpn.output.L3vpnInstances;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.getl3vpn.output
79 .L3vpnInstancesBuilder;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.subnetmaps.Subnetmap;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.subnetmaps.SubnetmapBuilder;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.vpnmaps.VpnMap;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.vpnmaps.VpnMapBuilder;
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.vpnmaps.VpnMapKey;
86 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
87 import org.opendaylight.yangtools.yang.common.RpcError;
88 import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
89 import org.opendaylight.yangtools.yang.common.RpcResult;
90 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
91 import org.slf4j.Logger;
92 import org.slf4j.LoggerFactory;
93 import java.util.ArrayList;
94 import java.util.Arrays;
95 import java.util.List;
96 import java.util.concurrent.ExecutionException;
97 import java.util.concurrent.Future;
99 public class NeutronvpnManager implements NeutronvpnService, AutoCloseable {
101 private static final Logger logger = LoggerFactory.getLogger(NeutronvpnManager.class);
102 private final DataBroker broker;
103 private LockManagerService lockManager;
104 IMdsalApiManager mdsalUtil;
107 * @param db - dataBroker reference
108 * @param mdsalManager - MDSAL Util API access
110 public NeutronvpnManager(final DataBroker db, IMdsalApiManager mdsalManager) {
112 mdsalUtil = mdsalManager;
115 public void setLockManager(LockManagerService lockManager) {
116 this.lockManager = lockManager;
120 public void close() throws Exception {
121 logger.info("Neutron VPN Manager Closed");
124 protected Subnetmap updateSubnetNode(Uuid subnetId, String subnetIp, Uuid tenantId, Uuid networkId, Uuid routerId,
125 Uuid vpnId, Uuid portId) {
126 Subnetmap subnetmap = null;
127 SubnetmapBuilder builder = null;
128 boolean isLockAcquired = false;
129 InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
130 child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
132 Optional<Subnetmap> sn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, id);
133 logger.debug("updating Subnet :read: ");
134 if (sn.isPresent()) {
135 builder = new SubnetmapBuilder(sn.get());
136 logger.debug("updating Subnet :existing: ");
138 builder = new SubnetmapBuilder().setKey(new SubnetmapKey(subnetId)).setId(subnetId);
139 logger.debug("updating Subnet :new: ");
142 if (subnetIp != null) {
143 builder.setSubnetIp(subnetIp);
145 if (routerId != null) {
146 builder.setRouterId(routerId);
148 if (networkId != null) {
149 builder.setNetworkId(networkId);
152 builder.setVpnId(vpnId);
154 if (tenantId != null) {
155 builder.setTenantId(tenantId);
158 if (portId != null) {
159 List<Uuid> portList = builder.getPortList();
160 if (portList == null) {
161 portList = new ArrayList<Uuid>();
163 portList.add(portId);
164 builder.setPortList(portList);
167 subnetmap = builder.build();
168 isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
169 logger.debug("Creating/Updating subnetMap node: {} ", subnetId.getValue());
170 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
171 } catch (Exception e) {
172 logger.error("Updation of subnetMap failed for node: {}", subnetId.getValue());
174 if (isLockAcquired) {
175 NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
181 protected Subnetmap removeFromSubnetNode(Uuid subnetId, Uuid networkId, Uuid routerId, Uuid vpnId, Uuid portId) {
182 Subnetmap subnetmap = null;
183 boolean isLockAcquired = false;
184 InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
185 child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
187 Optional<Subnetmap> sn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, id);
188 if (sn.isPresent()) {
189 SubnetmapBuilder builder = new SubnetmapBuilder(sn.get());
190 if (routerId != null) {
191 builder.setRouterId(null);
193 if (networkId != null) {
194 builder.setNetworkId(null);
197 builder.setVpnId(null);
199 if (portId != null && builder.getPortList() != null) {
200 List<Uuid> portList = builder.getPortList();
201 portList.remove(portId);
202 builder.setPortList(portList);
205 subnetmap = builder.build();
206 isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
207 logger.debug("Removing from existing subnetmap node: {} ", subnetId.getValue());
208 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
210 logger.warn("removing from non-existing subnetmap node: {} ", subnetId.getValue());
212 } catch (Exception e) {
213 logger.error("Removal from subnetmap failed for node: {}", subnetId.getValue());
215 if (isLockAcquired) {
216 NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
222 protected void deleteSubnetMapNode(Uuid subnetId) {
223 boolean isLockAcquired = false;
224 InstanceIdentifier<Subnetmap> subnetMapIdentifier = InstanceIdentifier.builder(Subnetmaps.class)
225 .child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
226 logger.debug("removing subnetMap node: {} ", subnetId.getValue());
228 isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
229 MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, subnetMapIdentifier);
230 } catch (Exception e) {
231 logger.error("Delete subnetMap node failed for subnet : {} ", subnetId.getValue());
233 if (isLockAcquired) {
234 NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
239 private void updateVpnInstanceNode(String vpnName, List<String> rd, List<String> irt, List<String> ert) {
241 VpnInstanceBuilder builder = null;
242 List<VpnTarget> vpnTargetList = new ArrayList<VpnTarget>();
243 boolean isLockAcquired = false;
244 InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).
245 child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
247 Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
249 logger.debug("Creating/Updating a new vpn-instance node: {} ", vpnName);
250 if (optionalVpn.isPresent()) {
251 builder = new VpnInstanceBuilder(optionalVpn.get());
252 logger.debug("updating existing vpninstance node");
254 builder = new VpnInstanceBuilder().setKey(new VpnInstanceKey(vpnName)).setVpnInstanceName(vpnName);
256 if (irt != null && !irt.isEmpty()) {
257 if (ert != null && !ert.isEmpty()) {
258 List<String> commonRT = new ArrayList<String>(irt);
259 commonRT.retainAll(ert);
261 for (String common : commonRT) {
264 VpnTarget vpnTarget = new VpnTargetBuilder().setKey(new VpnTargetKey(common)).setVrfRTValue
265 (common).setVrfRTType(VpnTarget.VrfRTType.Both).build();
266 vpnTargetList.add(vpnTarget);
269 for (String importRT : irt) {
270 VpnTarget vpnTarget = new VpnTargetBuilder().setKey(new VpnTargetKey(importRT)).setVrfRTValue
271 (importRT).setVrfRTType(VpnTarget.VrfRTType.ImportExtcommunity).build();
272 vpnTargetList.add(vpnTarget);
276 if (ert != null && !ert.isEmpty()) {
277 for (String exportRT : ert) {
278 VpnTarget vpnTarget = new VpnTargetBuilder().setKey(new VpnTargetKey(exportRT)).setVrfRTValue
279 (exportRT).setVrfRTType(VpnTarget.VrfRTType.ExportExtcommunity).build();
280 vpnTargetList.add(vpnTarget);
284 VpnTargets vpnTargets = new VpnTargetsBuilder().setVpnTarget(vpnTargetList).build();
286 Ipv4FamilyBuilder ipv4vpnBuilder = new Ipv4FamilyBuilder().setVpnTargets(vpnTargets);
288 if (rd != null && !rd.isEmpty()) {
289 ipv4vpnBuilder.setRouteDistinguisher(rd.get(0));
292 VpnInstance newVpn = builder.setIpv4Family(ipv4vpnBuilder.build()).build();
293 isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnName);
294 logger.debug("Creating/Updating vpn-instance for {} ", vpnName);
295 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier, newVpn);
296 } catch (Exception e) {
297 logger.error("Update VPN Instance node failed for node: {} {} {} {}", vpnName, rd, irt, ert);
299 if (isLockAcquired) {
300 NeutronvpnUtils.unlock(lockManager, vpnName);
305 private void deleteVpnMapsNode(Uuid vpnid) {
306 boolean isLockAcquired = false;
307 InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
308 .child(VpnMap.class, new VpnMapKey(vpnid)).build();
309 logger.debug("removing vpnMaps node: {} ", vpnid.getValue());
311 isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnid.getValue());
312 MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
313 } catch (Exception e) {
314 logger.error("Delete vpnMaps node failed for vpn : {} ", vpnid.getValue());
316 if (isLockAcquired) {
317 NeutronvpnUtils.unlock(lockManager, vpnid.getValue());
322 private void updateVpnMaps(Uuid vpnId, String name, Uuid router, Uuid tenantId, List<Uuid> networks) {
323 VpnMapBuilder builder;
324 boolean isLockAcquired = false;
325 InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
326 .child(VpnMap.class, new VpnMapKey(vpnId)).build();
328 Optional<VpnMap> optionalVpnMap = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
330 if (optionalVpnMap.isPresent()) {
331 builder = new VpnMapBuilder(optionalVpnMap.get());
333 builder = new VpnMapBuilder().setKey(new VpnMapKey(vpnId)).setVpnId(vpnId);
337 builder.setName(name);
339 if (tenantId != null) {
340 builder.setTenantId(tenantId);
342 if (router != null) {
343 builder.setRouterId(router);
345 if (networks != null) {
346 List<Uuid> nwList = builder.getNetworkIds();
347 if (nwList == null) {
348 nwList = new ArrayList<Uuid>();
350 nwList.addAll(networks);
351 builder.setNetworkIds(nwList);
354 isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
355 logger.debug("Creating/Updating vpnMaps node: {} ", vpnId.getValue());
356 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier, builder.build());
357 logger.debug("VPNMaps DS updated for VPN {} ", vpnId.getValue());
358 } catch (Exception e) {
359 logger.error("UpdateVpnMaps failed for node: {} ", vpnId.getValue());
361 if (isLockAcquired) {
362 NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
367 private void clearFromVpnMaps(Uuid vpnId, Uuid routerId, List<Uuid> networkIds) {
368 boolean isLockAcquired = false;
369 InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
370 .child(VpnMap.class, new VpnMapKey(vpnId)).build();
371 Optional<VpnMap> optionalVpnMap = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
373 if (optionalVpnMap.isPresent()) {
374 VpnMap vpnMap = optionalVpnMap.get();
375 VpnMapBuilder vpnMapBuilder = new VpnMapBuilder(vpnMap);
376 if (routerId != null) {
377 if (vpnMap.getNetworkIds() == null && routerId.equals(vpnMap.getVpnId())) {
379 // remove entire node in case of internal VPN
380 isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
381 logger.debug("removing vpnMaps node: {} ", vpnId);
382 MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
383 } catch (Exception e) {
384 logger.error("Deletion of vpnMaps node failed for vpn {}", vpnId.getValue());
386 if (isLockAcquired) {
387 NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
392 vpnMapBuilder.setRouterId(null);
394 if (networkIds != null) {
395 List<Uuid> vpnNw = vpnMap.getNetworkIds();
396 for (Uuid nw : networkIds) {
399 if (vpnNw.isEmpty()) {
400 logger.debug("setting networks null in vpnMaps node: {} ", vpnId.getValue());
401 vpnMapBuilder.setNetworkIds(null);
403 vpnMapBuilder.setNetworkIds(vpnNw);
408 isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
409 logger.debug("clearing from vpnMaps node: {} ", vpnId.getValue());
410 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier, vpnMapBuilder.build
412 } catch (Exception e) {
413 logger.error("Clearing from vpnMaps node failed for vpn {}", vpnId.getValue());
415 if (isLockAcquired) {
416 NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
420 logger.error("VPN : {} not found", vpnId.getValue());
422 logger.debug("Clear from VPNMaps DS successful for VPN {} ", vpnId.getValue());
425 private void deleteVpnInstance(Uuid vpnId) {
426 boolean isLockAcquired = false;
427 InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).
428 child(VpnInstance.class, new VpnInstanceKey(vpnId.getValue())).build();
430 isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
431 logger.debug("Deleting vpnInstance {}", vpnId.getValue());
432 MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier);
433 } catch (Exception e) {
434 logger.error("Deletion of VPNInstance node failed for VPN {}", vpnId.getValue());
436 if (isLockAcquired) {
437 NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
442 protected void createVpnInterface(Uuid vpnId, Port port) {
443 boolean isLockAcquired = false;
444 if (vpnId == null || port == null) {
447 String infName = port.getUuid().getValue();
448 List<Adjacency> adjList = new ArrayList<Adjacency>();
449 InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
451 // find router associated to vpn
452 Uuid routerId = NeutronvpnUtils.getRouterforVpn(broker, vpnId);
454 if (routerId != null) {
455 rtr = NeutronvpnUtils.getNeutronRouter(broker, routerId);
457 // find all subnets to which this port is associated
458 List<FixedIps> ips = port.getFixedIps();
459 // create adjacency list
460 for (FixedIps ip : ips) {
461 // create vm adjacency
462 StringBuilder IpPrefixBuild = new StringBuilder(ip.getIpAddress().getIpv4Address().getValue());
463 String IpPrefix = IpPrefixBuild.append("/32").toString();
464 Adjacency vmAdj = new AdjacencyBuilder().setKey(new AdjacencyKey(IpPrefix)).setIpAddress(IpPrefix)
465 .setMacAddress(port.getMacAddress()).build();
467 // create extra route adjacency
468 if (rtr != null && rtr.getRoutes() != null) {
469 List<Routes> routeList = rtr.getRoutes();
470 List<Adjacency> erAdjList = addAdjacencyforExtraRoute(routeList, false, infName);
471 if (erAdjList != null && !erAdjList.isEmpty()) {
472 adjList.addAll(erAdjList);
476 // create vpn-interface on this neutron port
477 Adjacencies adjs = new AdjacenciesBuilder().setAdjacency(adjList).build();
478 VpnInterfaceBuilder vpnb = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(infName)).
479 setName(infName).setVpnInstanceName(vpnId.getValue()).addAugmentation(Adjacencies.class, adjs);
480 VpnInterface vpnIf = vpnb.build();
483 isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
484 logger.debug("Creating vpn interface {}", vpnIf);
485 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
486 } catch (Exception ex) {
487 logger.error("Creation of vpninterface {} failed due to {}", infName, ex);
489 if (isLockAcquired) {
490 NeutronvpnUtils.unlock(lockManager, infName);
495 protected void deleteVpnInterface(Port port) {
498 boolean isLockAcquired = false;
499 String infName = port.getUuid().getValue();
500 InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
503 isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
504 logger.debug("Deleting vpn interface {}", infName);
505 MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
506 } catch (Exception ex) {
507 logger.error("Deletion of vpninterface {} failed due to {}", infName, ex);
509 if (isLockAcquired) {
510 NeutronvpnUtils.unlock(lockManager, infName);
516 protected void updateVpnInterface(Uuid vpnId, Port port) {
517 if (vpnId == null || port == null) {
520 boolean isLockAcquired = false;
521 String infName = port.getUuid().getValue();
522 InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
524 Optional<VpnInterface> optionalVpnInterface = NeutronvpnUtils.read(broker, LogicalDatastoreType
525 .CONFIGURATION, vpnIfIdentifier);
526 if (optionalVpnInterface.isPresent()) {
527 VpnInterfaceBuilder vpnIfBuilder = new VpnInterfaceBuilder(optionalVpnInterface.get());
528 VpnInterface vpnIf = vpnIfBuilder.setVpnInstanceName(vpnId.getValue()).build();
529 isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
530 logger.debug("Updating vpn interface {}", vpnIf);
531 MDSALUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
533 logger.error("VPN Interface {} not found", infName);
535 } catch (Exception ex) {
536 logger.error("Updation of vpninterface {} failed due to {}", infName, ex);
538 if (isLockAcquired) {
539 NeutronvpnUtils.unlock(lockManager, infName);
544 public void createL3Vpn(Uuid vpn, String name, Uuid tenant, List<String> rd, List<String> irt, List<String> ert,
545 Uuid router, List<Uuid> networks) {
547 // Update VPN Instance node
548 updateVpnInstanceNode(vpn.getValue(), rd, irt, ert);
550 // Update local vpn-subnet DS
551 updateVpnMaps(vpn, name, router, tenant, networks);
553 if (router != null) {
554 associateRouterToVpn(vpn, router);
556 if (networks != null) {
557 associateNetworksToVpn(vpn, networks);
562 public Future<RpcResult<CreateL3VPNOutput>> createL3VPN(CreateL3VPNInput input) {
564 CreateL3VPNOutputBuilder opBuilder = new CreateL3VPNOutputBuilder();
565 SettableFuture<RpcResult<CreateL3VPNOutput>> result = SettableFuture.create();
566 List<RpcError> errorList = new ArrayList<RpcError>();
567 int failurecount = 0;
568 int warningcount = 0;
570 List<L3vpn> vpns = input.getL3vpn();
571 for (L3vpn vpn : vpns) {
572 RpcError error = null;
574 if (vpn.getRouteDistinguisher() == null || vpn.getImportRT() == null || vpn.getExportRT() == null) {
575 msg = String.format("Creation of L3VPN failed for VPN %s due to absence of RD/iRT/eRT input",
576 vpn.getId().getValue());
578 error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
579 errorList.add(error);
583 if (vpn.getRouteDistinguisher().size() > 1) {
584 msg = String.format("Creation of L3VPN failed for VPN %s due to multiple RD input %s",
585 vpn.getId().getValue(), vpn.getRouteDistinguisher());
587 error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
588 errorList.add(error);
592 if (vpn.getRouterId() != null) {
593 if (NeutronvpnUtils.getNeutronRouter(broker, vpn.getRouterId()) == null) {
594 msg = String.format("Creation of L3VPN failed for VPN %s due to router not found %s",
595 vpn.getId().getValue(), vpn.getRouterId().getValue());
597 error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
598 errorList.add(error);
602 Uuid vpnId = NeutronvpnUtils.getVpnForRouter(broker, vpn.getRouterId(), true);
604 msg = String.format("Creation of L3VPN failed for VPN %s due to router %s already associated to " +
605 "another VPN %s", vpn.getId().getValue(), vpn.getRouterId().getValue(), vpnId.getValue());
607 error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
608 errorList.add(error);
613 if (vpn.getNetworkIds() != null) {
614 for (Uuid nw : vpn.getNetworkIds()) {
615 Network network = NeutronvpnUtils.getNeutronNetwork(broker, nw);
616 Uuid vpnId = NeutronvpnUtils.getVpnForNetwork(broker, nw);
617 if (network == null) {
618 msg = String.format("Creation of L3VPN failed for VPN %s due to network not found %s",
619 vpn.getId().getValue(), nw.getValue());
621 error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
622 errorList.add(error);
624 } else if (vpnId != null) {
625 msg = String.format("Creation of L3VPN failed for VPN %s due to network %s already associated" +
626 " to another VPN %s", vpn.getId().getValue(), nw.getValue(), vpnId.getValue());
628 error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
629 errorList.add(error);
638 createL3Vpn(vpn.getId(), vpn.getName(), vpn.getTenantId(), vpn.getRouteDistinguisher(),
639 vpn.getImportRT(), vpn.getExportRT(), vpn.getRouterId(), vpn.getNetworkIds());
640 } catch (Exception ex) {
641 msg = String.format("Creation of L3VPN failed for VPN %s", vpn.getId().getValue());
642 logger.error(msg, ex);
643 error = RpcResultBuilder.newError(ErrorType.APPLICATION, msg, ex.getMessage());
644 errorList.add(error);
648 // if at least one succeeds; result is success
649 // if none succeeds; result is failure
650 if (failurecount + warningcount == vpns.size()) {
651 result.set(RpcResultBuilder.<CreateL3VPNOutput>failed().withRpcErrors(errorList).build());
653 List<String> errorResponseList = new ArrayList<>();
654 if (!errorList.isEmpty()) {
655 for (RpcError rpcError : errorList) {
656 String errorResponse = String.format("ErrorType: " + rpcError.getErrorType() + ", " + "ErrorTag: " +
657 rpcError.getTag() + ", " + "ErrorMessage: " + rpcError.getMessage());
658 errorResponseList.add(errorResponse);
661 errorResponseList.add("Operation successful with no errors");
663 opBuilder.setResponse(errorResponseList);
664 result.set(RpcResultBuilder.<CreateL3VPNOutput>success().withResult(opBuilder.build()).build());
670 public Future<RpcResult<GetL3VPNOutput>> getL3VPN(GetL3VPNInput input) {
672 GetL3VPNOutputBuilder opBuilder = new GetL3VPNOutputBuilder();
673 SettableFuture<RpcResult<GetL3VPNOutput>> result = SettableFuture.create();
674 Uuid inputVpnId = input.getId();
675 List<VpnInstance> vpns = new ArrayList<VpnInstance>();
678 if (inputVpnId == null) {
680 InstanceIdentifier<VpnInstances> vpnsIdentifier =
681 InstanceIdentifier.builder(VpnInstances.class).build();
682 Optional<VpnInstances> optionalVpns = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
684 if (optionalVpns.isPresent() && optionalVpns.get().getVpnInstance() != null) {
685 for (VpnInstance vpn : optionalVpns.get().getVpnInstance()) {
686 // eliminating internal VPNs from getL3VPN output
687 if (vpn.getIpv4Family().getRouteDistinguisher() != null) {
693 result.set(RpcResultBuilder.<GetL3VPNOutput>failed()
694 .withWarning(ErrorType.PROTOCOL, "", "No VPN is present").build());
698 String name = inputVpnId.getValue();
699 InstanceIdentifier<VpnInstance> vpnIdentifier =
700 InstanceIdentifier.builder(VpnInstances.class)
701 .child(VpnInstance.class, new VpnInstanceKey(name)).build();
702 // read VpnInstance Info
703 Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
705 if (optionalVpn.isPresent()) {
706 vpns.add(optionalVpn.get());
708 String message = String.format("GetL3VPN failed because VPN %s is not present", name);
709 logger.error(message);
710 result.set(RpcResultBuilder.<GetL3VPNOutput>failed()
711 .withWarning(ErrorType.PROTOCOL, "invalid-value", message).build());
714 List<L3vpnInstances> l3vpnList = new ArrayList<L3vpnInstances>();
715 for (VpnInstance vpnInstance : vpns) {
716 Uuid vpnId = new Uuid(vpnInstance.getVpnInstanceName());
718 InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class).child(VpnMap
719 .class, new VpnMapKey(vpnId)).build();
720 L3vpnInstancesBuilder l3vpn = new L3vpnInstancesBuilder();
722 List<String> rd = Arrays.asList(vpnInstance.getIpv4Family().getRouteDistinguisher().split(","));
723 List<VpnTarget> vpnTargetList = vpnInstance.getIpv4Family().getVpnTargets().getVpnTarget();
725 List<String> ertList = new ArrayList<String>();
726 List<String> irtList = new ArrayList<String>();
728 for (VpnTarget vpnTarget : vpnTargetList) {
729 if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ExportExtcommunity) {
730 ertList.add(vpnTarget.getVrfRTValue());
732 if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ImportExtcommunity) {
733 irtList.add(vpnTarget.getVrfRTValue());
735 if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.Both) {
736 ertList.add(vpnTarget.getVrfRTValue());
737 irtList.add(vpnTarget.getVrfRTValue());
741 l3vpn.setId(vpnId).setRouteDistinguisher(rd).setImportRT(irtList).setExportRT(ertList);
742 Optional<VpnMap> optionalVpnMap = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
744 if (optionalVpnMap.isPresent()) {
745 VpnMap vpnMap = optionalVpnMap.get();
746 l3vpn.setRouterId(vpnMap.getRouterId()).setNetworkIds(vpnMap.getNetworkIds())
747 .setTenantId(vpnMap.getTenantId()).setName(vpnMap.getName());
749 l3vpnList.add(l3vpn.build());
752 opBuilder.setL3vpnInstances(l3vpnList);
753 result.set(RpcResultBuilder.<GetL3VPNOutput>success().withResult(opBuilder.build()).build());
755 } catch (Exception ex) {
756 String message = String.format("GetL3VPN failed due to %s", ex.getMessage());
757 logger.error(message, ex);
758 result.set(RpcResultBuilder.<GetL3VPNOutput>failed().withError(ErrorType.APPLICATION, message).build());
764 public Future<RpcResult<DeleteL3VPNOutput>> deleteL3VPN(DeleteL3VPNInput input) {
766 DeleteL3VPNOutputBuilder opBuilder = new DeleteL3VPNOutputBuilder();
767 SettableFuture<RpcResult<DeleteL3VPNOutput>> result = SettableFuture.create();
768 List<RpcError> errorList = new ArrayList<RpcError>();
770 int failurecount = 0;
771 int warningcount = 0;
772 List<Uuid> vpns = input.getId();
773 for (Uuid vpn : vpns) {
777 InstanceIdentifier<VpnInstance> vpnIdentifier =
778 InstanceIdentifier.builder(VpnInstances.class)
779 .child(VpnInstance.class, new VpnInstanceKey(vpn.getValue())).build();
780 Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
782 if (optionalVpn.isPresent()) {
785 msg = String.format("VPN with vpnid: %s does not exist", vpn.getValue());
787 error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-value", msg);
788 errorList.add(error);
791 } catch (Exception ex) {
792 msg = String.format("Deletion of L3VPN failed when deleting for uuid %s", vpn.getValue());
793 logger.error(msg, ex);
794 error = RpcResultBuilder.newError(ErrorType.APPLICATION, msg, ex.getMessage());
795 errorList.add(error);
799 // if at least one succeeds; result is success
800 // if none succeeds; result is failure
801 if (failurecount + warningcount == vpns.size()) {
802 result.set(RpcResultBuilder.<DeleteL3VPNOutput>failed().withRpcErrors(errorList).build());
804 List<String> errorResponseList = new ArrayList<>();
805 if (!errorList.isEmpty()) {
806 for (RpcError rpcError : errorList) {
807 String errorResponse = String.format("ErrorType: " + rpcError.getErrorType() + ", " + "ErrorTag: " +
808 rpcError.getTag() + ", " + "ErrorMessage: " + rpcError.getMessage());
809 errorResponseList.add(errorResponse);
812 errorResponseList.add("Operation successful with no errors");
814 opBuilder.setResponse(errorResponseList);
815 result.set(RpcResultBuilder.<DeleteL3VPNOutput>success().withResult(opBuilder.build()).build());
820 protected void addSubnetToVpn(Uuid vpnId, Uuid subnet) {
821 logger.debug("Adding subnet {} to vpn {}", subnet.getValue(), vpnId.getValue());
822 Subnetmap sn = updateSubnetNode(subnet, null, null, null, null, vpnId, null);
823 // Check if there are ports on this subnet and add corresponding vpn-interfaces
824 List<Uuid> portList = sn.getPortList();
825 if (portList != null) {
826 for (Uuid port : sn.getPortList()) {
827 logger.debug("adding vpn-interface for port {}", port.getValue());
828 createVpnInterface(vpnId, NeutronvpnUtils.getNeutronPort(broker, port));
833 protected void updateVpnForSubnet(Uuid vpnId, Uuid subnet) {
834 logger.debug("Updating VPN {} for subnet {}", vpnId.getValue(), subnet.getValue());
835 Subnetmap sn = updateSubnetNode(subnet, null, null, null, null, vpnId, null);
836 // Check for ports on this subnet and update association of corresponding vpn-interfaces to external vpn
837 List<Uuid> portList = sn.getPortList();
838 if (portList != null) {
839 for (Uuid port : sn.getPortList()) {
840 logger.debug("Updating vpn-interface for port {}", port.getValue());
841 updateVpnInterface(vpnId, NeutronvpnUtils.getNeutronPort(broker, port));
846 protected List<Adjacency> addAdjacencyforExtraRoute(List<Routes> routeList, boolean rtrUp, String vpnifname) {
847 List<Adjacency> adjList = new ArrayList<Adjacency>();
848 for (Routes route : routeList) {
849 if (route != null && route.getNexthop() != null && route.getDestination() != null) {
850 boolean isLockAcquired = false;
851 String nextHop = String.valueOf(route.getNexthop().getValue());
852 String destination = String.valueOf(route.getDestination().getValue());
854 String infName = NeutronvpnUtils.getNeutronPortNamefromPortFixedIp(broker, nextHop);
855 logger.trace("Adding extra route with nexthop {}, destination {}, infName {}", nextHop,
856 destination, infName);
857 Adjacency erAdj = new AdjacencyBuilder().setIpAddress(destination).setNextHopIp(nextHop).setKey
858 (new AdjacencyKey(destination)).build();
859 if (rtrUp == false) {
860 if (infName.equals(vpnifname)) {
865 InstanceIdentifier<VpnInterface> vpnIfIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
866 child(VpnInterface.class, new VpnInterfaceKey(infName)).build();
868 Optional<VpnInterface> optionalVpnInterface = NeutronvpnUtils.read(broker, LogicalDatastoreType
869 .CONFIGURATION, vpnIfIdentifier);
870 if (optionalVpnInterface.isPresent()) {
871 Adjacencies erAdjs = new AdjacenciesBuilder().setAdjacency(Arrays.asList(erAdj)).build();
872 VpnInterface vpnIf = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(infName))
873 .addAugmentation(Adjacencies.class, erAdjs).build();
874 isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
875 logger.debug("Adding extra route {}", route);
876 MDSALUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
878 logger.error("VM adjacency for interface {} not present ; cannot add extra route adjacency",
881 } catch (Exception e) {
882 logger.error("exception in adding extra route: {}" + e);
884 if (isLockAcquired) {
885 NeutronvpnUtils.unlock(lockManager, infName);
889 logger.error("Incorrect input received for extra route. {}", route);
895 protected void removeAdjacencyforExtraRoute(List<Routes> routeList) {
896 for (Routes route : routeList) {
897 if (route != null && route.getNexthop() != null && route.getDestination() != null) {
898 boolean isLockAcquired = false;
899 String nextHop = String.valueOf(route.getNexthop().getValue());
900 String destination = String.valueOf(route.getDestination().getValue());
902 String infName = NeutronvpnUtils.getNeutronPortNamefromPortFixedIp(broker, nextHop);
903 logger.trace("Removing extra route with nexthop {}, destination {}, infName {}", nextHop,
904 destination, infName);
905 InstanceIdentifier<Adjacency> adjacencyIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
906 child(VpnInterface.class, new VpnInterfaceKey(infName)).augmentation(Adjacencies.class)
907 .child(Adjacency.class, new AdjacencyKey(destination)).build();
909 isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
910 MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier);
911 logger.trace("extra route {} deleted successfully", route);
912 } catch (Exception e) {
913 logger.error("exception in deleting extra route: {}" + e);
915 if (isLockAcquired) {
916 NeutronvpnUtils.unlock(lockManager, infName);
920 logger.error("Incorrect input received for extra route. {}", route);
925 protected void removeL3Vpn(Uuid id) {
927 VpnMap vpnMap = NeutronvpnUtils.getVpnMap(broker, id);
928 Uuid router = vpnMap.getRouterId();
930 if (router != null) {
931 dissociateRouterFromVpn(id, router);
933 // dissociate networks
934 if (!id.equals(router)) {
935 dissociateNetworksFromVpn(id, vpnMap.getNetworkIds());
937 // remove entire vpnMaps node
938 deleteVpnMapsNode(id);
940 // remove vpn-instance
941 deleteVpnInstance(id);
944 protected void removeSubnetFromVpn(Uuid vpnId, Uuid subnet) {
945 logger.debug("Removing subnet {} from vpn {}", subnet.getValue(), vpnId.getValue());
946 Subnetmap sn = NeutronvpnUtils.getSubnetmap(broker, subnet);
948 // Check if there are ports on this subnet; remove corresponding vpn-interfaces
949 List<Uuid> portList = sn.getPortList();
950 if (portList != null) {
951 for (Uuid port : sn.getPortList()) {
952 logger.debug("removing vpn-interface for port {}", port.getValue());
953 deleteVpnInterface(NeutronvpnUtils.getNeutronPort(broker, port));
956 // update subnet-vpn association
957 removeFromSubnetNode(subnet, null, null, vpnId, null);
959 logger.warn("Subnetmap for subnet {} not found", subnet.getValue());
963 protected void associateRouterToVpn(Uuid vpnId, Uuid routerId) {
964 updateVpnMaps(vpnId, null, routerId, null, null);
965 List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
966 if (!vpnId.equals(routerId)) {
967 logger.debug("Updating association of subnets to external vpn {}", vpnId.getValue());
968 if (routerSubnets != null) {
969 for (Uuid subnetId : routerSubnets) {
970 updateVpnForSubnet(vpnId, subnetId);
974 logger.debug("Adding subnets to internal vpn {}", vpnId.getValue());
975 for (Uuid subnet : routerSubnets) {
976 addSubnetToVpn(vpnId, subnet);
981 protected void dissociateRouterFromVpn(Uuid vpnId, Uuid routerId) {
983 List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
984 if (routerSubnets != null) {
985 for (Uuid subnetId : routerSubnets) {
986 logger.debug("Updating association of subnets to internal vpn {}", routerId.getValue());
987 updateVpnForSubnet(routerId, subnetId);
990 clearFromVpnMaps(vpnId, routerId, null);
993 protected List<String> associateNetworksToVpn(Uuid vpn, List<Uuid> networks) {
994 List<String> failed = new ArrayList<String>();
995 if (!networks.isEmpty()) {
996 // store in Data Base
997 updateVpnMaps(vpn, null, null, null, networks);
998 // process corresponding subnets for VPN
999 for (Uuid nw : networks) {
1000 if (NeutronvpnUtils.getNeutronNetwork(broker, nw) == null) {
1001 failed.add(nw.getValue());
1003 List<Uuid> networkSubnets = NeutronvpnUtils.getSubnetIdsFromNetworkId(broker, nw);
1004 logger.debug("Adding network subnets...");
1005 if (networkSubnets != null) {
1006 for (Uuid subnet : networkSubnets) {
1007 addSubnetToVpn(vpn, subnet);
1016 protected List<String> dissociateNetworksFromVpn(Uuid vpn, List<Uuid> networks) {
1017 List<String> failed = new ArrayList<String>();
1018 if (networks != null && !networks.isEmpty()) {
1019 // store in Data Base
1020 clearFromVpnMaps(vpn, null, networks);
1021 // process corresponding subnets for VPN
1022 for (Uuid nw : networks) {
1023 if (NeutronvpnUtils.getNeutronNetwork(broker, nw) == null) {
1024 failed.add(nw.getValue());
1026 List<Uuid> networkSubnets = NeutronvpnUtils.getSubnetIdsFromNetworkId(broker, nw);
1027 logger.debug("Removing network subnets...");
1028 if (networkSubnets != null) {
1029 for (Uuid subnet : networkSubnets) {
1030 removeSubnetFromVpn(vpn, subnet);
1040 public Future<RpcResult<AssociateNetworksOutput>> associateNetworks(AssociateNetworksInput input) {
1042 AssociateNetworksOutputBuilder opBuilder = new AssociateNetworksOutputBuilder();
1043 SettableFuture<RpcResult<AssociateNetworksOutput>> result = SettableFuture.create();
1044 logger.debug("associateNetworks {}", input);
1045 StringBuilder returnMsg = new StringBuilder();
1046 Uuid vpnId = input.getVpnId();
1049 if (NeutronvpnUtils.getVpnMap(broker, vpnId) != null) {
1050 List<Uuid> netIds = input.getNetworkId();
1051 if (netIds != null && !netIds.isEmpty()) {
1052 List<String> failed = associateNetworksToVpn(vpnId, netIds);
1053 if (!failed.isEmpty()) {
1054 returnMsg.append("network(s) not found : ").append(failed);
1058 returnMsg.append("VPN not found : ").append(vpnId.getValue());
1060 if (returnMsg.length() != 0) {
1061 String message = String.format("associate Networks to vpn %s failed due to %s", vpnId.getValue(),
1063 logger.error(message);
1064 String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: " +
1066 opBuilder.setResponse(errorResponse);
1067 result.set(RpcResultBuilder.<AssociateNetworksOutput>success().withResult(opBuilder.build()).build());
1069 result.set(RpcResultBuilder.<AssociateNetworksOutput>success().build());
1071 } catch (Exception ex) {
1072 String message = String.format("associate Networks to vpn %s failed due to %s", input.getVpnId().getValue(),
1074 logger.error(message, ex);
1075 result.set(RpcResultBuilder.<AssociateNetworksOutput>failed().withError(ErrorType.APPLICATION, message)
1078 logger.debug("associateNetworks returns..");
1083 public Future<RpcResult<Void>> associateRouter(AssociateRouterInput input) {
1085 SettableFuture<RpcResult<Void>> result = SettableFuture.create();
1086 logger.debug("associateRouter {}", input);
1087 StringBuilder returnMsg = new StringBuilder();
1088 Uuid vpnId = input.getVpnId();
1089 Uuid routerId = input.getRouterId();
1091 if (routerId != null && vpnId != null) {
1092 Router rtr = NeutronvpnUtils.getNeutronRouter(broker, routerId);
1093 VpnMap vpnMap = NeutronvpnUtils.getVpnMap(broker, vpnId);
1094 if (rtr != null && vpnMap != null) {
1095 if (vpnMap.getRouterId() != null) {
1096 returnMsg.append("vpn ").append(vpnId.getValue()).append(" already associated to router ")
1097 .append(vpnMap.getRouterId().getValue());
1099 associateRouterToVpn(vpnId, routerId);
1102 returnMsg.append("router not found : ").append(routerId.getValue());
1105 returnMsg.append("VPN not found : ").append(vpnId.getValue());
1107 if (returnMsg.length() != 0) {
1108 String message = String.format("associate router to vpn %s failed due to %s", routerId.getValue(),
1110 logger.error(message);
1111 result.set(RpcResultBuilder.<Void>failed().withWarning(ErrorType.PROTOCOL, "invalid-value", message)
1114 result.set(RpcResultBuilder.<Void>success().build());
1116 } catch (Exception ex) {
1117 String message = String.format("associate router %s to vpn %s failed due to %s", routerId.getValue(),
1118 vpnId.getValue(), ex.getMessage());
1119 logger.error(message, ex);
1120 result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, message).build());
1122 logger.debug("associateRouter returns..");
1127 public Future<RpcResult<DissociateNetworksOutput>> dissociateNetworks(DissociateNetworksInput input) {
1129 DissociateNetworksOutputBuilder opBuilder = new DissociateNetworksOutputBuilder();
1130 SettableFuture<RpcResult<DissociateNetworksOutput>> result = SettableFuture.create();
1132 logger.debug("dissociateNetworks {}", input);
1133 StringBuilder returnMsg = new StringBuilder();
1134 Uuid vpnId = input.getVpnId();
1137 if (NeutronvpnUtils.getVpnMap(broker, vpnId) != null) {
1138 List<Uuid> netIds = input.getNetworkId();
1139 if (netIds != null && !netIds.isEmpty()) {
1140 List<String> failed = dissociateNetworksFromVpn(vpnId, netIds);
1141 if (!failed.isEmpty()) {
1142 returnMsg.append("netowrk(s) not found : ").append(failed);
1146 returnMsg.append("VPN not found : ").append(vpnId.getValue());
1148 if (returnMsg.length() != 0) {
1149 String message = String.format("dissociate Networks to vpn %s failed due to %s", vpnId.getValue(),
1151 logger.error(message);
1152 String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: " +
1154 opBuilder.setResponse(errorResponse);
1155 result.set(RpcResultBuilder.<DissociateNetworksOutput>success().withResult(opBuilder.build()).build());
1157 result.set(RpcResultBuilder.<DissociateNetworksOutput>success().build());
1159 } catch (Exception ex) {
1160 String message = String.format("dissociate Networks to vpn %s failed due to %s", input.getVpnId().
1161 getValue(), ex.getMessage());
1162 logger.error(message, ex);
1163 result.set(RpcResultBuilder.<DissociateNetworksOutput>failed().withError(ErrorType.APPLICATION, message)
1166 logger.debug("dissociateNetworks returns..");
1171 public Future<RpcResult<Void>> dissociateRouter(DissociateRouterInput input) {
1173 SettableFuture<RpcResult<Void>> result = SettableFuture.create();
1175 logger.debug("dissociateRouter {}", input);
1176 StringBuilder returnMsg = new StringBuilder();
1177 Uuid vpnId = input.getVpnId();
1178 Uuid routerId = input.getRouterId();
1180 if (NeutronvpnUtils.getVpnMap(broker, vpnId) != null) {
1181 if (routerId != null) {
1182 Router rtr = NeutronvpnUtils.getNeutronRouter(broker, routerId);
1184 dissociateRouterFromVpn(vpnId, routerId);
1186 returnMsg.append("router not found : ").append(routerId.getValue());
1190 returnMsg.append("VPN not found : ").append(vpnId.getValue());
1192 if (returnMsg.length() != 0) {
1193 String message = String.format("dissociate router %s to vpn %s failed due to %s", routerId.getValue(),
1194 vpnId.getValue(), returnMsg);
1195 logger.error(message);
1196 String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: " +
1198 result.set(RpcResultBuilder.<Void>failed().withWarning(ErrorType.PROTOCOL, "invalid-value", message)
1201 result.set(RpcResultBuilder.<Void>success().build());
1203 } catch (Exception ex) {
1204 String message = String.format("disssociate router %s to vpn %s failed due to %s", routerId.getValue(),
1205 vpnId.getValue(), ex.getMessage());
1206 logger.error(message, ex);
1207 result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, message).build());
1209 logger.debug("dissociateRouter returns..");
1215 public Future<RpcResult<GetFixedIPsForNeutronPortOutput>> getFixedIPsForNeutronPort(GetFixedIPsForNeutronPortInput
1217 GetFixedIPsForNeutronPortOutputBuilder opBuilder = new GetFixedIPsForNeutronPortOutputBuilder();
1218 SettableFuture<RpcResult<GetFixedIPsForNeutronPortOutput>> result = SettableFuture.create();
1219 Uuid portId = input.getPortId();
1220 StringBuilder returnMsg = new StringBuilder();
1222 List<String> fixedIPList = new ArrayList<>();
1223 Port port = NeutronvpnUtils.getNeutronPort(broker, portId);
1225 List<FixedIps> fixedIPs = port.getFixedIps();
1226 for (FixedIps ip : fixedIPs) {
1227 fixedIPList.add(ip.getIpAddress().getIpv4Address().getValue());
1230 returnMsg.append("neutron port: ").append(portId.getValue()).append(" not found");
1232 if (returnMsg.length() != 0) {
1233 String message = String.format("Retrieval of FixedIPList for neutron port failed due to %s", returnMsg);
1234 logger.error(message);
1235 result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>failed().withWarning(ErrorType.PROTOCOL,
1236 "invalid-value", message).build());
1238 opBuilder.setFixedIPs(fixedIPList);
1239 result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>success().withResult(opBuilder.build())
1241 result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>success().build());
1243 } catch (Exception ex) {
1244 String message = String.format("Retrieval of FixedIPList for neutron port %s failed due to %s", portId
1245 .getValue(), ex.getMessage());
1246 logger.error(message, ex);
1247 result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>failed().withError(ErrorType.APPLICATION,
1253 protected void handleNeutronRouterDeleted(Uuid routerId, List<Uuid> routerSubnetIds) {
1254 // check if the router is associated to some VPN
1255 Uuid vpnId = NeutronvpnUtils.getVpnForRouter(broker, routerId, true);
1256 if (vpnId != null) {
1257 // remove existing external vpn interfaces
1258 for (Uuid subnetId : routerSubnetIds) {
1259 removeSubnetFromVpn(vpnId, subnetId);
1261 clearFromVpnMaps(vpnId, routerId, null);
1263 // remove existing internal vpn interfaces
1264 for (Uuid subnetId : routerSubnetIds) {
1265 removeSubnetFromVpn(routerId, subnetId);
1268 // delete entire vpnMaps node for internal VPN
1269 deleteVpnMapsNode(routerId);
1271 // delete vpn-instance for internal VPN
1272 deleteVpnInstance(routerId);
1275 protected Subnet getNeutronSubnet(Uuid subnetId) {
1276 InstanceIdentifier<Subnet> inst = InstanceIdentifier.create(Neutron.class).
1277 child(Subnets.class).child(Subnet.class, new SubnetKey(subnetId));
1278 Optional<Subnet> sn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, inst);
1280 if (sn.isPresent()) {
1286 protected IpAddress getNeutronSubnetGateway(Uuid subnetId) {
1287 Subnet sn = getNeutronSubnet(subnetId);
1289 return sn.getGatewayIp();
1294 protected Port getNeutronPort(String name) {
1295 return NeutronvpnUtils.getNeutronPort(broker, new Uuid(name));
1298 protected Port getNeutronPort(Uuid portId) {
1299 return NeutronvpnUtils.getNeutronPort(broker, portId);
1302 protected List<Uuid> getSubnetsforVpn(Uuid vpnid) {
1303 List<Uuid> subnets = new ArrayList<Uuid>();
1305 InstanceIdentifier<Subnetmaps> subnetmapsid = InstanceIdentifier.builder(Subnetmaps.class).build();
1306 Optional<Subnetmaps> subnetmaps = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
1308 if (subnetmaps.isPresent() && subnetmaps.get().getSubnetmap() != null) {
1309 List<Subnetmap> subnetMapList = subnetmaps.get().getSubnetmap();
1310 for (Subnetmap subnetMap : subnetMapList) {
1311 if (subnetMap.getVpnId() != null && subnetMap.getVpnId().equals(vpnid)) {
1312 subnets.add(subnetMap.getId());
1319 public List<String> showNeutronPortsCLI() {
1320 List<String> result = new ArrayList<String>();
1321 result.add(String.format(" %-34s %-22s %-22s %-6s ", "PortName", "Mac Address", "IP Address",
1323 result.add("---------------------------------------------------------------------------------------");
1324 InstanceIdentifier<Ports> portidentifier = InstanceIdentifier.create(Neutron.class).child(Ports.class);
1326 Optional<Ports> ports = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, portidentifier);
1327 if (ports.isPresent() && ports.get().getPort() != null) {
1328 List<Port> portList = ports.get().getPort();
1329 for (Port port : portList) {
1330 result.add(String.format(" %-34s %-22s %-22s %-6s ", port.getUuid().getValue(), port
1331 .getMacAddress(), port.getFixedIps().get(0).getIpAddress().getIpv4Address().getValue(),
1332 NeutronvpnUtils.getIPPrefixFromPort(broker, port)));
1335 } catch (Exception e) {
1336 logger.error("Failed to retrieve neutronPorts info : ", e);
1337 System.out.println("Failed to retrieve neutronPorts info : " + e.getMessage());
1342 public List<String> showVpnConfigCLI(Uuid vpnuuid) {
1343 List<String> result = new ArrayList<String>();
1344 if (vpnuuid == null) {
1345 System.out.println("");
1346 System.out.println("Displaying VPN config for all VPNs");
1347 System.out.println("To display VPN config for a particular VPN, use the following syntax");
1348 System.out.println(getshowVpnConfigCLIHelp());
1351 RpcResult<GetL3VPNOutput> rpcResult = getL3VPN(new GetL3VPNInputBuilder().setId(vpnuuid).build()).get();
1352 if (rpcResult.isSuccessful()) {
1354 result.add(String.format(" %-37s %-37s %-7s ", "VPN ID", "Tenant ID", "RD"));
1356 result.add(String.format(" %-80s ", "Import-RTs"));
1358 result.add(String.format(" %-80s ", "Export-RTs"));
1360 result.add(String.format(" %-76s ", "Subnet IDs"));
1362 result.add("------------------------------------------------------------------------------------");
1364 List<L3vpnInstances> VpnList = rpcResult.getResult().getL3vpnInstances();
1365 for (L3vpnInstance Vpn : VpnList) {
1366 String tenantId = Vpn.getTenantId() != null ? Vpn.getTenantId().getValue() : "\" " +
1368 result.add(String.format(" %-37s %-37s %-7s ", Vpn.getId().getValue(), tenantId, Vpn
1369 .getRouteDistinguisher()));
1371 result.add(String.format(" %-80s ", Vpn.getImportRT()));
1373 result.add(String.format(" %-80s ", Vpn.getExportRT()));
1376 Uuid vpnid = Vpn.getId();
1377 List<Uuid> subnetList = getSubnetsforVpn(vpnid);
1378 if (!subnetList.isEmpty()) {
1379 for (Uuid subnetuuid : subnetList) {
1380 result.add(String.format(" %-76s ", subnetuuid.getValue()));
1383 result.add(String.format(" %-76s ", "\" \""));
1386 result.add("----------------------------------------");
1390 String errortag = rpcResult.getErrors().iterator().next().getTag();
1391 if (errortag == "") {
1392 System.out.println("");
1393 System.out.println("No VPN has been configured yet");
1394 } else if (errortag == "invalid-value") {
1395 System.out.println("");
1396 System.out.println("VPN " + vpnuuid.getValue() + " is not present");
1398 System.out.println("error getting VPN info : " + rpcResult.getErrors());
1399 System.out.println(getshowVpnConfigCLIHelp());
1402 } catch (InterruptedException | ExecutionException e) {
1403 logger.error("error getting VPN info : ", e);
1404 System.out.println("error getting VPN info : " + e.getMessage());
1409 private String getshowVpnConfigCLIHelp() {
1410 StringBuilder help = new StringBuilder("Usage:");
1411 help.append("display vpn-config [-vid/--vpnid <id>]");
1412 return help.toString();