NeutronVpn : Added support for NN v0.6.0 subnet-network mapping

Also added isTraceEnabled checks wherever missing.

Node created when the first subnet is associated to network, deleted when
last subnet is dissociated.

Change-Id: I5cd9c38fd943534c225c81637fc44dcda318863d
Signed-off-by: Abhinav Gupta <abhinav.gupta@ericsson.com>

diff --git a/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/vpnservice/neutronvpn/NeutronSubnetChangeListener.java b/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/vpnservice/neutronvpn/NeutronSubnetChangeListener.java
index 5eceab30fd7829896e8489a0577acd3a02383b31..6a1c05a4d45863485b78d950e5300cbfba0cd148 100644 (file)
--- a/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/vpnservice/neutronvpn/NeutronSubnetChangeListener.java
+++ b/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/vpnservice/neutronvpn/NeutronSubnetChangeListener.java
@@ -13,7 +13,6 @@ import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.vpnservice.mdsalutil.AbstractDataChangeListener;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.Subnets;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
@@ -65,17 +64,18 @@ public class NeutronSubnetChangeListener extends AbstractDataChangeListener<Subn
 
     @Override
     protected void add(InstanceIdentifier<Subnet> identifier, Subnet input) {
-        LOG.trace("Adding Subnet : key: " + identifier + ", value=" + input);
-        nvpnManager.updateSubnetNode(input.getUuid(), input.getTenantId(), input.getNetworkId(), null, null, null);
+        if (LOG.isTraceEnabled()) {
+            LOG.trace("Adding Subnet : key: " + identifier + ", value=" + input);
+        }
+        nvpnManager.handleNeutronSubnetCreated(input.getUuid(), input.getNetworkId(), input.getTenantId());
     }
 
     @Override
     protected void remove(InstanceIdentifier<Subnet> identifier, Subnet input) {
-        LOG.trace("Removing subnet : key: " + identifier + ", value=" + input);
-        Uuid vpnId = NeutronvpnUtils.getVpnForNetwork(broker, input.getNetworkId());
-        if (vpnId != null) {
-            nvpnManager.removeSubnetFromVpn(vpnId, input.getUuid());
+        if (LOG.isTraceEnabled()) {
+            LOG.trace("Removing subnet : key: " + identifier + ", value=" + input);
         }
+        nvpnManager.handleNeutronSubnetDeleted(input.getUuid(), input.getNetworkId(), null);
     }
 
     @Override
@@ -84,6 +84,6 @@ public class NeutronSubnetChangeListener extends AbstractDataChangeListener<Subn
             LOG.trace("Updating Subnet : key: " + identifier + ", original value=" + original + ", update value=" +
                     update);
         }
-        nvpnManager.updateSubnetNode(update.getUuid(), update.getTenantId(), update.getNetworkId(), null, null, null);
+        nvpnManager.handleNeutronSubnetUpdated(update.getUuid(), update.getNetworkId(), update.getTenantId());
     }
 }

diff --git a/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/vpnservice/neutronvpn/NeutronvpnManager.java b/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/vpnservice/neutronvpn/NeutronvpnManager.java
index 3a591375445e182e6d70ca654885a63ebf5527aa..48959211d91b995ae237bc13684cf0b0031183e4 100644 (file)
--- a/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/vpnservice/neutronvpn/NeutronvpnManager.java
+++ b/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/vpnservice/neutronvpn/NeutronvpnManager.java
@@ -72,13 +72,14 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev15
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.L3vpnInstance;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.NeutronvpnService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.Subnetmaps;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.SubnetmapsBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.VpnMaps;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.VpnMapsBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.createl3vpn.input.L3vpn;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.getl3vpn.output.L3vpnInstances;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.getl3vpn.output
         .L3vpnInstancesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.networkmaps.NetworkMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.networkmaps.NetworkMapBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.networkmaps.NetworkMapKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.neutron.port.data
         .PortFixedipToPortNameBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.neutron.port.data
@@ -223,6 +224,63 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable {
         return subnetmap;
     }
 
