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.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;
  32
  33 import java.util.ArrayList;
  34 import java.util.HashSet;
  35 import java.util.List;
  36
  37
  38 public class NeutronvpnNatManager implements AutoCloseable {
  39     private static final Logger logger = LoggerFactory.getLogger(NeutronvpnNatManager.class);
  40
  41     private final DataBroker broker;
  42     IMdsalApiManager mdsalUtil;
  43
  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;
  48
  49     /**
  50      * @param db           - dataBroker reference
  51      * @param mdsalManager - MDSAL Util API access
  52      */
  53     public NeutronvpnNatManager(final DataBroker db, IMdsalApiManager mdsalManager) {
  54         broker = db;
  55         mdsalUtil = mdsalManager;
  56     }
  57
  58     @Override
  59     public void close() throws Exception {
  60         logger.info("Neutron VPN Nat Manager Closed.");
  61     }
  62
  63     public void handleExternalNetworkForRouter(Router original, Router update) {
  64
  65         Uuid routerId = update.getUuid();
  66         Uuid origExtNetId = null;
  67         Uuid updExtNetId = null;
  68
  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);
  77                 return;
  78             }
  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);
  84                 return;
  85             }
  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);
  92             return;
  93         }
  94
  95         if (snatSettingChanged(original, update)) {
  96             logger.trace("SNAT settings on gateway changed  " +
  97                     "for router " + routerId.getValue());
  98             handleSnatSettingChangeForRouter(update, broker);
  99         }
 100
 101         if (externalFixedIpsChanged(original, update)) {
 102             logger.trace("External Fixed IPs changed " +
 103                     "for router " + routerId.getValue());
 104             handleExternalFixedIpsForRouter(update, broker);
 105         }
 106     }
 107
 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();
 113         }
 114
 115         if (update.getExternalGatewayInfo() != null) {
 116             new_ext_net = update.getExternalGatewayInfo().getExternalNetworkId().getValue();
 117         }
 118
 119         if (orig_ext_net == null) {
 120             if (new_ext_net == null) {
 121                 return EXTERNAL_NO_CHANGE;
 122             }
 123             return EXTERNAL_ADDED;
 124         }else{
 125             if (new_ext_net == null) {
 126                 return EXTERNAL_REMOVED;
 127             }
 128             if (!orig_ext_net.equals(new_ext_net)) {
 129                 return EXTERNAL_CHANGED;
 130             }
 131             return EXTERNAL_NO_CHANGE;
 132         }
 133     }
 134
 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();
 140         }
 141
 142         if (update.getExternalGatewayInfo() != null) {
 143             new_ext_gw = update.getExternalGatewayInfo();
 144         }
 145
 146         if ((orig_ext_gw != null) && (new_ext_gw != null)) {
 147             if (orig_ext_gw.isEnableSnat() != new_ext_gw.isEnableSnat()) {
 148                 return true;
 149             }
 150         }
 151
 152         return false;
 153     }
 154
 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();
 160         }
 161
 162         if (update.getExternalGatewayInfo() != null) {
 163             new_ext_gw = update.getExternalGatewayInfo();
 164         }
 165
 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());
 171             }
 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());
 176             }
 177
 178             if (!orig_fixed_ip_set.equals(upd_fixed_ip_set)) {
 179                 // External Subnets have changed
 180                 return true;
 181             }
 182         }
 183         return false;
 184     }
 185
 186     public void addExternalNetwork(Network net) {
 187         Uuid extNetId = net.getUuid();
 188
 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();
 192
 193         try {
 194             logger.trace(" Creating/Updating a new Networks node: " +  extNetId.getValue());
 195             Optional<Networks> optionalNets = NeutronvpnUtils.read(broker,
 196                     LogicalDatastoreType.CONFIGURATION,
 197                     netsIdentifier);
 198             if (optionalNets.isPresent()) {
 199                 logger.error("External Network " + extNetId.getValue() +
 200                         " already detected to be present");
 201                 return;
 202             }
 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>());
 207
 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());
 217         } finally {
 218             //if (isLockAcquired) {
 219             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 220             //}
 221         }
 222     }
 223
 224     public void removeExternalNetwork(Network net) {
 225         Uuid extNetId = net.getUuid();
 226
 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();
 230
 231         try {
 232             Optional<Networks> optionalNets = NeutronvpnUtils.read(broker,
 233                     LogicalDatastoreType.CONFIGURATION,
 234                     netsIdentifier);
 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");
 239                 return;
 240             }
 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");
 247
 248         } catch (Exception ex) {
 249             logger.error("Deletion of External Network " + extNetId.getValue() +
 250                     " failed " + ex.getMessage());
 251         } finally {
 252             //if (isLockAcquired) {
 253             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 254             //}
 255         }
 256     }
 257
 258     private void addExternalNetworkToRouter(Router update) {
 259         Uuid routerId = update.getUuid();
 260         Uuid extNetId = update.getExternalGatewayInfo().getExternalNetworkId();
 261
 262         // Add this router to the ExtRouters list
 263         addExternalRouter(update, broker);
 264
 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();
 268
 269         try {
 270             Optional<Networks> optionalNets = NeutronvpnUtils.read(broker,
 271                     LogicalDatastoreType.CONFIGURATION,
 272                     netsIdentifier);
 273             NetworksBuilder builder = null;
 274             if (optionalNets.isPresent()) {
 275                 builder = new NetworksBuilder(optionalNets.get());
 276             } else {
 277                 logger.error("External Network " + extNetId.getValue() +
 278                         " not present in the NVPN datamodel");
 279                 return;
 280             }
 281             List<Uuid> rtrList = builder.getRouterIds();
 282             if (rtrList == null) {
 283                 rtrList = new ArrayList<Uuid>();
 284             }
 285             rtrList.add(routerId);
 286             builder.setRouterIds(rtrList);
 287
 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());
 296         } finally {
 297             //if (isLockAcquired) {
 298             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 299             //}
 300         }
 301     }
 302
 303     public void removeExternalNetworkFromRouter(Uuid origExtNetId, Router update) {
 304         Uuid routerId = update.getUuid();
 305
 306         // Remove the router to the ExtRouters list
 307         removeExternalRouter(origExtNetId, update, broker);
 308
 309         // Remove the router from the ExternalNetworks list
 310         InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
 311                 child(Networks.class, new NetworksKey(origExtNetId)).build();
 312
 313         try {
 314             Optional<Networks> optionalNets = NeutronvpnUtils.read(broker,
 315                     LogicalDatastoreType.CONFIGURATION,
 316                     netsIdentifier);
 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());
 328                 }
 329             }
 330         } catch (Exception ex) {
 331             logger.error("Removing externalnetwork " + origExtNetId.getValue() +
 332                     " from router " + routerId + " failed " + ex.getMessage());
 333         } finally {
 334             //if (isLockAcquired) {
 335             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 336             //}
 337         }
 338     }
 339
 340     public void addExternalNetworkToVpn(Network network, Uuid vpnId) {
 341         Uuid extNetId = network.getUuid();
 342
 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();
 346
 347         try {
 348             Optional<Networks> optionalNets = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 349                     netsIdentifier);
 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());
 354             } else {
 355                 logger.error("External Network " + extNetId.getValue() +
 356                         " not present in the NVPN datamodel");
 357                 return;
 358             }
 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");
 366
 367         } catch (Exception ex) {
 368             logger.error("Attaching VPN-ID to externalnetwork"+ extNetId.getValue() +" failed with " + ex.getMessage());
 369         } finally {
 370             //if (isLockAcquired) {
 371             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 372             //}
 373         }
 374     }
 375
 376     public void removeExternalNetworkFromVpn(Network network) {
 377         Uuid extNetId = network.getUuid();
 378
 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();
 382
 383         try {
 384             Optional<Networks> optionalNets = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 385                     netsIdentifier);
 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());
 390             } else {
 391                 logger.error("External Network " + extNetId.getValue() + " not present in the NVPN datamodel");
 392                 return;
 393             }
 394
 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");
 402
 403         } catch (Exception ex) {
 404             logger.error("Removing VPN-ID from externalnetworks " + extNetId.getValue() + "failed with " + ex.getMessage());
 405         } finally {
 406             //if (isLockAcquired) {
 407             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 408             //}
 409         }
 410     }
 411
 412     private void addExternalRouter(Router update, DataBroker broker) {
 413         Uuid routerId = update.getUuid();
 414         Uuid extNetId = update.getExternalGatewayInfo().getExternalNetworkId();
 415
 416         // Create and add Routers object for this Router to the ExtRouters list
 417
 418         // Create a Routers object
 419         InstanceIdentifier<Routers> routersIdentifier = InstanceIdentifier.builder(ExtRouters.class).
 420                 child(Routers.class, new RoutersKey(routerId.getValue())).build();
 421
 422         try {
 423             Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
 424                     LogicalDatastoreType.CONFIGURATION,
 425                     routersIdentifier);
 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());
 430             } else {
 431                 builder = new RoutersBuilder().setKey(new RoutersKey(routerId.getValue()));
 432             }
 433             if (builder != null) {
 434                 builder.setRouterName(routerId.getValue());
 435             }
 436             if (builder != null) {
 437                 builder.setNetworkId(extNetId);
 438             }
 439             if (builder != null) {
 440                 builder.setEnableSnat(update.getExternalGatewayInfo().isEnableSnat());
 441             }
 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());
 446                 }
 447                 builder.setExternalIps(ext_fixed_ips);
 448             }
 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");
 457
 458         } catch (Exception ex) {
 459             logger.error("Creation of extrouters failed for router " + routerId.getValue() + " failed with " + ex.getMessage());
 460         } finally {
 461             //if (isLockAcquired) {
 462             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 463             //}
 464         }
 465     }
 466
 467     private void removeExternalRouter(Uuid extNetId, Router update, DataBroker broker) {
 468         Uuid routerId = update.getUuid();
 469
 470         InstanceIdentifier<Routers> routersIdentifier = InstanceIdentifier.builder(ExtRouters.class).
 471                 child(Routers.class, new RoutersKey(routerId.getValue())).build();
 472
 473         try {
 474             Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
 475                     LogicalDatastoreType.CONFIGURATION,
 476                     routersIdentifier);
 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 ");
 484             }
 485         } catch (Exception ex) {
 486             logger.error("Removing extrouter " + routerId.getValue() + " from extrouters " + "failed with " + ex.getMessage());
 487         } finally {
 488             //if (isLockAcquired) {
 489             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 490             //}
 491         }
 492     }
 493
 494     private void handleExternalFixedIpsForRouter(Router update, DataBroker broker) {
 495         Uuid routerId = update.getUuid();
 496
 497         InstanceIdentifier<Routers> routersIdentifier = InstanceIdentifier.builder(ExtRouters.class).
 498                 child(Routers.class, new RoutersKey(routerId.getValue())).build();
 499
 500         try {
 501             Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
 502                     LogicalDatastoreType.CONFIGURATION,
 503                     routersIdentifier);
 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());
 511                     }
 512                     builder.setExternalIps(ext_fixed_ips);
 513                 }
 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");
 519             }
 520         } catch (Exception ex) {
 521             logger.error("Updating extfixedips for " + routerId.getValue() + " in extrouters failed with " + ex.getMessage());
 522         } finally {
 523             //if (isLockAcquired) {
 524             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 525             //}
 526         }
 527     }
 528
 529     public void handleSubnetsForExternalRouter(Uuid routerId, DataBroker broker) {
 530
 531         InstanceIdentifier<Routers> routersIdentifier = InstanceIdentifier.builder(ExtRouters.class).
 532                 child(Routers.class, new RoutersKey(routerId.getValue())).build();
 533
 534         try {
 535             Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
 536                     LogicalDatastoreType.CONFIGURATION,
 537                     routersIdentifier);
 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());
 543             } else {
 544                 logger.info("No Routers element found for router name " + routerId.getValue());
 545                 return;
 546             }
 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");
 555
 556         } catch (Exception ex) {
 557             logger.error("Updation of internal subnets for extrouters failed for router " + routerId.getValue() + " with " + ex.getMessage());
 558         } finally {
 559             //if (isLockAcquired) {
 560             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 561             //}
 562         }
 563     }
 564
 565     private void handleSnatSettingChangeForRouter(Router update, DataBroker broker) {
 566         Uuid routerId = update.getUuid();
 567
 568         InstanceIdentifier<Routers> routersIdentifier = InstanceIdentifier.builder(ExtRouters.class).
 569                 child(Routers.class, new RoutersKey(routerId.getValue())).build();
 570
 571         try {
 572             Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
 573                     LogicalDatastoreType.CONFIGURATION,
 574                     routersIdentifier);
 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());
 580             } else {
 581                 logger.trace("No Routers element found for router name " + routerId.getValue());
 582                 return;
 583             }
 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");
 591
 592         } catch (Exception ex) {
 593             logger.error("Updation of snat for extrouters failed for router " + routerId.getValue() + " with " + ex.getMessage());
 594         } finally {
 595             //if (isLockAcquired) {
 596             //    NeutronvpnUtils.unlock(lockManager, extNetId.getValue());
 597             //}
 598         }
 599     }
 600 }