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