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.netvirt.neutronvpn;
10 import com.google.common.base.Optional;
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.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
15 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
16 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
17 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.ExternalGatewayInfo;
18 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.external_gateway_info.ExternalFixedIps;
19 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExtRouters;
20 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalNetworks;
21 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
22 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersBuilder;
23 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersKey;
24 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.Networks;
25 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.NetworksBuilder;
26 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.NetworksKey;
27 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
28 import org.slf4j.Logger;
29 import org.slf4j.LoggerFactory;
30 import org.opendaylight.genius.mdsalutil.MDSALUtil;
31 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
33 import java.util.ArrayList;
34 import java.util.HashSet;
35 import java.util.List;
38 public class NeutronvpnNatManager implements AutoCloseable {
39 private static final Logger logger = LoggerFactory.getLogger(NeutronvpnNatManager.class);
41 private final DataBroker broker;
42 IMdsalApiManager mdsalUtil;
44 private static final int EXTERNAL_NO_CHANGE = 0;
45 private static final int EXTERNAL_ADDED = 1;
46 private static final int EXTERNAL_REMOVED = 2;
47 private static final int EXTERNAL_CHANGED = 3;
50 * @param db - dataBroker reference
51 * @param mdsalManager - MDSAL Util API access
53 public NeutronvpnNatManager(final DataBroker db, IMdsalApiManager mdsalManager) {
55 mdsalUtil = mdsalManager;
59 public void close() throws Exception {
60 logger.info("Neutron VPN Nat Manager Closed.");
63 public void handleExternalNetworkForRouter(Router original, Router update) {
65 Uuid routerId = update.getUuid();
66 Uuid origExtNetId = null;
67 Uuid updExtNetId = null;
69 logger.trace("handleExternalNetwork for router " + routerId);
70 int ext_net_changed = externalNetworkChanged(original, update);
71 if (ext_net_changed != EXTERNAL_NO_CHANGE) {
72 if (ext_net_changed == EXTERNAL_ADDED) {
73 updExtNetId = update.getExternalGatewayInfo().getExternalNetworkId();
74 logger.trace("External Network " + updExtNetId.getValue() +
75 " addition detected for router " + routerId.getValue());
76 addExternalNetworkToRouter(update);
79 if (ext_net_changed == EXTERNAL_REMOVED) {
80 origExtNetId = original.getExternalGatewayInfo().getExternalNetworkId();
81 logger.trace("External Network removal detected " +
82 "for router " + routerId.getValue());
83 removeExternalNetworkFromRouter(origExtNetId, update);
86 origExtNetId = original.getExternalGatewayInfo().getExternalNetworkId();
87 updExtNetId = update.getExternalGatewayInfo().getExternalNetworkId();
88 logger.trace("External Network changed from "+ origExtNetId.getValue() + " to "
89 + updExtNetId.getValue() + " for router " + routerId.getValue());
90 removeExternalNetworkFromRouter(origExtNetId, update);
91 addExternalNetworkToRouter(update);
95 if (snatSettingChanged(original, update)) {
96 logger.trace("SNAT settings on gateway changed " +
97 "for router " + routerId.getValue());
98 handleSnatSettingChangeForRouter(update, broker);
101 if (externalFixedIpsChanged(original, update)) {
102 logger.trace("External Fixed IPs changed " +
103 "for router " + routerId.getValue());
104 handleExternalFixedIpsForRouter(update, broker);
108 private int externalNetworkChanged(Router original, Router update) {
109 String orig_ext_net = null;
110 String new_ext_net = null;
111 if (original.getExternalGatewayInfo() != null) {
112 orig_ext_net = original.getExternalGatewayInfo().getExternalNetworkId().getValue();
115 if (update.getExternalGatewayInfo() != null) {
116 new_ext_net = update.getExternalGatewayInfo().getExternalNetworkId().getValue();
119 if (orig_ext_net == null) {
120 if (new_ext_net == null) {
121 return EXTERNAL_NO_CHANGE;
123 return EXTERNAL_ADDED;
125 if (new_ext_net == null) {
126 return EXTERNAL_REMOVED;
128 if (!orig_ext_net.equals(new_ext_net)) {
129 return EXTERNAL_CHANGED;
131 return EXTERNAL_NO_CHANGE;
135 private boolean snatSettingChanged(Router orig, Router update) {
136 ExternalGatewayInfo orig_ext_gw = null;
137 ExternalGatewayInfo new_ext_gw = null;
138 if (orig.getExternalGatewayInfo() != null) {
139 orig_ext_gw = orig.getExternalGatewayInfo();
142 if (update.getExternalGatewayInfo() != null) {
143 new_ext_gw = update.getExternalGatewayInfo();
146 if ((orig_ext_gw != null) && (new_ext_gw != null)) {
147 if (orig_ext_gw.isEnableSnat() != new_ext_gw.isEnableSnat()) {
155 private boolean externalFixedIpsChanged(Router orig, Router update) {
156 ExternalGatewayInfo orig_ext_gw = null;
157 ExternalGatewayInfo new_ext_gw = null;
158 if (orig.getExternalGatewayInfo() != null) {
159 orig_ext_gw = orig.getExternalGatewayInfo();
162 if (update.getExternalGatewayInfo() != null) {
163 new_ext_gw = update.getExternalGatewayInfo();
166 if ((orig_ext_gw != null) && (new_ext_gw != null)) {
167 List<ExternalFixedIps> orig_ext_fixed_ips = orig_ext_gw.getExternalFixedIps();
168 HashSet<String> orig_fixed_ip_set = new HashSet<String>();
169 for (ExternalFixedIps fixed_ip: orig_ext_fixed_ips) {
170 orig_fixed_ip_set.add(fixed_ip.getIpAddress().toString());
172 HashSet<String> upd_fixed_ip_set = new HashSet<String>();
173 List<ExternalFixedIps> new_ext_fixed_ips = new_ext_gw.getExternalFixedIps();
174 for (ExternalFixedIps fixed_ip: new_ext_fixed_ips) {
175 upd_fixed_ip_set.add(fixed_ip.getIpAddress().toString());
178 if (!orig_fixed_ip_set.equals(upd_fixed_ip_set)) {
179 // External Subnets have changed
186 public void addExternalNetwork(Network net) {
187 Uuid extNetId = net.getUuid();
189 // Create and add Networks object for this External Network to the ExternalNetworks list
190 InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
191 child(Networks.class, new NetworksKey(extNetId)).build();
194 logger.trace(" Creating/Updating a new Networks node: " + extNetId.getValue());
195 Optional<Networks> optionalNets = NeutronvpnUtils.read(broker,
196 LogicalDatastoreType.CONFIGURATION,
198 if (optionalNets.isPresent()) {
199 logger.error("External Network " + extNetId.getValue() +
200 " already detected to be present");
203 NetworksBuilder builder = null;
204 builder = new NetworksBuilder().setKey(new NetworksKey(extNetId)).setId(extNetId);
205 builder.setVpnid(NeutronvpnUtils.getVpnForNetwork(broker, extNetId));
206 builder.setRouterIds(new ArrayList<Uuid>());
208 Networks networkss = builder.build();
209 // Add Networks object to the ExternalNetworks list
210 //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
211 logger.trace("Creating externalnetworks " + networkss);
212 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, netsIdentifier, networkss);
213 logger.trace("Wrote externalnetwork successfully to CONFIG Datastore");
214 } catch (Exception ex) {
215 logger.error("Creation of External Network " +
216 extNetId.getValue() + " failed " + ex.getMessage());
218 //if (isLockAcquired) {
219 // NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
224 public void removeExternalNetwork(Network net) {
225 Uuid extNetId = net.getUuid();
227 // Create and add Networks object for this External Network to the ExternalNetworks list
228 InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
229 child(Networks.class, new NetworksKey(extNetId)).build();
232 Optional<Networks> optionalNets = NeutronvpnUtils.read(broker,
233 LogicalDatastoreType.CONFIGURATION,
235 logger.trace("Removing Networks node: " + extNetId.getValue());
236 if (!optionalNets.isPresent()) {
237 logger.info("External Network " + extNetId.getValue() +
238 " not available in the datastore");
241 // Delete Networks object from the ExternalNetworks list
242 //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
243 logger.trace("Deleting External Network " + extNetId.getValue());
244 MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, netsIdentifier);
245 logger.trace("Deleted External Network " + extNetId.getValue() +
246 " successfully from CONFIG Datastore");
248 } catch (Exception ex) {
249 logger.error("Deletion of External Network " + extNetId.getValue() +
250 " failed " + ex.getMessage());
252 //if (isLockAcquired) {
253 // NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
258 private void addExternalNetworkToRouter(Router update) {
259 Uuid routerId = update.getUuid();
260 Uuid extNetId = update.getExternalGatewayInfo().getExternalNetworkId();
262 // Add this router to the ExtRouters list
263 addExternalRouter(update, broker);
265 // Create and add Networks object for this External Network to the ExternalNetworks list
266 InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
267 child(Networks.class, new NetworksKey(extNetId)).build();
270 Optional<Networks> optionalNets = NeutronvpnUtils.read(broker,
271 LogicalDatastoreType.CONFIGURATION,
273 NetworksBuilder builder = null;
274 if (optionalNets.isPresent()) {
275 builder = new NetworksBuilder(optionalNets.get());
277 logger.error("External Network " + extNetId.getValue() +
278 " not present in the NVPN datamodel");
281 List<Uuid> rtrList = builder.getRouterIds();
282 if (rtrList == null) {
283 rtrList = new ArrayList<Uuid>();
285 rtrList.add(routerId);
286 builder.setRouterIds(rtrList);
288 Networks networkss = builder.build();
289 // Add Networks object to the ExternalNetworks list
290 //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
291 logger.trace("Updating externalnetworks " + networkss);
292 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, netsIdentifier, networkss);
293 logger.trace("Updated externalnetworks successfully to CONFIG Datastore");
294 } catch (Exception ex) {
295 logger.error("Creation of externalnetworks failed for " + extNetId.getValue() + "with exception " + ex.getMessage());
297 //if (isLockAcquired) {
298 // NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
303 public void removeExternalNetworkFromRouter(Uuid origExtNetId, Router update) {
304 Uuid routerId = update.getUuid();
306 // Remove the router to the ExtRouters list
307 removeExternalRouter(origExtNetId, update, broker);
309 // Remove the router from the ExternalNetworks list
310 InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
311 child(Networks.class, new NetworksKey(origExtNetId)).build();
314 Optional<Networks> optionalNets = NeutronvpnUtils.read(broker,
315 LogicalDatastoreType.CONFIGURATION,
317 logger.trace("Removing a router from External Networks node: " +
318 origExtNetId.getValue());
319 if (optionalNets.isPresent()) {
320 NetworksBuilder builder = new NetworksBuilder(optionalNets.get());
321 List<Uuid> rtrList = builder.getRouterIds();
322 if (rtrList != null) {
323 rtrList.remove(routerId);
324 builder.setRouterIds(rtrList);
325 Networks networkss = builder.build();
326 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, netsIdentifier, networkss);
327 logger.trace("Removed router " + routerId + " from externalnetworks " + origExtNetId.getValue());
330 } catch (Exception ex) {
331 logger.error("Removing externalnetwork " + origExtNetId.getValue() +
332 " from router " + routerId + " failed " + ex.getMessage());
334 //if (isLockAcquired) {
335 // NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
340 public void addExternalNetworkToVpn(Network network, Uuid vpnId) {
341 Uuid extNetId = network.getUuid();
343 // Create and add Networks object for this External Network to the ExternalNetworks list
344 InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
345 child(Networks.class, new NetworksKey(extNetId)).build();
348 Optional<Networks> optionalNets = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
350 logger.trace("Adding vpn-id into Networks node: " + extNetId.getValue());
351 NetworksBuilder builder = null;
352 if (optionalNets.isPresent()) {
353 builder = new NetworksBuilder(optionalNets.get());
355 logger.error("External Network " + extNetId.getValue() +
356 " not present in the NVPN datamodel");
359 builder.setVpnid(vpnId);
360 Networks networkss = builder.build();
361 // Add Networks object to the ExternalNetworks list
362 //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
363 logger.trace("Setting VPN-ID for externalnetworks " + networkss);
364 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, netsIdentifier, networkss);
365 logger.trace("Wrote with VPN-ID successfully to CONFIG Datastore");
367 } catch (Exception ex) {
368 logger.error("Attaching VPN-ID to externalnetwork"+ extNetId.getValue() +" failed with " + ex.getMessage());
370 //if (isLockAcquired) {
371 // NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
376 public void removeExternalNetworkFromVpn(Network network) {
377 Uuid extNetId = network.getUuid();
379 // Create and add Networks object for this External Network to the ExternalNetworks list
380 InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
381 child(Networks.class, new NetworksKey(extNetId)).build();
384 Optional<Networks> optionalNets = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
386 logger.trace("Removing vpn-id from Networks node: " + extNetId.getValue());
387 NetworksBuilder builder = null;
388 if (optionalNets.isPresent()) {
389 builder = new NetworksBuilder(optionalNets.get());
391 logger.error("External Network " + extNetId.getValue() + " not present in the NVPN datamodel");
395 builder.setVpnid(null);
396 Networks networkss = builder.build();
397 // Add Networks object to the ExternalNetworks list
398 //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
399 logger.trace("Remove vpn-id for externalnetwork " + networkss);
400 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, netsIdentifier, networkss);
401 logger.trace("Updated extnetworks successfully to CONFIG Datastore");
403 } catch (Exception ex) {
404 logger.error("Removing VPN-ID from externalnetworks " + extNetId.getValue() + "failed with " + ex.getMessage());
406 //if (isLockAcquired) {
407 // NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
412 private void addExternalRouter(Router update, DataBroker broker) {
413 Uuid routerId = update.getUuid();
414 Uuid extNetId = update.getExternalGatewayInfo().getExternalNetworkId();
416 // Create and add Routers object for this Router to the ExtRouters list
418 // Create a Routers object
419 InstanceIdentifier<Routers> routersIdentifier = InstanceIdentifier.builder(ExtRouters.class).
420 child(Routers.class, new RoutersKey(routerId.getValue())).build();
423 Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
424 LogicalDatastoreType.CONFIGURATION,
426 logger.trace("Creating/Updating a new Routers node: " + routerId.getValue());
427 RoutersBuilder builder = null;
428 if (optionalRouters.isPresent()) {
429 builder = new RoutersBuilder(optionalRouters.get());
431 builder = new RoutersBuilder().setKey(new RoutersKey(routerId.getValue()));
433 if (builder != null) {
434 builder.setRouterName(routerId.getValue());
436 if (builder != null) {
437 builder.setNetworkId(extNetId);
439 if (builder != null) {
440 builder.setEnableSnat(update.getExternalGatewayInfo().isEnableSnat());
442 if (builder != null) {
443 ArrayList<String> ext_fixed_ips = new ArrayList<String>();
444 for (ExternalFixedIps fixed_ips : update.getExternalGatewayInfo().getExternalFixedIps()) {
445 ext_fixed_ips.add(fixed_ips.getIpAddress().toString());
447 builder.setExternalIps(ext_fixed_ips);
449 List<Uuid> subList = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
450 builder.setSubnetIds(subList);
451 Routers routerss = builder.build();
452 // Add Routers object to the ExtRouters list
453 //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
454 logger.trace("Creating extrouters " + routerss);
455 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, routersIdentifier, builder.build());
456 logger.trace("Wrote successfully Routers to CONFIG Datastore");
458 } catch (Exception ex) {
459 logger.error("Creation of extrouters failed for router " + routerId.getValue() + " failed with " + ex.getMessage());
461 //if (isLockAcquired) {
462 // NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
467 private void removeExternalRouter(Uuid extNetId, Router update, DataBroker broker) {
468 Uuid routerId = update.getUuid();
470 InstanceIdentifier<Routers> routersIdentifier = InstanceIdentifier.builder(ExtRouters.class).
471 child(Routers.class, new RoutersKey(routerId.getValue())).build();
474 Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
475 LogicalDatastoreType.CONFIGURATION,
477 logger.trace(" Removing Routers node: " + routerId.getValue());
478 if (optionalRouters.isPresent()) {
479 RoutersBuilder builder = new RoutersBuilder(optionalRouters.get());
480 builder.setExternalIps(null);
481 builder.setSubnetIds(null);
482 MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, routersIdentifier);
483 logger.trace("Removed router " + routerId.getValue() + " from extrouters ");
485 } catch (Exception ex) {
486 logger.error("Removing extrouter " + routerId.getValue() + " from extrouters " + "failed with " + ex.getMessage());
488 //if (isLockAcquired) {
489 // NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
494 private void handleExternalFixedIpsForRouter(Router update, DataBroker broker) {
495 Uuid routerId = update.getUuid();
497 InstanceIdentifier<Routers> routersIdentifier = InstanceIdentifier.builder(ExtRouters.class).
498 child(Routers.class, new RoutersKey(routerId.getValue())).build();
501 Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
502 LogicalDatastoreType.CONFIGURATION,
504 logger.trace("Updating External Fixed IPs Routers node: " + routerId.getValue());
505 if (optionalRouters.isPresent()) {
506 RoutersBuilder builder = new RoutersBuilder(optionalRouters.get());
507 if (builder != null) {
508 ArrayList<String> ext_fixed_ips = new ArrayList<String>();
509 for (ExternalFixedIps fixed_ips : update.getExternalGatewayInfo().getExternalFixedIps()) {
510 ext_fixed_ips.add(fixed_ips.getIpAddress().toString());
512 builder.setExternalIps(ext_fixed_ips);
514 Routers routerss = builder.build();
515 logger.trace("Updating external fixed ips for router " +
516 routerId.getValue() + " with value " + routerss);
517 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, routersIdentifier, routerss);
518 logger.trace("Added External Fixed IPs successfully for Routers to CONFIG Datastore");
520 } catch (Exception ex) {
521 logger.error("Updating extfixedips for " + routerId.getValue() + " in extrouters failed with " + ex.getMessage());
523 //if (isLockAcquired) {
524 // NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
529 public void handleSubnetsForExternalRouter(Uuid routerId, DataBroker broker) {
531 InstanceIdentifier<Routers> routersIdentifier = InstanceIdentifier.builder(ExtRouters.class).
532 child(Routers.class, new RoutersKey(routerId.getValue())).build();
535 Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
536 LogicalDatastoreType.CONFIGURATION,
538 logger.trace("Updating Internal subnets for Routers node: " +
539 routerId.getValue());
540 RoutersBuilder builder = null;
541 if (optionalRouters.isPresent()) {
542 builder = new RoutersBuilder(optionalRouters.get());
544 logger.info("No Routers element found for router name " + routerId.getValue());
547 List<Uuid> subList = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
548 builder.setSubnetIds(subList);
549 Routers routerss = builder.build();
550 // Add Routers object to the ExtRouters list
551 //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
552 logger.trace("Updating extrouters " + routerss);
553 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, routersIdentifier, routerss);
554 logger.trace("Updated successfully Routers to CONFIG Datastore");
556 } catch (Exception ex) {
557 logger.error("Updation of internal subnets for extrouters failed for router " + routerId.getValue() + " with " + ex.getMessage());
559 //if (isLockAcquired) {
560 // NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
565 private void handleSnatSettingChangeForRouter(Router update, DataBroker broker) {
566 Uuid routerId = update.getUuid();
568 InstanceIdentifier<Routers> routersIdentifier = InstanceIdentifier.builder(ExtRouters.class).
569 child(Routers.class, new RoutersKey(routerId.getValue())).build();
572 Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
573 LogicalDatastoreType.CONFIGURATION,
575 logger.trace("Updating Internal subnets for Routers node: " +
576 routerId.getValue());
577 RoutersBuilder builder = null;
578 if (optionalRouters.isPresent()) {
579 builder = new RoutersBuilder(optionalRouters.get());
581 logger.trace("No Routers element found for router name " + routerId.getValue());
584 builder.setEnableSnat(update.getExternalGatewayInfo().isEnableSnat());
585 Routers routerss = builder.build();
586 // Add Routers object to the ExtRouters list
587 //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
588 logger.trace("Updating extrouters for snat change " + routerss);
589 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, routersIdentifier, routerss);
590 logger.trace("Updated successfully Routers to CONFIG Datastore");
592 } catch (Exception ex) {
593 logger.error("Updation of snat for extrouters failed for router " + routerId.getValue() + " with " + ex.getMessage());
595 //if (isLockAcquired) {
596 // NeutronvpnUtils.unlock(lockManager, extNetId.getValue());