+    private void createSubnetToNetworkMapping(Uuid subnetId, Uuid networkId) {
+        try {
+            InstanceIdentifier networkMapIdentifier = NeutronvpnUtils.buildNetworkMapIdentifier(networkId);
+            Optional<NetworkMap> optionalNetworkMap = read(LogicalDatastoreType.CONFIGURATION, networkMapIdentifier);
+            NetworkMapBuilder nwMapBuilder = null;
+            if (optionalNetworkMap.isPresent()) {
+                nwMapBuilder = new NetworkMapBuilder(optionalNetworkMap.get());
+            } else {
+                nwMapBuilder = new NetworkMapBuilder().setKey(new NetworkMapKey(networkId)).setNetworkId(networkId);
+                logger.debug("Adding a new network node in NetworkMaps DS for network {}", networkId.getValue());
+            }
+            List<Uuid> subnetIdList = nwMapBuilder.getSubnetIdList();
+            if (subnetIdList == null) {
+                subnetIdList = new ArrayList<>();
+            }
+            subnetIdList.add(subnetId);
+            nwMapBuilder.setSubnetIdList(subnetIdList);
+            MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, networkMapIdentifier, nwMapBuilder.build());
+            logger.debug("Created subnet-network mapping for subnet {} network {}", subnetId.getValue(),
+                    networkId.getValue());
+        } catch (Exception e) {
+            logger.error("Create subnet-network mapping failed for subnet {} network {}", subnetId.getValue(),
+                    networkId.getValue());
+        }
+    }
+
+    private void deleteSubnetToNetworkMapping(Uuid subnetId, Uuid networkId) {
+        try {
+            InstanceIdentifier networkMapIdentifier = NeutronvpnUtils.buildNetworkMapIdentifier(networkId);
+            Optional<NetworkMap> optionalNetworkMap = read(LogicalDatastoreType.CONFIGURATION, networkMapIdentifier);
+            if (optionalNetworkMap.isPresent()) {
+                NetworkMapBuilder nwMapBuilder = new NetworkMapBuilder(optionalNetworkMap.get());
+                List<Uuid> subnetIdList = nwMapBuilder.getSubnetIdList();
+                if (subnetIdList.remove(subnetId)) {
+                    if (subnetIdList.size() == 0) {
+                        MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, networkMapIdentifier);
+                        logger.debug("Deleted network node in NetworkMaps DS for network {}", subnetId.getValue(),
+                                networkId.getValue());
+                    } else {
+                        nwMapBuilder.setSubnetIdList(subnetIdList);
+                        MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, networkMapIdentifier,
+                                nwMapBuilder.build());
+                        logger.debug("Deleted subnet-network mapping for subnet {} network {}", subnetId.getValue(),
+                                networkId.getValue());
+                    }
+                } else {
+                    logger.error("Subnet {} is not mapped to network {}", subnetId.getValue(), networkId.getValue());
+                }
+            } else {
+                logger.error("network {} not present for subnet {} ", networkId, subnetId);
+            }
+        } catch (Exception e) {
+            logger.error("Delete subnet-network mapping failed for subnet {} network {}", subnetId.getValue(),
+                    networkId.getValue());
+        }
+    }
+
     private void updateVpnInstanceNode(String name, List<String> rd, List<String> irt, List<String> ert) {
 
         try {
@@ -284,15 +342,6 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable {
         }
     }
 
-    private void createVpnMapsNode() {
-        InstanceIdentifier<VpnMaps> vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build();
-        VpnMapsBuilder vpnMaps = new VpnMapsBuilder();
-        MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnMapsIdentifier, vpnMaps.build());
-        InstanceIdentifier<Subnetmaps> subnetmapsId = InstanceIdentifier.builder(Subnetmaps.class).build();
-        SubnetmapsBuilder subnetmaps = new SubnetmapsBuilder();
-        MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, subnetmapsId, subnetmaps.build());
-    }
-
     private void deleteVpnMapsNode(Uuid vpnid) {
         InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
                 .child(VpnMap.class, new VpnMapKey(vpnid)).build();
@@ -415,8 +464,8 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable {
             logger.error("Failed to delete interface {} due to the exception {}", name, e.getMessage());
         }
 
-        InstanceIdentifier id = NeutronvpnUtils.buildPortNameToPortUuidIdentifier(name);
-        MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, id);
+        InstanceIdentifier portIdentifier = NeutronvpnUtils.buildPortNameToPortUuidIdentifier(name);
+        MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, portIdentifier);
         logger.debug("name-uuid map for port with name: {}, uuid: {} deleted from NeutronPortData DS", name, port
                 .getUuid());
     }
