vpnservice/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/netvirt/neutronvpn/NeutronvpnUtils.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
   9 package org.opendaylight.netvirt.neutronvpn;
  10
  11 import com.google.common.base.Optional;
  12
  13 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  14 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  15 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  16 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
  17 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
  18 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
  19 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  20 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  21 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  22 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExtRouters;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersKey;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.Routers;
  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.RouterKey;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeGre;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeVlan;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.NetworkKey;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortKey;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.portsecurity.rev150712.PortSecurityExtension;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.provider.ext.rev150712.NetworkProviderExtension;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.Subnets;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.SubnetKey;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TimeUnits;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockInput;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockInputBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockInput;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockInputBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NetworkMaps;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronPortData;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.VpnMaps;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMap;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMapKey;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.port.data.PortFixedipToPortName;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.port.data.PortFixedipToPortNameKey;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMap;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMapKey;
  62 import org.opendaylight.yangtools.yang.binding.DataObject;
  63 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  64 import org.opendaylight.yangtools.yang.common.RpcResult;
  65 import org.slf4j.Logger;
  66 import org.slf4j.LoggerFactory;
  67
  68 import java.util.ArrayList;
  69 import java.util.List;
  70 import java.util.concurrent.ConcurrentHashMap;
  71 import java.util.concurrent.ExecutionException;
  72 import java.util.concurrent.Future;
  73
  74 public class NeutronvpnUtils {
  75
  76     private static final Logger logger = LoggerFactory.getLogger(NeutronvpnUtils.class);
  77     public static ConcurrentHashMap<Uuid, Network> networkMap = new ConcurrentHashMap<Uuid, Network>();
  78     public static ConcurrentHashMap<Uuid, Router> routerMap = new ConcurrentHashMap<Uuid, Router>();
  79     public static ConcurrentHashMap<Uuid, Port> portMap = new ConcurrentHashMap<Uuid, Port>();
  80     public static ConcurrentHashMap<Uuid, Subnet> subnetMap = new ConcurrentHashMap<Uuid, Subnet>();
  81
  82     private NeutronvpnUtils() {
  83         throw new UnsupportedOperationException("Utility class should not be instantiated");
  84     }
  85
  86     protected static Subnetmap getSubnetmap(DataBroker broker, Uuid subnetId) {
  87         InstanceIdentifier id = buildSubnetMapIdentifier(subnetId);
  88         Optional<Subnetmap> sn = read(broker, LogicalDatastoreType.CONFIGURATION, id);
  89
  90         if (sn.isPresent()) {
  91             return sn.get();
  92         }
  93         return null;
  94     }
  95
  96     protected static VpnMap getVpnMap(DataBroker broker, Uuid id) {
  97         InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class).child(VpnMap.class,
  98                 new VpnMapKey(id)).build();
  99         Optional<VpnMap> optionalVpnMap = read(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
 100         if (optionalVpnMap.isPresent()) {
 101             return optionalVpnMap.get();
 102         }
 103         logger.error("getVpnMap failed, VPN {} not present", id.getValue());
 104         return null;
 105     }
 106
 107     protected static Uuid getVpnForNetwork(DataBroker broker, Uuid network) {
 108         InstanceIdentifier<VpnMaps> vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build();
 109         Optional<VpnMaps> optionalVpnMaps = read(broker, LogicalDatastoreType.CONFIGURATION, vpnMapsIdentifier);
 110         if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().getVpnMap() != null) {
 111             List<VpnMap> allMaps = optionalVpnMaps.get().getVpnMap();
 112             for (VpnMap vpnMap : allMaps) {
 113                 List<Uuid> netIds = vpnMap.getNetworkIds();
 114                 if ((netIds != null) && (netIds.contains(network))) {
 115                     return vpnMap.getVpnId();
 116                 }
 117             }
 118         }
 119         return null;
 120     }
 121
 122     protected static Uuid getVpnForSubnet(DataBroker broker, Uuid subnetId) {
 123         InstanceIdentifier<Subnetmap> subnetmapIdentifier = buildSubnetMapIdentifier(subnetId);
 124         Optional<Subnetmap> optionalSubnetMap = read(broker, LogicalDatastoreType.CONFIGURATION, subnetmapIdentifier);
 125         if (optionalSubnetMap.isPresent()) {
 126             return optionalSubnetMap.get().getVpnId();
 127         }
 128         return null;
 129     }
 130
 131     // @param external vpn - true if external vpn being fetched, false for internal vpn
 132     protected static Uuid getVpnForRouter(DataBroker broker, Uuid routerId, Boolean externalVpn) {
 133         InstanceIdentifier<VpnMaps> vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build();
 134         Optional<VpnMaps> optionalVpnMaps = read(broker, LogicalDatastoreType.CONFIGURATION,
 135                 vpnMapsIdentifier);
 136         if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().getVpnMap() != null) {
 137             List<VpnMap> allMaps = optionalVpnMaps.get().getVpnMap();
 138             if (routerId != null) {
 139                 for (VpnMap vpnMap : allMaps) {
 140                     if (routerId.equals(vpnMap.getRouterId())) {
 141                         if (externalVpn) {
 142                             if (!routerId.equals(vpnMap.getVpnId())) {
 143                                 return vpnMap.getVpnId();
 144                             }
 145                         } else {
 146                             if (routerId.equals(vpnMap.getVpnId())) {
 147                                 return vpnMap.getVpnId();
 148                             }
 149                         }
 150                     }
 151                 }
 152             }
 153         }
 154         return null;
 155     }
 156
 157     protected static Uuid getRouterforVpn(DataBroker broker, Uuid vpnId) {
 158         InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
 159                 .child(VpnMap.class, new VpnMapKey(vpnId)).build();
 160         Optional<VpnMap> optionalVpnMap = read(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
 161         if (optionalVpnMap.isPresent()) {
 162             VpnMap vpnMap = optionalVpnMap.get();
 163             return vpnMap.getRouterId();
 164         }
 165         return null;
 166     }
 167
 168     protected static String getNeutronPortNamefromPortFixedIp(DataBroker broker, String fixedIp) {
 169         InstanceIdentifier id = buildFixedIpToPortNameIdentifier(fixedIp);
 170         Optional<PortFixedipToPortName> portFixedipToPortNameData = read(broker, LogicalDatastoreType.CONFIGURATION,
 171                 id);
 172         if (portFixedipToPortNameData.isPresent()) {
 173             return portFixedipToPortNameData.get().getPortName();
 174         }
 175         return null;
 176     }
 177
 178     protected static List<Uuid> getSubnetIdsFromNetworkId(DataBroker broker, Uuid networkId) {
 179         InstanceIdentifier id = buildNetworkMapIdentifier(networkId);
 180         Optional<NetworkMap> optionalNetworkMap = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 181         if (optionalNetworkMap.isPresent()) {
 182             return optionalNetworkMap.get().getSubnetIdList();
 183         }
 184         return null;
 185     }
 186
 187     protected static Router getNeutronRouter(DataBroker broker, Uuid routerId) {
 188         Router router = null;
 189         router = routerMap.get(routerId);
 190         if (router != null) {
 191             return router;
 192         }
 193         InstanceIdentifier<Router> inst = InstanceIdentifier.create(Neutron.class).child(Routers.class).child(Router
 194                 .class, new RouterKey(routerId));
 195         Optional<Router> rtr = read(broker, LogicalDatastoreType.CONFIGURATION, inst);
 196         if (rtr.isPresent()) {
 197             router = rtr.get();
 198         }
 199         return router;
 200     }
 201
 202     protected static Network getNeutronNetwork(DataBroker broker, Uuid networkId) {
 203         Network network = null;
 204         network = networkMap.get(networkId);
 205         if (network != null) {
 206             return network;
 207         }
 208         logger.debug("getNeutronNetwork for {}", networkId.getValue());
 209         InstanceIdentifier<Network> inst = InstanceIdentifier.create(Neutron.class).child(Networks.class).child
 210                 (Network.class, new NetworkKey(networkId));
 211         Optional<Network> net = read(broker, LogicalDatastoreType.CONFIGURATION, inst);
 212         if (net.isPresent()) {
 213             network = net.get();
 214         }
 215         return network;
 216     }
 217
 218     protected static List<Uuid> getNeutronRouterSubnetIds(DataBroker broker, Uuid routerId) {
 219         logger.info("getNeutronRouterSubnetIds for {}", routerId.getValue());
 220
 221         List<Uuid> subnetIdList = new ArrayList<>();
 222         Ports ports = getNeutrounPorts(broker);
 223         if (ports != null && ports.getPort() != null) {
 224             for (Port port: ports.getPort()) {
 225                 if ((port.getDeviceOwner() != null) && (port.getDeviceId() != null)) {
 226                     if (port.getDeviceOwner().equals(NeutronConstants.DEVICE_OWNER_ROUTER_INF) &&
 227                             port.getDeviceId().equals(routerId.getValue())) {
 228                         for (FixedIps portIp: port.getFixedIps()) {
 229                             subnetIdList.add(portIp.getSubnetId());
 230                         }
 231                     }
 232                 }
 233             }
 234         }
 235         /*Router router = getNeutronRouter(broker, routerId);
 236         if (router != null) {
 237             List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router
 238                     .Interfaces> interfacesList = router.getInterfaces();
 239             if (interfacesList != null) {
 240                 for (org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers
 241                         .router.Interfaces interfaces : interfacesList) {
 242                     subnetIdList.add(interfaces.getSubnetId());
 243                 }
 244             }
 245         }*/
 246         logger.info("returning from getNeutronRouterSubnetIds for {}", routerId.getValue());
 247         return subnetIdList;
 248     }
 249
 250     protected static Ports getNeutrounPorts(DataBroker broker) {
 251         InstanceIdentifier<Ports> inst = InstanceIdentifier.create(Neutron.class).child(Ports.class);
 252         Optional<Ports> ports = read(broker, LogicalDatastoreType.CONFIGURATION, inst);
 253         if (ports.isPresent()) {
 254             return ports.get();
 255         }
 256         return null;
 257     }
 258
 259     protected static Port getNeutronPort(DataBroker broker, Uuid portId) {
 260         Port prt = null;
 261         prt = portMap.get(portId);
 262         if (prt != null) {
 263             return prt;
 264         }
 265         logger.debug("getNeutronPort for {}", portId.getValue());
 266         InstanceIdentifier<Port> inst = InstanceIdentifier.create(Neutron.class).child(Ports.class).child(Port.class,
 267                 new PortKey(portId));
 268         Optional<Port> port = read(broker, LogicalDatastoreType.CONFIGURATION, inst);
 269         if (port.isPresent()) {
 270             prt = port.get();
 271         }
 272         return prt;
 273     }
 274     public static boolean isPortSecurityEnabled(Port port) {
 275         PortSecurityExtension portSecurity = port.getAugmentation(PortSecurityExtension.class);
 276         return (portSecurity != null && portSecurity.isPortSecurityEnabled() != null);
 277     }
 278
 279     public static Boolean getPortSecurityEnabled(Port port) {
 280         PortSecurityExtension portSecurity = port.getAugmentation(PortSecurityExtension.class);
 281         if (portSecurity != null) {
 282             return portSecurity.isPortSecurityEnabled();
 283         }
 284         return null;
 285     }
 286
 287     protected static Interface getOfPortInterface(DataBroker broker, Port port) {
 288         String name = port.getUuid().getValue();
 289         InstanceIdentifier interfaceIdentifier = NeutronvpnUtils.buildVlanInterfaceIdentifier(name);
 290         try {
 291             Optional<Interface> optionalInf = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 292                     interfaceIdentifier);
 293             if (optionalInf.isPresent()) {
 294                 return optionalInf.get();
 295             } else {
 296                 logger.error("Interface {} is not present", name);
 297             }
 298         } catch (Exception e) {
 299             logger.error("Failed to get interface {} due to the exception {}", name, e.getMessage());
 300         }
 301         return null;
 302     }
 303
 304     protected static Subnet getNeutronSubnet(DataBroker broker, Uuid subnetId) {
 305         Subnet subnet = null;
 306         subnet = subnetMap.get(subnetId);
 307         if (subnet != null) {
 308             return subnet;
 309         }
 310         InstanceIdentifier<Subnet> inst = InstanceIdentifier.create(Neutron.class).
 311                 child(Subnets.class).child(Subnet.class, new SubnetKey(subnetId));
 312         Optional<Subnet> sn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, inst);
 313
 314         if (sn.isPresent()) {
 315             subnet = sn.get();
 316         }
 317         return subnet;
 318     }
 319
 320     protected static String getVifPortName(Port port) {
 321         if (port == null || port.getUuid() == null) {
 322             logger.warn("Invalid Neutron port {}", port);
 323             return null;
 324         }
 325         String tapId = port.getUuid().getValue().substring(0, 11);
 326         String portNamePrefix = getPortNamePrefix(port);
 327         if (portNamePrefix != null) {
 328             return new StringBuilder().append(portNamePrefix).append(tapId).toString();
 329         }
 330         logger.debug("Failed to get prefix for port {}", port.getUuid());
 331         return null;
 332     }
 333
 334     protected static String getPortNamePrefix(Port port) {
 335         PortBindingExtension portBinding = port.getAugmentation(PortBindingExtension.class);
 336         if (portBinding == null || portBinding.getVifType() == null) {
 337             return null;
 338         }
 339         switch(portBinding.getVifType()) {
 340             case NeutronConstants.VIF_TYPE_VHOSTUSER:
 341                 return NeutronConstants.PREFIX_VHOSTUSER;
 342             case NeutronConstants.VIF_TYPE_OVS:
 343             case NeutronConstants.VIF_TYPE_DISTRIBUTED:
 344             case NeutronConstants.VIF_TYPE_BRIDGE:
 345             case NeutronConstants.VIF_TYPE_OTHER:
 346             case NeutronConstants.VIF_TYPE_MACVTAP:
 347                 return NeutronConstants.PREFIX_TAP;
 348             case NeutronConstants.VIF_TYPE_UNBOUND:
 349             case NeutronConstants.VIF_TYPE_BINDING_FAILED:
 350             default:
 351                 return null;
 352         }
 353     }
 354
 355     protected static boolean isPortVifTypeUpdated(Port original, Port updated) {
 356         return ((getPortNamePrefix(original) == null) && (getPortNamePrefix(updated) != null));
 357     }
 358
 359     protected static boolean lock(LockManagerService lockManager, String lockName) {
 360         TryLockInput input = new TryLockInputBuilder().setLockName(lockName).setTime(5L).setTimeUnit
 361                 (TimeUnits.Milliseconds).build();
 362         boolean islockAcquired = false;
 363         try {
 364             Future<RpcResult<Void>> result = lockManager.tryLock(input);
 365             if ((result != null) && (result.get().isSuccessful())) {
 366                 logger.debug("Acquired lock for {}", lockName);
 367                 islockAcquired = true;
 368             } else {
 369                 logger.error("Unable to acquire lock for  {}", lockName);
 370             }
 371         } catch (InterruptedException | ExecutionException e) {
 372             logger.error("Unable to acquire lock for  {}", lockName);
 373             throw new RuntimeException(String.format("Unable to acquire lock for %s", lockName), e.getCause());
 374         }
 375         return islockAcquired;
 376     }
 377
 378     protected static boolean unlock(LockManagerService lockManager, String lockName) {
 379         UnlockInput input = new UnlockInputBuilder().setLockName(lockName).build();
 380         boolean islockAcquired = false;
 381         try {
 382             Future<RpcResult<Void>> result = lockManager.unlock(input);
 383             if ((result != null) && (result.get().isSuccessful())) {
 384                 logger.debug("Unlocked {}", lockName);
 385                 islockAcquired = true;
 386             } else {
 387                 logger.error("Unable to unlock {}", lockName);
 388             }
 389         } catch (InterruptedException | ExecutionException e) {
 390             logger.error("Unable to unlock {}", lockName);
 391             throw new RuntimeException(String.format("Unable to unlock %s", lockName), e.getCause());
 392         }
 393         return islockAcquired;
 394     }
 395
 396     protected static Short getIPPrefixFromPort(DataBroker broker, Port port) {
 397         Short prefix = new Short((short) 0);
 398         String cidr = "";
 399         try {
 400             Uuid subnetUUID = port.getFixedIps().get(0).getSubnetId();
 401
 402             SubnetKey subnetkey = new SubnetKey(subnetUUID);
 403             InstanceIdentifier<Subnet> subnetidentifier = InstanceIdentifier.create(Neutron.class).child(Subnets
 404                     .class).child(Subnet.class, subnetkey);
 405             Optional<Subnet> subnet = read(broker, LogicalDatastoreType.CONFIGURATION,subnetidentifier);
 406             if (subnet.isPresent()) {
 407                 cidr = String.valueOf(subnet.get().getCidr().getValue());
 408                 // Extract the prefix length from cidr
 409                 String[] parts = cidr.split("/");
 410                 if ((parts.length == 2)) {
 411                     prefix = Short.valueOf(parts[1]);
 412                     return prefix;
 413                 } else {
 414                     logger.trace("Could not retrieve prefix from subnet CIDR");
 415                     System.out.println("Could not retrieve prefix from subnet CIDR");
 416                 }
 417             } else {
 418                 logger.trace("Unable to read on subnet datastore");
 419             }
 420         } catch (Exception e) {
 421             logger.error("Failed to retrieve IP prefix from port : ", e);
 422             System.out.println("Failed to retrieve IP prefix from port : " + e.getMessage());
 423         }
 424         return null;
 425     }
 426
 427     public static void addToNetworkCache(Network network) {
 428         networkMap.put(network.getUuid(),network);
 429     }
 430
 431     public static void removeFromNetworkCache(Network network) {
 432         networkMap.remove(network.getUuid());
 433     }
 434
 435     public static void addToRouterCache(Router router) {
 436         routerMap.put(router.getUuid(),router);
 437     }
 438
 439     public static void removeFromRouterCache(Router router) {
 440         routerMap.remove(router.getUuid());
 441     }
 442
 443     public static void addToPortCache(Port port) {
 444         portMap.put(port.getUuid(),port);
 445     }
 446
 447     public static void removeFromPortCache(Port port) {
 448         portMap.remove(port.getUuid());
 449     }
 450
 451     public static void addToSubnetCache(Subnet subnet) {
 452         subnetMap.put(subnet.getUuid(),subnet);
 453     }
 454
 455     public static void removeFromSubnetCache(Subnet subnet) {
 456         subnetMap.remove(subnet.getUuid());
 457     }
 458
 459     static InstanceIdentifier<PortFixedipToPortName> buildFixedIpToPortNameIdentifier(String fixedIp) {
 460         InstanceIdentifier<PortFixedipToPortName> id = InstanceIdentifier.builder(NeutronPortData.class).child
 461                 (PortFixedipToPortName.class, new PortFixedipToPortNameKey(fixedIp)).build();
 462         return id;
 463     }
 464
 465     static InstanceIdentifier<NetworkMap> buildNetworkMapIdentifier(Uuid networkId) {
 466         InstanceIdentifier<NetworkMap> id = InstanceIdentifier.builder(NetworkMaps.class).child(NetworkMap.class, new
 467                 NetworkMapKey(networkId)).build();
 468         return id;
 469     }
 470
 471     static InstanceIdentifier<VpnInterface> buildVpnInterfaceIdentifier(String ifName) {
 472         InstanceIdentifier<VpnInterface> id = InstanceIdentifier.builder(VpnInterfaces.class).
 473                 child(VpnInterface.class, new VpnInterfaceKey(ifName)).build();
 474         return id;
 475     }
 476
 477     static InstanceIdentifier<Subnetmap> buildSubnetMapIdentifier(Uuid subnetId) {
 478         InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class, new
 479                 SubnetmapKey(subnetId)).build();
 480         return id;
 481     }
 482
 483     static InstanceIdentifier<Interface> buildVlanInterfaceIdentifier(String interfaceName) {
 484         InstanceIdentifier<Interface> id = InstanceIdentifier.builder(Interfaces.class).child(Interface.class, new
 485                 InterfaceKey(interfaceName)).build();
 486         return id;
 487     }
 488
 489     static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext
 490             .routers.Routers> buildExtRoutersIdentifier(Uuid routerId) {
 491         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers
 492                 .Routers> id = InstanceIdentifier.builder(ExtRouters.class).child(org.opendaylight.yang.gen.v1.urn
 493                 .opendaylight.netvirt.natservice.rev160111.ext.routers.Routers.class,
 494                 new RoutersKey(routerId.getValue())).build();
 495         return id;
 496     }
 497
 498     static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
 499                                                    InstanceIdentifier<T> path) {
 500
 501         ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
 502
 503         Optional<T> result = Optional.absent();
 504         try {
 505             result = tx.read(datastoreType, path).get();
 506         } catch (Exception e) {
 507             throw new RuntimeException(e);
 508         }
 509
 510         return result;
 511     }
 512
 513     static boolean isNetworkTypeVlanOrGre(Network network) {
 514         NetworkProviderExtension npe = network.getAugmentation(NetworkProviderExtension.class);
 515         if (npe != null && npe.getNetworkType() != null) {
 516             if (npe.getNetworkType().isAssignableFrom(NetworkTypeVlan.class) ||
 517                     npe.getNetworkType().isAssignableFrom(NetworkTypeGre.class)) {
 518                 logger.trace("Network is of type {}", npe.getNetworkType());
 519                 return true;
 520             }
 521         }
 522         return false;
 523     }
 524 }