Add Tunnel configuration

Yang changes to configure tunnels [including bfd]
Code to store tunnels information in Operational DataStore.
Code to configure tunnels

Change-Id: Ibd882c6737305af9931488e4cda394e92bcdaf91
Signed-off-by: Vishal Thapar <vishal.thapar@ericsson.com>

diff --git a/hwvtepsouthbound/hwvtepsouthbound-api/src/main/yang/hwvtep.yang b/hwvtepsouthbound/hwvtepsouthbound-api/src/main/yang/hwvtep.yang
index 8261124b58531dbc60ed8c1d3aa8d04948d13d3f..1041c86300a933c861374e661a2c0bd3129919db 100644 (file)
--- a/hwvtepsouthbound/hwvtepsouthbound-api/src/main/yang/hwvtep.yang
+++ b/hwvtepsouthbound/hwvtepsouthbound-api/src/main/yang/hwvtep.yang
@@ -159,6 +159,7 @@ module hwvtep {
             }
         }
         list tunnels {
+            key "local-locator-ref remote-locator-ref";
             uses hwvtep-tunnel-attributes ;
         }
     }

diff --git a/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/HwvtepOperationalState.java b/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/HwvtepOperationalState.java
index 09608dfd925b6fe315eb8d3359eba33aec9f8e84..58de15991d663c11c22c9f62bf575f5c7785779f 100644 (file)
--- a/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/HwvtepOperationalState.java
+++ b/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/HwvtepOperationalState.java
@@ -36,11 +36,14 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hw
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacs;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacsKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Switches;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.Tunnels;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelsKey;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 
@@ -139,6 +142,26 @@ public class HwvtepOperationalState {
         return Optional.absent();
     }
 