@@ -446,7 +495,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable {
         if (routerId != null) {
             rtr = NeutronvpnUtils.getNeutronRouter(broker, routerId);
         }
-        // find all Subnets to which this port is associated
+        // find all subnets to which this port is associated
         List<FixedIps> ips = port.getFixedIps();
         // create adjacency list
         for (FixedIps ip : ips) {
@@ -508,7 +557,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable {
         Uuid vpnId = null;
         String name = NeutronvpnUtils.uuidToTapPortName(port.getUuid());
 
-        // find all Subnets to which this port is associated,
+        // find all subnets to which this port is associated
         List<FixedIps> ips = port.getFixedIps();
         for (FixedIps ip : ips) {
             String ipValue = ip.getIpAddress().getIpv4Address().getValue();
@@ -533,7 +582,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable {
         Uuid subnetId = null;
         Uuid vpnId = null;
 
-        // find all Subnets to which this port is associated,
+        // find all Subnets to which this port is associated
         List<FixedIps> ips = port.getFixedIps();
         for (FixedIps ip : ips) {
             String ipValue = ip.getIpAddress().getIpv4Address().getValue();
@@ -552,6 +601,34 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable {
         return vpnId;
     }
 
+    protected void handleNeutronSubnetCreated(Uuid subnetId, Uuid networkId, Uuid tenantId) {
+        updateSubnetNode(subnetId, tenantId, networkId, null, null, null);
+        if (networkId != null && NeutronvpnUtils.getNeutronNetwork(broker, networkId) != null) {
+            createSubnetToNetworkMapping(subnetId, networkId);
+        }
+    }
+
+    protected void handleNeutronSubnetDeleted(Uuid subnetId, Uuid networkId, Uuid tenantId) {
+        Uuid vpnId = NeutronvpnUtils.getVpnForNetwork(broker, networkId);
+        if (vpnId != null) {
+            removeSubnetFromVpn(vpnId, subnetId);
+        }
+        if (networkId != null)  {
+            deleteSubnetToNetworkMapping(subnetId, networkId);
+        }
+    }
+
+    protected void handleNeutronSubnetUpdated(Uuid subnetId, Uuid networkId, Uuid tenantId) {
+        Uuid oldNetworkId = NeutronvpnUtils.getSubnetmap(broker, subnetId).getNetworkId();
+        if (oldNetworkId != null && !oldNetworkId.equals(networkId)) {
+            deleteSubnetToNetworkMapping(subnetId, oldNetworkId);
+        }
+        if (networkId != null && !networkId.equals(oldNetworkId)) {
+            createSubnetToNetworkMapping(subnetId, networkId);
+        }
+        updateSubnetNode(subnetId, tenantId, networkId, null, null, null);
+    }
+
     protected void handleNeutronPortCreated(Port port) {
         logger.info("Of-port-interface creation");
         int portVlanId = NeutronvpnUtils.getVlanFromNeutronPort(port);
@@ -1009,7 +1086,7 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable {
                 if (NeutronvpnUtils.getNeutronNetwork(broker, nw) == null) {
                     failed.add(nw.getValue());
                 } else {
-                    List<Uuid> networkSubnets = NeutronvpnUtils.getNeutronNetworkSubnetIds(broker, nw);
+                    List<Uuid> networkSubnets = NeutronvpnUtils.getSubnetIdsFromNetworkId(broker, nw);
                     logger.debug("Adding network subnets...");
                     if (networkSubnets != null) {
                         for (Uuid subnet : networkSubnets) {
@@ -1032,10 +1109,12 @@ public class NeutronvpnManager implements NeutronvpnService, AutoCloseable {
                 if (NeutronvpnUtils.getNeutronNetwork(broker, nw) == null) {
                     failed.add(nw.getValue());
                 } else {
-                    List<Uuid> networkSubnets = NeutronvpnUtils.getNeutronNetworkSubnetIds(broker, nw);
+                    List<Uuid> networkSubnets = NeutronvpnUtils.getSubnetIdsFromNetworkId(broker, nw);
                     logger.debug("Removing network subnets...");
-                    for (Uuid subnet : networkSubnets) {
-                        removeSubnetFromVpn(vpn, subnet);
+                    if (networkSubnets != null) {
+                        for (Uuid subnet : networkSubnets) {
+                            removeSubnetFromVpn(vpn, subnet);
+                        }
                     }
                 }
             }

diff --git a/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/vpnservice/neutronvpn/NeutronvpnUtils.java b/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/vpnservice/neutronvpn/NeutronvpnUtils.java
index 12bd658358a20ab6417984a63b35da4373257503..993a465337852a2a0ab1c53124b37ad4539f8c8c 100644 (file)
--- a/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/vpnservice/neutronvpn/NeutronvpnUtils.java
+++ b/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/vpnservice/neutronvpn/NeutronvpnUtils.java
@@ -31,9 +31,13 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.lockmanager.rev1
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.lockmanager.rev150819.TryLockInputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.lockmanager.rev150819.UnlockInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.lockmanager.rev150819.UnlockInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.NetworkMaps;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.NeutronPortData;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.Subnetmaps;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.VpnMaps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.networkmaps.NetworkMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.networkmaps.NetworkMapKey;
+
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.neutron.port.data
         .PortFixedipToPortName;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.neutron.port.data
@@ -66,8 +70,7 @@ public class NeutronvpnUtils {
     private static final Logger logger = LoggerFactory.getLogger(NeutronvpnUtils.class);
 
     protected static Subnetmap getSubnetmap(DataBroker broker, Uuid subnetId) {
-        InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
-                child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
+        InstanceIdentifier id = buildSubnetMapIdentifier(subnetId);
         Optional<Subnetmap> sn = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 
         if (sn.isPresent()) {
@@ -153,6 +156,16 @@ public class NeutronvpnUtils {
         return null;
     }
 
+    protected static List<Uuid> getSubnetIdsFromNetworkId(DataBroker broker, Uuid networkId) {
+        InstanceIdentifier id = buildNetworkMapIdentifier(networkId);
+        Optional<NetworkMap> optionalNetworkMap = read(broker, LogicalDatastoreType.CONFIGURATION,
+                id);
+        if (optionalNetworkMap.isPresent()) {
+            return optionalNetworkMap.get().getSubnetIdList();
+        }
+        return null;
+    }
+
     //TODO
     //Will be done once integrated with TrunkPort Extensions
     protected static int getVlanFromNeutronPort(Port port) {
@@ -193,19 +206,6 @@ public class NeutronvpnUtils {
         return null;
     }
 
-    protected static List<Uuid> getNeutronNetworkSubnetIds(DataBroker broker, Uuid networkId) {
-
-        logger.debug("getNeutronNetworkSubnetIds for {}", networkId.getValue());
-        Network network = getNeutronNetwork(broker, networkId);
-        if (network != null) {
-            //TODO
-            //return network.getSubnets();
-        }
-        logger.debug("returning from getNeutronNetworkSubnetIds for {}", networkId.getValue());
-
-        return null;
-    }
-
     protected static List<Uuid> getNeutronRouterSubnetIds(DataBroker broker, Uuid routerId) {
         logger.info("getNeutronRouterSubnetIds for {}", routerId.getValue());
 
@@ -264,16 +264,26 @@ public class NeutronvpnUtils {
     }
 
     static InstanceIdentifier<PortNameToPortUuid> buildPortNameToPortUuidIdentifier(String portname) {
-        InstanceIdentifier<PortNameToPortUuid> id =
-                InstanceIdentifier.builder(NeutronPortData.class).child(PortNameToPortUuid.class, new
-                        PortNameToPortUuidKey(portname)).build();
+        InstanceIdentifier<PortNameToPortUuid> id = InstanceIdentifier.builder(NeutronPortData.class).child
+                (PortNameToPortUuid.class, new PortNameToPortUuidKey(portname)).build();
         return id;
     }
 
     static InstanceIdentifier<PortFixedipToPortName> buildFixedIpToPortNameIdentifier(String fixedIp) {
-        InstanceIdentifier<PortFixedipToPortName> id =
-                InstanceIdentifier.builder(NeutronPortData.class).child(PortFixedipToPortName.class, new
-                        PortFixedipToPortNameKey(fixedIp)).build();
+        InstanceIdentifier<PortFixedipToPortName> id = InstanceIdentifier.builder(NeutronPortData.class).child
+                (PortFixedipToPortName.class, new PortFixedipToPortNameKey(fixedIp)).build();
+        return id;
+    }
+
+    static InstanceIdentifier<NetworkMap> buildNetworkMapIdentifier(Uuid networkId) {
+        InstanceIdentifier<NetworkMap> id = InstanceIdentifier.builder(NetworkMaps.class).child(NetworkMap.class, new
+                NetworkMapKey(networkId)).build();
+        return id;
+    }
+
+    static InstanceIdentifier<Subnetmap> buildSubnetMapIdentifier(Uuid subnetId) {
+        InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class, new
+                SubnetmapKey(subnetId)).build();
         return id;
     }