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