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