+    public Optional<Tunnels> getTunnels(InstanceIdentifier<?> iid, TunnelsKey tunnelsKey) {
+        Preconditions.checkNotNull(iid);
+        Optional<PhysicalSwitchAugmentation> psOptional = getPhysicalSwitchAugmentation(iid);
+        if (psOptional.isPresent()) {
+            PhysicalSwitchAugmentation psAugmentation = psOptional.get();
+            List<Tunnels> tunnelList = null;
+            if (psAugmentation != null) {
+                tunnelList = psAugmentation.getTunnels();
+            }
+            if (tunnelList != null) {
+                for (Tunnels tunnel: tunnelList) {
+                    if (tunnel.getKey().equals(tunnelsKey)) {
+                        return Optional.fromNullable(tunnel);
+                    }
+                }
+            }
+        }
+        return Optional.absent();
+    }
+
     public Optional<HwvtepPhysicalPortAugmentation> getPhysicalPortAugmentation(InstanceIdentifier<?> iid,
             HwvtepNodeName hwvtepNodeName) {
         Preconditions.checkNotNull(iid);
@@ -264,7 +287,12 @@ public class HwvtepOperationalState {
         Optional<LogicalSwitches> lswitch = HwvtepSouthboundUtil.readNode(transaction, iid);
         return lswitch;
     }
-    
+
+    public Optional<Tunnels> getTunnels(InstanceIdentifier<Tunnels> iid) {
+        Optional<Tunnels> tunnels = HwvtepSouthboundUtil.readNode(transaction, iid);
+        return tunnels;
+    }
+
     public ReadWriteTransaction getReadWriteTransaction() {
         return transaction;
     }

diff --git a/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/PhysicalSwitchUpdateCommand.java b/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/PhysicalSwitchUpdateCommand.java
index 86ad47334a6e5bf0062aa33fee208e7d2db46c48..d3ff95871419a17adf1db361b6d52ee33b9edb5c 100644 (file)
--- a/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/PhysicalSwitchUpdateCommand.java
+++ b/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/PhysicalSwitchUpdateCommand.java
@@ -26,10 +26,14 @@ import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
 import org.opendaylight.ovsdb.schema.hardwarevtep.Global;
 import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalSwitch;
+import org.opendaylight.ovsdb.schema.hardwarevtep.Tunnel;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentation;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.ManagementIps;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.Tunnels;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -75,7 +79,7 @@ public class PhysicalSwitchUpdateCommand extends AbstractTransactCommand {
         setDescription(physicalSwitch, physicalSwitchAugmentation);
         setManagementIps(physicalSwitch, physicalSwitchAugmentation);
         setTunnuleIps(physicalSwitch, physicalSwitchAugmentation);
-        setTunnels(physicalSwitch, physicalSwitchAugmentation);
+        setTunnels(transaction, iid, physicalSwitch, physicalSwitchAugmentation);
         if (!operationalPhysicalSwitchOptional.isPresent()) {
             //create a physical switch
             setName(physicalSwitch, physicalSwitchAugmentation, operationalPhysicalSwitchOptional);
@@ -136,8 +140,61 @@ public class PhysicalSwitchUpdateCommand extends AbstractTransactCommand {
         }
     }
 
-    private void setTunnels(PhysicalSwitch physicalSwitch, PhysicalSwitchAugmentation physicalSwitchAugmentation) {
-        //TODO
+    @SuppressWarnings("unchecked")
+    private void setTunnels(TransactionBuilder transaction, InstanceIdentifier<Node> iid,
+                    PhysicalSwitch physicalSwitch, PhysicalSwitchAugmentation physicalSwitchAugmentation) {
+        //TODO: revisit this code for optimizations
+        //TODO: needs more testing
+        if(physicalSwitchAugmentation.getTunnels() != null) {
+            Set<UUID> tunnels = Sets.newHashSet();
+            for(Tunnels tunnel: physicalSwitchAugmentation.getTunnels()) {
+                Optional<Tunnels> opTunnelOpt = getOperationalState().getTunnels(iid, tunnel.getKey());
+                Tunnel newTunnel = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Tunnel.class);
+                String tunnelUuid = null;
+                if(!opTunnelOpt.isPresent()) {
+                    tunnelUuid = "Tunnel_" + HwvtepSouthboundMapper.getRandomUUID();
+                } else {
+                    tunnelUuid = opTunnelOpt.get().getTunnelUuid().getValue();
+                }
+                UUID localUUID = getLocatorUUID(transaction,
+                                (InstanceIdentifier<TerminationPoint>) tunnel.getLocalLocatorRef().getValue());
+                UUID remoteUUID = getLocatorUUID(transaction,
+                                (InstanceIdentifier<TerminationPoint>) tunnel.getRemoteLocatorRef().getValue());
+                if(localUUID != null && remoteUUID != null) {
+                    // local and remote must exist
+                    newTunnel.setLocal(localUUID);
+                    newTunnel.setRemote(remoteUUID);
+                    //TODO Set BFD Params
+                    transaction.add(op.insert(newTunnel).withId(tunnelUuid));
+                    tunnels.add(new UUID(tunnelUuid));
+                }
+            }
+            physicalSwitch.setTunnels(tunnels);
+        }
+    }
+
+    private UUID getLocatorUUID(TransactionBuilder transaction, InstanceIdentifier<TerminationPoint> iid) {
+        UUID locatorUUID = null;
+        Optional<HwvtepPhysicalLocatorAugmentation> opLocOptional =
+                        getOperationalState().getPhysicalLocatorAugmentation(iid);
+        if (opLocOptional.isPresent()) {
+            // Get Locator UUID from operational
+            HwvtepPhysicalLocatorAugmentation locatorAug = opLocOptional.get();
+            locatorUUID = new UUID(locatorAug.getPhysicalLocatorUuid().getValue());
+        } else {
+            // TODO/FIXME: Not in operational, do we create a new one?
+            LOG.warn("Trying to create tunnel without creating physical locators first");
+            Optional<TerminationPoint> confLocOptional =
+                            TransactUtils.readNodeFromConfig(getOperationalState().getReadWriteTransaction(), iid);
+            if (confLocOptional.isPresent()) {
+                HwvtepPhysicalLocatorAugmentation locatorAugmentation =
+                                confLocOptional.get().getAugmentation(HwvtepPhysicalLocatorAugmentation.class);
+                locatorUUID = TransactUtils.createPhysicalLocator(transaction, locatorAugmentation);
+            } else {
+                LOG.warn("Unable to find endpoint for tunnel. Endpoint indentifier is {}", iid);
+            }
+        }
+        return locatorUUID;
     }
 
     private Map<InstanceIdentifier<Node>, PhysicalSwitchAugmentation> extractCreated(
@@ -179,4 +236,5 @@ public class PhysicalSwitchUpdateCommand extends AbstractTransactCommand {
         }
         return result;
     }
+
 }
\ No newline at end of file

diff --git a/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/TunnelUpdateCommand.java b/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/TunnelUpdateCommand.java
index fc524aeda359503f096b30972714d265f2922a17..c4e303e68e3fc50e8b77bbcd0ef2a349e51a82b2 100644 (file)
--- a/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/TunnelUpdateCommand.java
+++ b/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/TunnelUpdateCommand.java
@@ -26,6 +26,6 @@ public class TunnelUpdateCommand extends AbstractTransactCommand {
 
     @Override
     public void execute(TransactionBuilder transaction) {
-        //TODO
+        //FIXME: Handling it as part of PhysicalSwitchUpdate. Do we need this?
     }
 }

diff --git a/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transactions/md/PhysicalSwitchUpdateCommand.java b/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transactions/md/PhysicalSwitchUpdateCommand.java
index 7a44d5a95e815953eadcd164e774145e4a588863..04553b02d86a195471dee652734e1cc67bab5ebf 100644 (file)
--- a/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transactions/md/PhysicalSwitchUpdateCommand.java
+++ b/hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transactions/md/PhysicalSwitchUpdateCommand.java
@@ -12,6 +12,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+
 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
@@ -44,6 +45,12 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hw
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelIpsKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.Tunnels;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdLocalConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdLocalConfigsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdParams;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdParamsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdRemoteConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdRemoteConfigsBuilder;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
@@ -91,6 +98,7 @@ public class PhysicalSwitchUpdateCommand extends AbstractTransactionCommand {
             transaction.merge(LogicalDatastoreType.OPERATIONAL, psIid, psNode);
             // TODO: Delete entries that are no longer needed
             // TODO: Deletion of tunnels
+            // TODO: Deletion of Tunnel BFD config and params
         }
     }
 
