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