vpnservice/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/netvirt/neutronvpn/NeutronvpnNatManager.java

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.netvirt.neutronvpn;
   9
  10 import com.google.common.base.Optional;
  11
  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.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
  28 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  29 import org.slf4j.Logger;
  30 import org.slf4j.LoggerFactory;
  31 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  32 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  33
  34 import java.util.ArrayList;
  35 import java.util.HashSet;
  36 import java.util.List;
  37
  38
  39 public class NeutronvpnNatManager implements AutoCloseable {
  40     private static final Logger logger = LoggerFactory.getLogger(NeutronvpnNatManager.class);
  41
  42     private final DataBroker broker;
  43     IMdsalApiManager mdsalUtil;
  44
  45     private static final int EXTERNAL_NO_CHANGE = 0;
  46     private static final int EXTERNAL_ADDED = 1;
  47     private static final int EXTERNAL_REMOVED = 2;
  48     private static final int EXTERNAL_CHANGED = 3;
  49
  50     /**
  51      * @param db           - dataBroker reference
  52      * @param mdsalManager - MDSAL Util API access
  53      */
  54     public NeutronvpnNatManager(final DataBroker db, IMdsalApiManager mdsalManager) {
  55         broker = db;
  56         mdsalUtil = mdsalManager;
  57     }
  58
  59     @Override
  60     public void close() throws Exception {
  61         logger.info("Neutron VPN Nat Manager Closed.");
  62     }
  63
  64     public void handleExternalNetworkForRouter(Router original, Router update) {
  65
  66         Uuid routerId = update.getUuid();
  67         Uuid origExtNetId = null;
  68         Uuid updExtNetId = null;
  69
  70         logger.trace("handleExternalNetwork for router " +  routerId);
  71         int ext_net_changed = externalNetworkChanged(original, update);
  72         if (ext_net_changed != EXTERNAL_NO_CHANGE) {
  73             if (ext_net_changed == EXTERNAL_ADDED) {
  74                 updExtNetId = update.getExternalGatewayInfo().getExternalNetworkId();
  75                 logger.trace("External Network " + updExtNetId.getValue() +
  76                         " addition detected for router " +  routerId.getValue());
  77                 addExternalNetworkToRouter(update);
  78                 return;
  79             }
  80             if (ext_net_changed == EXTERNAL_REMOVED) {
  81                 origExtNetId = original.getExternalGatewayInfo().getExternalNetworkId();
  82                 logger.trace("External Network removal detected " +
  83                         "for router " +  routerId.getValue());
  84                 removeExternalNetworkFromRouter(origExtNetId, update);
  85                 //gateway mac unset handled as part of gateway clear deleting top-level routers node
  86                 return;
  87             }
  88             origExtNetId = original.getExternalGatewayInfo().getExternalNetworkId();
  89             updExtNetId = update.getExternalGatewayInfo().getExternalNetworkId();
  90             logger.trace("External Network changed from "+ origExtNetId.getValue() + " to "
  91                     + updExtNetId.getValue() + " for router " +  routerId.getValue());
  92             removeExternalNetworkFromRouter(origExtNetId, update);
  93             addExternalNetworkToRouter(update);
  94             return;
  95         }
  96
  97         if (snatSettingChanged(original, update)) {
  98             logger.trace("SNAT settings on gateway changed  " +
  99                     "for router " + routerId.getValue());
 100             handleSnatSettingChangeForRouter(update, broker);
 101         }
 102
 103         if (externalFixedIpsChanged(original, update)) {
 104             logger.trace("External Fixed IPs changed " +
 105                     "for router " + routerId.getValue());
 106             handleExternalFixedIpsForRouter(update, broker);
 107         }
 108     }
 109
 110     private int externalNetworkChanged(Router original, Router update) {
 111         String orig_ext_net = null;
 112         String new_ext_net = null;
 113         if (original.getExternalGatewayInfo() != null) {
 114             orig_ext_net = original.getExternalGatewayInfo().getExternalNetworkId().getValue();
 115         }
 116
 117         if (update.getExternalGatewayInfo() != null) {
 118             new_ext_net = update.getExternalGatewayInfo().getExternalNetworkId().getValue();
 119         }
 120
 121         if (orig_ext_net == null) {
 122             if (new_ext_net == null) {
 123                 return EXTERNAL_NO_CHANGE;
 124             }
 125             return EXTERNAL_ADDED;
 126         }else{
 127             if (new_ext_net == null) {
 128                 return EXTERNAL_REMOVED;
 129             }
 130             if (!orig_ext_net.equals(new_ext_net)) {
 131                 return EXTERNAL_CHANGED;
 132             }
 133             return EXTERNAL_NO_CHANGE;
 134         }
 135     }
 136
 137     private boolean snatSettingChanged(Router orig, Router update) {
 138         ExternalGatewayInfo orig_ext_gw = null;
 139         ExternalGatewayInfo new_ext_gw = null;
 140         if (orig.getExternalGatewayInfo() != null) {
 141             orig_ext_gw = orig.getExternalGatewayInfo();
 142         }
 143
 144         if (update.getExternalGatewayInfo() != null) {
 145             new_ext_gw = update.getExternalGatewayInfo();
 146         }
 147
 148         if ((orig_ext_gw != null) && (new_ext_gw != null)) {
 149             if (orig_ext_gw.isEnableSnat() != new_ext_gw.isEnableSnat()) {
 150                 return true;
 151             }
 152         }
 153
 154         return false;
 155     }
 156
 157     private boolean externalFixedIpsChanged(Router orig, Router update) {
 158         ExternalGatewayInfo orig_ext_gw = null;
 159         ExternalGatewayInfo new_ext_gw = null;
 160         if (orig.getExternalGatewayInfo() != null) {
 161             orig_ext_gw = orig.getExternalGatewayInfo();
 162         }
 163
 164         if (update.getExternalGatewayInfo() != null) {
 165             new_ext_gw = update.getExternalGatewayInfo();
 166         }
 167
 168         if ((orig_ext_gw != null) && (new_ext_gw != null)) {
 169             List<ExternalFixedIps> orig_ext_fixed_ips = orig_ext_gw.getExternalFixedIps();
 170             HashSet<String> orig_fixed_ip_set = new HashSet<String>();
 171             for (ExternalFixedIps fixed_ip: orig_ext_fixed_ips) {
 172                 orig_fixed_ip_set.add(fixed_ip.getIpAddress().getIpv4Address().getValue());
 173             }
 174             HashSet<String> upd_fixed_ip_set = new HashSet<String>();
 175             List<ExternalFixedIps> new_ext_fixed_ips = new_ext_gw.getExternalFixedIps();
 176             for (ExternalFixedIps fixed_ip: new_ext_fixed_ips) {
 177                 upd_fixed_ip_set.add(fixed_ip.getIpAddress().getIpv4Address().getValue());
 178             }
 179
 180             if (!orig_fixed_ip_set.equals(upd_fixed_ip_set)) {
 181                 // External Subnets have changed
 182                 return true;
 183             }
 184         }
 185         return false;
 186     }
 187
 188     public void addExternalNetwork(Network net) {
 189         Uuid extNetId = net.getUuid();
 190
 191         // Create and add Networks object for this External Network to the ExternalNetworks list
 192         InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
 193                 child(Networks.class, new NetworksKey(extNetId)).build();
 194
 195         try {
 196             logger.trace(" Creating/Updating a new Networks node: " +  extNetId.getValue());
 197             Optional<Networks> optionalNets = NeutronvpnUtils.read(broker,
 198                     LogicalDatastoreType.CONFIGURATION,
 199                     netsIdentifier);
 200             if (optionalNets.isPresent()) {
 201                 logger.error("External Network " + extNetId.getValue() +
 202                         " already detected to be present");
 203                 return;
 204             }
 205             NetworksBuilder builder = null;
 206             builder = new NetworksBuilder().setKey(new NetworksKey(extNetId)).setId(extNetId);
 207             builder.setVpnid(NeutronvpnUtils.getVpnForNetwork(broker, extNetId));
 208             builder.setRouterIds(new ArrayList<Uuid>());
 209
 210             Networks networkss = builder.build();
 211             // Add Networks object to the ExternalNetworks list
 212             //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
 213             logger.trace("Creating externalnetworks " + networkss);
 214             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, netsIdentifier, networkss);
 215             logger.trace("Wrote externalnetwork successfully to CONFIG Datastore");
 216         } catch (Exception ex) {
 217             logger.error("Creation of External Network " +
 218                     extNetId.getValue() + " failed " + ex.getMessage());
 219         } finally {
 220             //if (isLockAcquired) {
 221             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 222             //}
 223         }
 224     }
 225
 226     public void removeExternalNetwork(Network net) {
 227         Uuid extNetId = net.getUuid();
 228
 229         // Create and add Networks object for this External Network to the ExternalNetworks list
 230         InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
 231                 child(Networks.class, new NetworksKey(extNetId)).build();
 232
 233         try {
 234             Optional<Networks> optionalNets = NeutronvpnUtils.read(broker,
 235                     LogicalDatastoreType.CONFIGURATION,
 236                     netsIdentifier);
 237             logger.trace("Removing Networks node: " +  extNetId.getValue());
 238             if (!optionalNets.isPresent()) {
 239                 logger.info("External Network " + extNetId.getValue() +
 240                         " not available in the datastore");
 241                 return;
 242             }
 243             // Delete Networks object from the ExternalNetworks list
 244             //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
 245             logger.trace("Deleting External Network " + extNetId.getValue());
 246             MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, netsIdentifier);
 247             logger.trace("Deleted External Network " + extNetId.getValue() +
 248                     " successfully from CONFIG Datastore");
 249
 250         } catch (Exception ex) {
 251             logger.error("Deletion of External Network " + extNetId.getValue() +
 252                     " failed " + ex.getMessage());
 253         } finally {
 254             //if (isLockAcquired) {
 255             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 256             //}
 257         }
 258     }
 259
 260     private void addExternalNetworkToRouter(Router update) {
 261         Uuid routerId = update.getUuid();
 262         Uuid extNetId = update.getExternalGatewayInfo().getExternalNetworkId();
 263
 264         // Add this router to the ExtRouters list
 265         addExternalRouter(update, broker);
 266
 267         // Create and add Networks object for this External Network to the ExternalNetworks list
 268         InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
 269                 child(Networks.class, new NetworksKey(extNetId)).build();
 270
 271         try {
 272             Optional<Networks> optionalNets = NeutronvpnUtils.read(broker,
 273                     LogicalDatastoreType.CONFIGURATION,
 274                     netsIdentifier);
 275             NetworksBuilder builder = null;
 276             if (optionalNets.isPresent()) {
 277                 builder = new NetworksBuilder(optionalNets.get());
 278             } else {
 279                 logger.error("External Network " + extNetId.getValue() +
 280                         " not present in the NVPN datamodel");
 281                 return;
 282             }
 283             List<Uuid> rtrList = builder.getRouterIds();
 284             if (rtrList == null) {
 285                 rtrList = new ArrayList<Uuid>();
 286             }
 287             rtrList.add(routerId);
 288             builder.setRouterIds(rtrList);
 289
 290             Networks networkss = builder.build();
 291             // Add Networks object to the ExternalNetworks list
 292             //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
 293             logger.trace("Updating externalnetworks " + networkss);
 294             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, netsIdentifier, networkss);
 295             logger.trace("Updated externalnetworks successfully to CONFIG Datastore");
 296         } catch (Exception ex) {
 297             logger.error("Creation of externalnetworks failed for " + extNetId.getValue() + "with exception " + ex.getMessage());
 298         } finally {
 299             //if (isLockAcquired) {
 300             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 301             //}
 302         }
 303     }
 304
 305     public void removeExternalNetworkFromRouter(Uuid origExtNetId, Router update) {
 306         Uuid routerId = update.getUuid();
 307
 308         // Remove the router to the ExtRouters list
 309         removeExternalRouter(origExtNetId, update, broker);
 310
 311         // Remove the router from the ExternalNetworks list
 312         InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
 313                 child(Networks.class, new NetworksKey(origExtNetId)).build();
 314
 315         try {
 316             Optional<Networks> optionalNets = NeutronvpnUtils.read(broker,
 317                     LogicalDatastoreType.CONFIGURATION,
 318                     netsIdentifier);
 319             logger.trace("Removing a router from External Networks node: " +
 320                     origExtNetId.getValue());
 321             if (optionalNets.isPresent()) {
 322                 NetworksBuilder builder = new NetworksBuilder(optionalNets.get());
 323                 List<Uuid> rtrList = builder.getRouterIds();
 324                 if (rtrList != null) {
 325                     rtrList.remove(routerId);
 326                     builder.setRouterIds(rtrList);
 327                     Networks networkss = builder.build();
 328                     MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, netsIdentifier, networkss);
 329                     logger.trace("Removed router " + routerId + " from externalnetworks " + origExtNetId.getValue());
 330                 }
 331             }
 332         } catch (Exception ex) {
 333             logger.error("Removing externalnetwork " + origExtNetId.getValue() +
 334                     " from router " + routerId + " failed " + ex.getMessage());
 335         } finally {
 336             //if (isLockAcquired) {
 337             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 338             //}
 339         }
 340     }
 341
 342     public void addExternalNetworkToVpn(Network network, Uuid vpnId) {
 343         Uuid extNetId = network.getUuid();
 344
 345         // Create and add Networks object for this External Network to the ExternalNetworks list
 346         InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
 347                 child(Networks.class, new NetworksKey(extNetId)).build();
 348
 349         try {
 350             Optional<Networks> optionalNets = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 351                     netsIdentifier);
 352             logger.trace("Adding vpn-id into Networks node: " +  extNetId.getValue());
 353             NetworksBuilder builder = null;
 354             if (optionalNets.isPresent()) {
 355                 builder = new NetworksBuilder(optionalNets.get());
 356             } else {
 357                 logger.error("External Network " + extNetId.getValue() +
 358                         " not present in the NVPN datamodel");
 359                 return;
 360             }
 361             builder.setVpnid(vpnId);
 362             Networks networkss = builder.build();
 363             // Add Networks object to the ExternalNetworks list
 364             //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
 365             logger.trace("Setting VPN-ID for externalnetworks " + networkss);
 366             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, netsIdentifier, networkss);
 367             logger.trace("Wrote with VPN-ID successfully to CONFIG Datastore");
 368
 369         } catch (Exception ex) {
 370             logger.error("Attaching VPN-ID to externalnetwork"+ extNetId.getValue() +" failed with " + ex.getMessage());
 371         } finally {
 372             //if (isLockAcquired) {
 373             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 374             //}
 375         }
 376     }
 377
 378     public void removeExternalNetworkFromVpn(Network network) {
 379         Uuid extNetId = network.getUuid();
 380
 381         // Create and add Networks object for this External Network to the ExternalNetworks list
 382         InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
 383                 child(Networks.class, new NetworksKey(extNetId)).build();
 384
 385         try {
 386             Optional<Networks> optionalNets = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 387                     netsIdentifier);
 388             logger.trace("Removing vpn-id from Networks node: " +  extNetId.getValue());
 389             NetworksBuilder builder = null;
 390             if (optionalNets.isPresent()) {
 391                 builder = new NetworksBuilder(optionalNets.get());
 392             } else {
 393                 logger.error("External Network " + extNetId.getValue() + " not present in the NVPN datamodel");
 394                 return;
 395             }
 396
 397             builder.setVpnid(null);
 398             Networks networkss = builder.build();
 399             // Add Networks object to the ExternalNetworks list
 400             //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
 401             logger.trace("Remove vpn-id for externalnetwork " + networkss);
 402             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, netsIdentifier, networkss);
 403             logger.trace("Updated extnetworks successfully to CONFIG Datastore");
 404
 405         } catch (Exception ex) {
 406             logger.error("Removing VPN-ID from externalnetworks " + extNetId.getValue() + "failed with " + ex.getMessage());
 407         } finally {
 408             //if (isLockAcquired) {
 409             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 410             //}
 411         }
 412     }
 413
 414     private void addExternalRouter(Router update, DataBroker broker) {
 415         Uuid routerId = update.getUuid();
 416         Uuid extNetId = update.getExternalGatewayInfo().getExternalNetworkId();
 417         Uuid gatewayPortId = update.getGatewayPortId();
 418
 419         // Create and add Routers object for this Router to the ExtRouters list
 420
 421         // Create a Routers object
 422         InstanceIdentifier<Routers> routersIdentifier = NeutronvpnUtils.buildExtRoutersIdentifier(routerId);
 423
 424         try {
 425             Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
 426                     LogicalDatastoreType.CONFIGURATION,
 427                     routersIdentifier);
 428             logger.trace("Creating/Updating a new Routers node: " + routerId.getValue());
 429             RoutersBuilder builder = null;
 430             if (optionalRouters.isPresent()) {
 431                 builder = new RoutersBuilder(optionalRouters.get());
 432             } else {
 433                 builder = new RoutersBuilder().setKey(new RoutersKey(routerId.getValue()));
 434             }
 435             if (builder != null) {
 436                 builder.setRouterName(routerId.getValue());
 437             }
 438             if (builder != null) {
 439                 builder.setNetworkId(extNetId);
 440             }
 441             if (builder != null) {
 442                 builder.setEnableSnat(update.getExternalGatewayInfo().isEnableSnat());
 443             }
 444             if (builder != null) {
 445                 ArrayList<String> ext_fixed_ips = new ArrayList<String>();
 446                 for (ExternalFixedIps fixed_ips : update.getExternalGatewayInfo().getExternalFixedIps()) {
 447                     ext_fixed_ips.add(fixed_ips.getIpAddress().getIpv4Address().getValue());
 448                 }
 449                 builder.setExternalIps(ext_fixed_ips);
 450             }
 451             if (gatewayPortId != null) {
 452                 logger.trace("Setting/Updating gateway Mac for router {}", routerId.getValue());
 453                 Port port = NeutronvpnUtils.getNeutronPort(broker, gatewayPortId);
 454                 if (port.getDeviceOwner().equals(NeutronConstants.DEVICE_OWNER_GATEWAY_INF)) {
 455                     builder.setExtGwMacAddress(port.getMacAddress().getValue());
 456                 }
 457             }
 458             List<Uuid> subList = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
 459             builder.setSubnetIds(subList);
 460             Routers routerss = builder.build();
 461             // Add Routers object to the ExtRouters list
 462             //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
 463             logger.trace("Creating extrouters " + routerss);
 464             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, routersIdentifier, builder.build());
 465             logger.trace("Wrote successfully Routers to CONFIG Datastore");
 466
 467         } catch (Exception ex) {
 468             logger.error("Creation of extrouters failed for router " + routerId.getValue() + " failed with " + ex.getMessage());
 469         } finally {
 470             //if (isLockAcquired) {
 471             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 472             //}
 473         }
 474     }
 475
 476     private void removeExternalRouter(Uuid extNetId, Router update, DataBroker broker) {
 477         Uuid routerId = update.getUuid();
 478
 479         InstanceIdentifier<Routers> routersIdentifier = NeutronvpnUtils.buildExtRoutersIdentifier(routerId);
 480
 481         try {
 482             Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
 483                     LogicalDatastoreType.CONFIGURATION,
 484                     routersIdentifier);
 485             logger.trace(" Removing Routers node: " +  routerId.getValue());
 486             if (optionalRouters.isPresent()) {
 487                 RoutersBuilder builder = new RoutersBuilder(optionalRouters.get());
 488                 builder.setExternalIps(null);
 489                 builder.setSubnetIds(null);
 490                 MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, routersIdentifier);
 491                 logger.trace("Removed router " + routerId.getValue() + " from extrouters ");
 492             }
 493         } catch (Exception ex) {
 494             logger.error("Removing extrouter " + routerId.getValue() + " from extrouters " + "failed with " + ex.getMessage());
 495         } finally {
 496             //if (isLockAcquired) {
 497             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 498             //}
 499         }
 500     }
 501
 502     private void handleExternalFixedIpsForRouter(Router update, DataBroker broker) {
 503         Uuid routerId = update.getUuid();
 504
 505         InstanceIdentifier<Routers> routersIdentifier = NeutronvpnUtils.buildExtRoutersIdentifier(routerId);
 506
 507         try {
 508             Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
 509                     LogicalDatastoreType.CONFIGURATION,
 510                     routersIdentifier);
 511             logger.trace("Updating External Fixed IPs Routers node: " +  routerId.getValue());
 512             if (optionalRouters.isPresent()) {
 513                 RoutersBuilder builder = new RoutersBuilder(optionalRouters.get());
 514                 if (builder != null) {
 515                     ArrayList<String> ext_fixed_ips = new ArrayList<String>();
 516                     for (ExternalFixedIps fixed_ips : update.getExternalGatewayInfo().getExternalFixedIps()) {
 517                         ext_fixed_ips.add(fixed_ips.getIpAddress().getIpv4Address().getValue());
 518                     }
 519                     builder.setExternalIps(ext_fixed_ips);
 520                 }
 521                 Routers routerss = builder.build();
 522                 logger.trace("Updating external fixed ips for router " +
 523                         routerId.getValue() +  " with value " + routerss);
 524                 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, routersIdentifier, routerss);
 525                 logger.trace("Added External Fixed IPs successfully for Routers to CONFIG Datastore");
 526             }
 527         } catch (Exception ex) {
 528             logger.error("Updating extfixedips for " + routerId.getValue() + " in extrouters failed with " + ex.getMessage());
 529         } finally {
 530             //if (isLockAcquired) {
 531             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 532             //}
 533         }
 534     }
 535
 536     public void handleSubnetsForExternalRouter(Uuid routerId, DataBroker broker) {
 537
 538         InstanceIdentifier<Routers> routersIdentifier = NeutronvpnUtils.buildExtRoutersIdentifier(routerId);
 539
 540         try {
 541             Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
 542                     LogicalDatastoreType.CONFIGURATION,
 543                     routersIdentifier);
 544             logger.trace("Updating Internal subnets for Routers node: " +
 545                     routerId.getValue());
 546             RoutersBuilder builder = null;
 547             if (optionalRouters.isPresent()) {
 548                 builder = new RoutersBuilder(optionalRouters.get());
 549             } else {
 550                 logger.info("No Routers element found for router name " + routerId.getValue());
 551                 return;
 552             }
 553             List<Uuid> subList = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
 554             builder.setSubnetIds(subList);
 555             Routers routerss = builder.build();
 556             // Add Routers object to the ExtRouters list
 557             //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
 558             logger.trace("Updating extrouters " + routerss);
 559             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, routersIdentifier, routerss);
 560             logger.trace("Updated successfully Routers to CONFIG Datastore");
 561
 562         } catch (Exception ex) {
 563             logger.error("Updation of internal subnets for extrouters failed for router " + routerId.getValue() + " with " + ex.getMessage());
 564         } finally {
 565             //if (isLockAcquired) {
 566             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 567             //}
 568         }
 569     }
 570
 571     private void handleSnatSettingChangeForRouter(Router update, DataBroker broker) {
 572         Uuid routerId = update.getUuid();
 573
 574         InstanceIdentifier<Routers> routersIdentifier = NeutronvpnUtils.buildExtRoutersIdentifier(routerId);
 575
 576         try {
 577             Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
 578                     LogicalDatastoreType.CONFIGURATION,
 579                     routersIdentifier);
 580             logger.trace("Updating Internal subnets for Routers node: " +
 581                     routerId.getValue());
 582             RoutersBuilder builder = null;
 583             if (optionalRouters.isPresent()) {
 584                 builder = new RoutersBuilder(optionalRouters.get());
 585             } else {
 586                 logger.trace("No Routers element found for router name " + routerId.getValue());
 587                 return;
 588             }
 589             builder.setEnableSnat(update.getExternalGatewayInfo().isEnableSnat());
 590             Routers routerss = builder.build();
 591             // Add Routers object to the ExtRouters list
 592             //isLockAcquired = NeutronvpnUtils.lock(lockManager, extNetId.getValue());
 593             logger.trace("Updating extrouters for snat change " + routerss);
 594             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, routersIdentifier, routerss);
 595             logger.trace("Updated successfully Routers to CONFIG Datastore");
 596
 597         } catch (Exception ex) {
 598             logger.error("Updation of snat for extrouters failed for router " + routerId.getValue() + " with " + ex.getMessage());
 599         } finally {
 600             //if (isLockAcquired) {
 601             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 602             //}
 603         }
 604     }
 605 }