@@ -128,9 +136,11 @@ public class PhysicalSwitchUpdateCommand extends AbstractTransactionCommand {
                                     HwvtepSouthboundMapper.createInstanceIdentifier(node.getNodeId()), pLoc);
                     tBuilder.setLocalLocatorRef(new HwvtepPhysicalLocatorRef(tpPath));
                 }
-                // TODO bfdconfiglocal
-                // TODO bfdconfigremote
-                // TODO bfdparams
+
+                setBfdLocalConfigs(tBuilder, tunnel);
+                setBfdRemoteConfigs(tBuilder, tunnel);
+                setBfdParams(tBuilder, tunnel);
+
                 if (tunnel.getRemoteColumn().getData() != null) {
                     PhysicalLocator pLoc = updatedPLocRows.get(tunnel.getRemoteColumn().getData());
                     InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint> tpPath =
@@ -145,6 +155,64 @@ public class PhysicalSwitchUpdateCommand extends AbstractTransactionCommand {
 
     }
 
+    private void setBfdLocalConfigs(TunnelsBuilder tBuilder, Tunnel tunnel) {
+        Map<String, String> localConfigs = tunnel.getBfdConfigLocalColumn().getData();
+        if(localConfigs != null && !localConfigs.isEmpty()) {
+            Set<String> localConfigKeys = localConfigs.keySet();
+            List<BfdLocalConfigs> localConfigsList = new ArrayList<>();
+            String localConfigValue = null;
+            for(String localConfigKey: localConfigKeys) {
+                localConfigValue = localConfigs.get(localConfigKey);
+                if(localConfigValue != null && localConfigKey != null) {
+                    localConfigsList.add(new BfdLocalConfigsBuilder()
+                        .setBfdLocalConfigKey(localConfigKey)
+                        .setBfdLocalConfigValue(localConfigValue)
+                        .build());
+                }
+            }
+            tBuilder.setBfdLocalConfigs(localConfigsList);
+        }
+    }
+
+    private void setBfdRemoteConfigs(TunnelsBuilder tBuilder, Tunnel tunnel) {
+        Map<String, String> remoteConfigs = tunnel.getBfdConfigRemoteColumn().getData();
+        if(remoteConfigs != null && !remoteConfigs.isEmpty()) {
+            Set<String> remoteConfigKeys = remoteConfigs.keySet();
+            List<BfdRemoteConfigs> remoteConfigsList = new ArrayList<>();
+            String remoteConfigValue = null;
+            for(String remoteConfigKey: remoteConfigKeys) {
+                remoteConfigValue = remoteConfigs.get(remoteConfigKey);
+                if(remoteConfigValue != null && remoteConfigKey != null) {
+                    remoteConfigsList.add(new BfdRemoteConfigsBuilder()
+                        .setBfdRemoteConfigKey(remoteConfigKey)
+                        .setBfdRemoteConfigValue(remoteConfigValue)
+                        .build());
+                }
+            }
+            tBuilder.setBfdRemoteConfigs(remoteConfigsList);
+        }
+    }
+
+
+    private void setBfdParams(TunnelsBuilder tBuilder, Tunnel tunnel) {
+        Map<String, String> params = tunnel.getBfdParamsColumn().getData();
+        if(params != null && !params.isEmpty()) {
+            Set<String> paramKeys = params.keySet();
+            List<BfdParams> paramsList = new ArrayList<>();
+            String paramValue = null;
+            for(String paramKey: paramKeys) {
+                paramValue = params.get(paramKey);
+                if(paramValue != null && paramKey != null) {
+                    paramsList.add(new BfdParamsBuilder()
+                        .setBfdParamKey(paramKey)
+                        .setBfdParamValue(paramValue)
+                        .build());
+                }
+            }
+            tBuilder.setBfdParams(paramsList);
+        }
+    }
+
     private void setManagedBy(PhysicalSwitchAugmentationBuilder psAugmentationBuilder) {
         InstanceIdentifier<Node> connectionNodePath = getOvsdbConnectionInstance().getInstanceIdentifier();
         psAugmentationBuilder.setManagedBy(new HwvtepGlobalRef(connectionNodePath));