Auto-convert String IPs in Mapping

Change-Id: I9205ef0a86d9311f9d368e033ff8f983483d7e37
Signed-off-by: Lorand Jakab <lojakab@cisco.com>

diff --git a/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MultiSiteScenario.java b/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MultiSiteScenario.java
index f1472abfa9cc2b57bee2a23828a89e7372dadefc..2c282fcdc9b7895e71f4ebdb48852c4689ad3acc 100644 (file)
--- a/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MultiSiteScenario.java
+++ b/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MultiSiteScenario.java
@@ -17,10 +17,12 @@ import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenario
 
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+
 import org.apache.commons.lang3.ArrayUtils;
 import org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.Site;
 import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
@@ -28,11 +30,10 @@ import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingServic
 import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
 import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.InstanceIdType;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv4Binary;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
@@ -58,6 +59,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev15090
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import com.google.common.net.InetAddresses;
 
 /**
  * Contains methods for:
@@ -94,13 +96,13 @@ class MultiSiteScenario {
         this.lms = lms;
     }
 
-    private Ipv4Address verifyIpv4Address(final LocatorRecord locatorRecord) {
+    private Ipv4AddressBinary verifyIpv4Address(final LocatorRecord locatorRecord) {
         assertNotNull(locatorRecord);
         final Rloc rloc = locatorRecord.getRloc();
         assertNotNull(rloc);
         final Address address = rloc.getAddress();
-        assertTrue(address instanceof Ipv4);
-        return ((Ipv4) address).getIpv4();
+        assertTrue(address instanceof Ipv4Binary);
+        return ((Ipv4Binary) address).getIpv4Binary();
     }
 
     private List<LocatorRecord> verifyLocatorRecordExists(final MappingRecord mappingRecord) {
@@ -135,16 +137,16 @@ class MultiSiteScenario {
     }
 
     void setCommonAuthentication() {
-        Eid eid = LispAddressUtil.toEid(new Ipv4Prefix("0.0.0.0/0"), SITE_A.getVNI());
+        Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("0.0.0.0/0", SITE_A.getVNI());
         mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
 
-        eid = LispAddressUtil.toEid(new Ipv4Prefix("0.0.0.0/0"), SITE_D5.getVNI());
+        eid = LispAddressUtil.asIpv4PrefixBinaryEid("0.0.0.0/0", SITE_D5.getVNI());
         mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
         sleepForSeconds(1);
     }
 
     private Eid toEid(final String destSiteEidPrefix, final InstanceIdType vniValue, final int mask) {
-        return LispAddressUtil.toEid(new Ipv4Prefix(destSiteEidPrefix + "/" + mask), vniValue);
+        return LispAddressUtil.asIpv4PrefixBinaryEid(destSiteEidPrefix + "/" + mask, vniValue);
 
     }
 
@@ -174,8 +176,8 @@ class MultiSiteScenario {
     }
 
     void storeNorthMappingNegative(final Site dstSite, final MappingRecord.Action action) {
-        final Ipv4Prefix ipv4Prefix = new Ipv4Prefix(dstSite.getEidPrefix() + "/" + DEFAULT_NETWORK_MASK);
-        final Eid eidAsIpv4Prefix = LispAddressUtil.toEid(ipv4Prefix, dstSite.getVNI());
+        final Eid eidAsIpv4Prefix = LispAddressUtil.asIpv4PrefixBinaryEid(
+                dstSite.getEidPrefix() + "/" + DEFAULT_NETWORK_MASK, dstSite.getVNI());
 
         final MappingRecordBuilder mrbNegative = prepareMappingRecord(EidType.EID_WITH_PREFIX, null, dstSite);
         mrbNegative.setEid(eidAsIpv4Prefix);
@@ -186,8 +188,8 @@ class MultiSiteScenario {
     }
 
     void deleteNorthMappingNegative(final Site dstSite) {
-        final Ipv4Prefix ipv4Prefix = new Ipv4Prefix(dstSite.getEidPrefix() + "/" + DEFAULT_NETWORK_MASK);
-        final Eid eidAsIpv4Prefix = LispAddressUtil.toEid(ipv4Prefix, dstSite.getVNI());
+        final Eid eidAsIpv4Prefix = LispAddressUtil.asIpv4PrefixBinaryEid(
+                dstSite.getEidPrefix() + "/" + DEFAULT_NETWORK_MASK, dstSite.getVNI());
 
         mapService.removeMapping(MappingOrigin.Northbound, eidAsIpv4Prefix);
     }
@@ -233,7 +235,7 @@ class MultiSiteScenario {
         if (!dstSites[0].isForDeletion) {
             for (Site dstSite : dstSites) {
                 if (dstSite.getRloc() != null) {
-                    locatorRecords.add(provideLocatorRecord(LispAddressUtil.toRloc(new Ipv4Address(dstSite.getRloc())),
+                    locatorRecords.add(provideLocatorRecord(LispAddressUtil.asIpv4Rloc(dstSite.getRloc()),
                             dstSite.getRloc(), dstSite.getWeight(), dstSite.getPriority()));
                 }
             }
@@ -338,10 +340,11 @@ class MultiSiteScenario {
             boolean expectedTargetFound = false;
             for (LocatorRecord locatorRecord : locatorRecords) {
                 if (expectedTargetSite.getRloc().equals(rlocToString(locatorRecord))) {
-                    final Ipv4Address ipv4AddressSrcDst = verifyIpv4Address(locatorRecord);
-                    final boolean isRlocSrcDstEqual = ipv4AddressSrcDst.getValue().equals(expectedTargetSite.getRloc());
+                    final byte[] ipv4AddressSrcDst = verifyIpv4Address(locatorRecord).getValue();
+                    final byte[] rloc = InetAddresses.forString((expectedTargetSite.getRloc())).getAddress();
+                    final boolean isRlocSrcDstEqual = Arrays.equals(ipv4AddressSrcDst, rloc);
                     if (isPossibleAssertPingResultImmediately(expectedPingWorks, isRlocSrcDstEqual, "Unexpected RLOC." +
-                            "Expected value " + dstSite.getRloc() + ". Real value " + ipv4AddressSrcDst.getValue() +
+                            "Expected value " + rloc + ". Real value " + ipv4AddressSrcDst +
                             ".")) {
                         return true;
                     }
@@ -392,8 +395,7 @@ class MultiSiteScenario {
                          boolean expectedPingWorks, final Site ... additionalSitesFromMapping) {
         final MapReply mapReplyFromSrcToDst = emitMapRequestMessage(srcSite.getHost(srcHostIndex), dstSite.getHost
                 (dstHostIndex), dstSite.getVNI());
-        if (checkActionAndRloc(dstSite, expectedPingWorks, mapReplyFromSrcToDst,
-                additionalSitesFromMapping)) {
+        if (checkActionAndRloc(dstSite, expectedPingWorks, mapReplyFromSrcToDst, additionalSitesFromMapping)) {
             return;
         }
 

diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolver.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolver.java
index b5393f63526132fe5dc2798fbf4a0bd98cc9a536..4c534fe7462e242aea99ffd51eab1ea11a029285 100644 (file)
--- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolver.java
+++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolver.java
@@ -122,7 +122,7 @@ public class MapResolver implements IMapResolverAsync {
         // mapping will be pushed to dst as well (see sendSMRs in MapServer)
         if (mapEid.getAddressType().equals(SourceDestKeyLcaf.class)
                 && !reqEid.getAddressType().equals(SourceDestKeyLcaf.class)) {
-            subscribedEid = SourceDestKeyHelper.getDst(mapEid);
+            subscribedEid = SourceDestKeyHelper.getDstBinary(mapEid);
         }
 
         Set<SubscriberRLOC> subscribers = getSubscribers(subscribedEid);
@@ -145,7 +145,7 @@ public class MapResolver implements IMapResolverAsync {
         if (mapping.getEid().getAddress() instanceof SourceDestKey
                 && !(dstEid.getAddress() instanceof SourceDestKey)) {
             return new MappingRecordBuilder(mapping).setEid(
-                    SourceDestKeyHelper.getDst(mapping.getEid())).build();
+                    SourceDestKeyHelper.getDstBinary(mapping.getEid())).build();
         }
         return mapping;
     }

diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServer.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServer.java
index 4b2659c922c98de3d4d9b95ff517754ff66143f5..914fd6cfcb93579f738c786593ce0ef92a66018d 100644 (file)
--- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServer.java
+++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServer.java
@@ -54,7 +54,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev15090
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingChanged;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.OdlMappingserviceListener;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkey;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -90,7 +89,6 @@ public class MapServer implements IMapServerAsync, OdlMappingserviceListener {
         boolean authFailed = false;
         boolean mappingUpdated = false;
         boolean merge = ConfigIni.getInstance().mappingMergeIsSet() && mapRegister.isMergeEnabled();
-        MappingAuthkey authkey = null;
         Set<SubscriberRLOC> subscribers = null;
         MappingRecord oldMapping;
 
@@ -202,7 +200,7 @@ public class MapServer implements IMapServerAsync, OdlMappingserviceListener {
 
         // For SrcDst LCAF also send SMRs to Dst prefix
         if (eid.getAddress() instanceof SourceDestKey) {
-            Eid dstAddr = SourceDestKeyHelper.getDst(eid);
+            Eid dstAddr = SourceDestKeyHelper.getDstBinary(eid);
             Set<SubscriberRLOC> dstSubs = getSubscribers(dstAddr);
             MappingRecord newRecord = new MappingRecordBuilder(record).setEid(dstAddr).build();
             handleSmr(newRecord.getEid(), dstSubs, notifyHandler);

diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/AuthenticationKeyDataListener.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/AuthenticationKeyDataListener.java
index cdefd3d6fe8debaae0837c0908b02d3d9c9c71bb..2c09cbd71ab1353b67def6deca7dcb75fea1eb96 100644 (file)
--- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/AuthenticationKeyDataListener.java
+++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/AuthenticationKeyDataListener.java
@@ -14,10 +14,6 @@ import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
 import org.opendaylight.lispflowmapping.interfaces.mapcache.IMappingSystem;
 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Prefix;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingDatabase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.AuthenticationKey;
@@ -86,8 +82,7 @@ public class AuthenticationKeyDataListener extends AbstractDataListener<Authenti
 
     private static AuthenticationKey convertToBinaryIfNecessary(AuthenticationKey authKey) {
         Eid originalEid = authKey.getEid();
-        if (originalEid.getAddress() instanceof Ipv4Prefix || originalEid.getAddress() instanceof Ipv6Prefix ||
-                originalEid.getAddress() instanceof Ipv4 || originalEid.getAddress() instanceof Ipv6) {
+        if (LispAddressUtil.addressNeedsConversionToBinary(originalEid.getAddress())) {
             AuthenticationKeyBuilder akb = new AuthenticationKeyBuilder(authKey);
             akb.setEid(LispAddressUtil.convertToBinary(originalEid));
             return akb.build();

diff --git a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/MappingDataListener.java b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/MappingDataListener.java
index f7a0f73691130e8ef735d9c319ead3a1153bd421..45f3c631d244c4a7d839cf591bd3912e45ec2e9b 100644 (file)
--- a/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/MappingDataListener.java
+++ b/mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/MappingDataListener.java
@@ -7,7 +7,10 @@
  */
 package org.opendaylight.lispflowmapping.implementation.mdsal;
 
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.List;
+
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
@@ -15,10 +18,16 @@ import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
 import org.opendaylight.lispflowmapping.implementation.util.MSNotificationInputUtil;
 import org.opendaylight.lispflowmapping.interfaces.mapcache.IMappingSystem;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingChange;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingDatabase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.Mapping;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.MappingBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.database.VirtualNetworkIdentifier;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.slf4j.Logger;
@@ -74,10 +83,12 @@ public class MappingDataListener extends AbstractDataListener<Mapping> {
                 LOG.trace("Key: {}", change.getRootPath().getRootIdentifier());
                 LOG.trace("Value: {}", mapping);
 
-                mapSystem.removeMapping(mapping.getOrigin(), mapping.getMappingRecord().getEid());
+                final Mapping convertedMapping = convertToBinaryIfNecessary(mapping);
+
+                mapSystem.removeMapping(convertedMapping.getOrigin(), convertedMapping.getMappingRecord().getEid());
                 try {
                     notificationPublishService.putNotification(MSNotificationInputUtil.toMappingChanged(
-                            mapping, MappingChange.Removed));
+                            convertedMapping, MappingChange.Removed));
                 } catch (InterruptedException e) {
                     LOG.warn("Notification publication interrupted!");
                 }
@@ -104,13 +115,15 @@ public class MappingDataListener extends AbstractDataListener<Mapping> {
                 LOG.trace("Key: {}", change.getRootPath().getRootIdentifier());
                 LOG.trace("Value: {}", mapping);
 
-                mapSystem.addMapping(mapping.getOrigin(), mapping.getMappingRecord().getEid(),
-                        mapping.getMappingRecord(), false);
+                final Mapping convertedMapping = convertToBinaryIfNecessary(mapping);
+
+                mapSystem.addMapping(convertedMapping.getOrigin(), convertedMapping.getMappingRecord().getEid(),
+                        convertedMapping.getMappingRecord(), false);
 
                 try {
                     // The notifications are used for sending SMR.
-                    notificationPublishService.putNotification(MSNotificationInputUtil.toMappingChanged(mapping,
-                            mappingChange));
+                    notificationPublishService.putNotification(MSNotificationInputUtil.toMappingChanged(
+                            convertedMapping, mappingChange));
                 } catch (InterruptedException e) {
                     LOG.warn("Notification publication interrupted!");
                 }
@@ -120,4 +133,41 @@ public class MappingDataListener extends AbstractDataListener<Mapping> {
             }
         }
     }
+
+    private static Mapping convertToBinaryIfNecessary(Mapping mapping) {
+        MappingRecord originalRecord = mapping.getMappingRecord();
+        List<LocatorRecord> originalLocators = originalRecord.getLocatorRecord();
+
+        List<LocatorRecord> convertedLocators = null;
+        if (originalLocators != null) {
+            // If convertedLocators is non-null, while originalLocators is also non-null, conversion has been made
+            convertedLocators = convertToBinaryIfNecessary(originalLocators);
+        }
+
+        if (LispAddressUtil.addressNeedsConversionToBinary(originalRecord.getEid().getAddress()) ||
+                (originalLocators != null && convertedLocators != null)) {
+            MappingRecordBuilder mrb = new MappingRecordBuilder(originalRecord);
+            mrb.setEid(LispAddressUtil.convertToBinary(originalRecord.getEid()));
+            if (convertedLocators != null) {
+                mrb.setLocatorRecord(convertedLocators);
+            }
+            return new MappingBuilder(mapping).setMappingRecord(mrb.build()).build();
+        }
+        return mapping;
+    }
+
+    private static List<LocatorRecord> convertToBinaryIfNecessary(List<LocatorRecord> locators) {
+        List<LocatorRecord> convertedLocators = null;
+        for (LocatorRecord record : locators) {
+            if (LispAddressUtil.addressNeedsConversionToBinary(record.getRloc().getAddress())) {
+                LocatorRecordBuilder lrb = new LocatorRecordBuilder(record);
+                lrb.setRloc(LispAddressUtil.convertToBinary(record.getRloc()));
+                if (convertedLocators == null) {
+                    convertedLocators = new ArrayList<LocatorRecord>();
+                }
+                convertedLocators.add(lrb.build());
+            }
+        }
+        return convertedLocators;
+    }
 }

diff --git a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java
index e0177e544d3f0c3f51b736be26077a0cb0cb7cc2..12d7633bca408a658cf0281b0bfbeafc3daa28d3 100644 (file)
--- a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java
+++ b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java
@@ -201,7 +201,7 @@ public class MapResolverTest {
 
         mapResolver.handleMapRequest(mapRequestBuilder.build());
         Mockito.verify(mapServiceMock).getData(MappingOrigin.Southbound,
-                SourceDestKeyHelper.getDst(SOURCE_DEST_KEY_EID), SubKeys.SUBSCRIBERS);
+                SourceDestKeyHelper.getDstBinary(SOURCE_DEST_KEY_EID), SubKeys.SUBSCRIBERS);
     }
 
     /**

diff --git a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.java b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.java
index f1d96489f64b48d9f04282dbca3d8510ddd148d1..77ad610180384d52fcb5151e7f80fd671d7cb40e 100644 (file)
--- a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.java
+++ b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.java
@@ -245,7 +245,7 @@ public class MapServerTest {
                 .thenReturn(subscriberSetMock_1);
 
         // return a subscriberSet for SrcDestKeyEid destination MappingRecord
-        Mockito.when(mapService.getData(MappingOrigin.Southbound, SourceDestKeyHelper.getDst(SOURCE_DEST_KEY_EID),
+        Mockito.when(mapService.getData(MappingOrigin.Southbound, SourceDestKeyHelper.getDstBinary(SOURCE_DEST_KEY_EID),
                 SubKeys.SUBSCRIBERS)).thenReturn(subscriberSetMock_2);
 
         // ----------------- Stubbing for Ipv4 type Eid mapping ------------------------
@@ -275,7 +275,8 @@ public class MapServerTest {
         // for SrcDst destination mapping
         final ArgumentCaptor<MapRequest> captor_2 = ArgumentCaptor.forClass(MapRequest.class);
         Mockito.verify(notifyHandler, Mockito.times(1)).handleSMR(captor_2.capture(), Mockito.eq(RLOC_4));
-        Mockito.verify(mapService).addData(MappingOrigin.Southbound, SourceDestKeyHelper.getDst(SOURCE_DEST_KEY_EID),
+        Mockito.verify(mapService).addData(MappingOrigin.Southbound,
+                SourceDestKeyHelper.getDstBinary(SOURCE_DEST_KEY_EID),
                 SubKeys.SUBSCRIBERS, subscriberSetMock_2);
         final Eid resultEid_2 = captor_2.getValue().getEidItem().iterator().next().getEid();
         assertEquals(IPV4_SOURCE_EID_4, resultEid_2);

diff --git a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LispAddressUtil.java b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LispAddressUtil.java
index 0398ce4db418064656571e7842d1a97c7478855a..93ddf85427998b3f05ece463472e698ce5871472 100644 (file)
--- a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LispAddressUtil.java
+++ b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/LispAddressUtil.java
@@ -17,6 +17,8 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Pattern;
 
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.AsNumber;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
@@ -153,6 +155,24 @@ public final class LispAddressUtil {
         return null;
     }
 
+    public static Class<? extends LispAddressFamily> binaryAddressTypeFromInet(InetAddress address) {
+        if (address instanceof Inet4Address) {
+            return Ipv4BinaryAfi.class;
+        } else if (address instanceof Inet6Address) {
+            return Ipv6BinaryAfi.class;
+        }
+        return null;
+    }
+
+    public static Address binaryAddressFromInet(InetAddress address) {
+        if (address instanceof Inet4Address) {
+            return (Address) new Ipv4BinaryBuilder().setIpv4Binary(new Ipv4AddressBinary(address.getAddress())).build();
+        } else if (address instanceof Inet6Address) {
+            return (Address) new Ipv6BinaryBuilder().setIpv6Binary(new Ipv6AddressBinary(address.getAddress())).build();
+        }
+        return null;
+    }
+
     public static Class<? extends LispAddressFamily> addressTypeFromIpAddress(IpAddress address) {
         if (address == null) {
             return null;
@@ -267,9 +287,9 @@ public final class LispAddressUtil {
 
     public static Rloc toRloc(InetAddress address) {
         RlocBuilder builder = new RlocBuilder();
-        builder.setAddressType(addressTypeFromInet(address));
+        builder.setAddressType(binaryAddressTypeFromInet(address));
         builder.setVirtualNetworkId(null);
-        builder.setAddress(addressFromInet(address));
+        builder.setAddress(binaryAddressFromInet(address));
         return builder.build();
     }
 
@@ -462,6 +482,25 @@ public final class LispAddressUtil {
         return toEid(new Ipv4AddressBinary(InetAddresses.forString(address).getAddress()), new InstanceIdType(vni));
     }
 
+    public static Eid asBinaryEid(SimpleAddress address, InstanceIdType iid) {
+        if (address.getIpPrefix() != null) {
+            if (address.getIpPrefix().getIpv4Prefix() != null) {
+                return LispAddressUtil.asIpv4PrefixBinaryEid(address.getIpPrefix().getIpv4Prefix().getValue(), iid);
+            } else if (address.getIpPrefix().getIpv6Prefix() != null) {
+                return LispAddressUtil.asIpv6PrefixBinaryEid(address.getIpPrefix().getIpv6Prefix().getValue(), iid);
+            }
+        } else if (address.getIpAddress() != null) {
+            if (address.getIpAddress().getIpv4Address() != null) {
+                LispAddressUtil.toEid(new Ipv4AddressBinary(InetAddresses.forString(
+                        address.getIpPrefix().getIpv4Prefix().getValue()).getAddress()), iid);
+            } else if (address.getIpAddress().getIpv6Address() != null) {
+                LispAddressUtil.toEid(new Ipv6AddressBinary(InetAddresses.forString(
+                        address.getIpPrefix().getIpv6Prefix().getValue()).getAddress()), iid);
+            }
+        }
+        return LispAddressUtil.asEid(address, iid);
+    }
+
     public static int ipVersionFromString(String ip) {
         if (IP4_PATTERN.matcher(ip).matches()) {
             return 4;
@@ -722,29 +761,62 @@ public final class LispAddressUtil {
         return new Ipv6BinaryBuilder().setIpv6Binary(new Ipv6AddressBinary(addr)).build();
     }
 
-    public static Eid convertToBinary(Eid eid) {
-        EidBuilder eb = new EidBuilder(eid);
-        Address addr = eid.getAddress();
+    private static Pair<Class<? extends LispAddressFamily>, Address> convertToBinary(Address addr) {
         Address convAddr = null;
+        Class<? extends LispAddressFamily> convType = null;
         if (addr instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf
                 .lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix) {
             convAddr = convertToBinary((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf
                     .lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix) addr);
+            convType = Ipv4PrefixBinaryAfi.class;
         } else if (addr instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf
                 .lisp.address.types.rev151105.lisp.address.address.Ipv6Prefix) {
             convAddr = convertToBinary((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf
                     .lisp.address.types.rev151105.lisp.address.address.Ipv6Prefix) addr);
+            convType = Ipv6PrefixBinaryAfi.class;
         } else if (addr instanceof Ipv4) {
             convAddr = convertToBinary((Ipv4) addr);
+            convType = Ipv4BinaryAfi.class;
         } else if (addr instanceof Ipv6) {
             convAddr = convertToBinary((Ipv6) addr);
-        } else {
+            convType = Ipv6BinaryAfi.class;
+        }
+        return new ImmutablePair<Class<? extends LispAddressFamily>, Address>(convType, convAddr);
+    }
+
+    public static Eid convertToBinary(Eid eid) {
+        Pair<Class<? extends LispAddressFamily>, Address> converted = convertToBinary(eid.getAddress());
+        if (converted.getRight() == null) {
             return eid;
         }
-        eb.setAddress(convAddr);
+        EidBuilder eb = new EidBuilder(eid);
+        eb.setAddressType(converted.getLeft());
+        eb.setAddress(converted.getRight());
         return eb.build();
     }
 
+    public static Rloc convertToBinary(Rloc rloc) {
+        Pair<Class<? extends LispAddressFamily>, Address> converted = convertToBinary(rloc.getAddress());
+        if (converted.getRight() == null) {
+            return rloc;
+        }
+        RlocBuilder rb = new RlocBuilder(rloc);
+        rb.setAddressType(converted.getLeft());
+        rb.setAddress(converted.getRight());
+        return rb.build();
+    }
+
+    public static boolean addressNeedsConversionToBinary(Address address) {
+        if (address instanceof Ipv4 || address instanceof Ipv6 ||
+                address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf
+                        .lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix ||
+                address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf
+                        .lisp.address.types.rev151105.lisp.address.address.Ipv6Prefix) {
+            return true;
+        }
+        return false;
+    }
+
     public static int compareIpAddressByteArrays(byte[] a, byte[] b) {
         int i;
         if (a.length < b.length) {

diff --git a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/SourceDestKeyHelper.java b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/SourceDestKeyHelper.java
index 8eb1a5601fc5e4d392b632cb9d3a1a98677d232b..fc530a36c57201f937bbc841031695d826fe4518 100644 (file)
--- a/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/SourceDestKeyHelper.java
+++ b/mappingservice/lisp-proto/src/main/java/org/opendaylight/lispflowmapping/lisp/util/SourceDestKeyHelper.java
@@ -45,6 +45,22 @@ public final class SourceDestKeyHelper {
         }
     }
 
+    public static Eid getSrcBinary(Eid eid) {
+        if (eid.getAddress() instanceof SourceDestKey) {
+            return LispAddressUtil.asBinaryEid(((SourceDestKey) eid.getAddress()).getSourceDestKey().getSource(),
+                    eid.getVirtualNetworkId());
+        }
+        return eid;
+    }
+
+    public static Eid getDstBinary(Eid eid) {
+        if (eid.getAddress() instanceof SourceDestKey) {
+            return LispAddressUtil.asBinaryEid(((SourceDestKey) eid.getAddress()).getSourceDestKey().getDest(),
+                    eid.getVirtualNetworkId());
+        }
+        return eid;
+    }
+
     public static short getSrcMask(Eid eid) {
         Address addr = eid.getAddress();
         if (!isSrcDst(addr)) {

diff --git a/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/lisp/util/LispAddressUtilTest.java b/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/lisp/util/LispAddressUtilTest.java
index 346b030744e8d9be855393ab1f1cd9c101f5d401..1f849f89efb5a6bbb6aac73a7b68b9f8c2a1fec4 100644 (file)
--- a/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/lisp/util/LispAddressUtilTest.java
+++ b/mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/lisp/util/LispAddressUtilTest.java
@@ -536,8 +536,8 @@ public class LispAddressUtilTest {
     public void toRloc() throws UnknownHostException {
         InetAddress ipv4AddressInet = Inet4Address.getByAddress(IPV4_ADDRESS_BYTES_A_TEST);
         final Rloc rlocFromInetAddress = LispAddressUtil.toRloc(ipv4AddressInet);
-        assertEquals(Ipv4Afi.class, rlocFromInetAddress.getAddressType());
-        assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4)rlocFromInetAddress.getAddress()).getIpv4().getValue());
+        assertEquals(Ipv4BinaryAfi.class, rlocFromInetAddress.getAddressType());
+        assertEquals(IPV4_ADDRESS_BINARY_TEST, ((Ipv4Binary) rlocFromInetAddress.getAddress()).getIpv4Binary());
 
         final Rloc rlocFromIpv4Address = LispAddressUtil.toRloc(IPV4_ADDRESS_TEST);
         assertEquals(Ipv4Afi.class, rlocFromIpv4Address.getAddressType());

diff --git a/mappingservice/mapcache/src/main/java/org/opendaylight/lispflowmapping/mapcache/MultiTableMapCache.java b/mappingservice/mapcache/src/main/java/org/opendaylight/lispflowmapping/mapcache/MultiTableMapCache.java
index 1ba18b55e2c6b49ef6f28f9cb0a4dfb187ead23e..3663c36f9c26ab4d9aad941bc1625f3226dfcbbd 100644 (file)
--- a/mappingservice/mapcache/src/main/java/org/opendaylight/lispflowmapping/mapcache/MultiTableMapCache.java
+++ b/mappingservice/mapcache/src/main/java/org/opendaylight/lispflowmapping/mapcache/MultiTableMapCache.java
@@ -69,7 +69,7 @@ public class MultiTableMapCache implements IMapCache {
         ILispDAO table = getOrInstantiateVniTable(key);
 
         if (eid.getAddress() instanceof SourceDestKey) {
-            Eid srcKey = SourceDestKeyHelper.getSrc(eid);
+            Eid srcKey = SourceDestKeyHelper.getSrcBinary(eid);
             ILispDAO srcDstDao = getOrInstantiateSDInnerDao(eid, table);
             srcDstDao.put(srcKey, new MappingEntry<>(SubKeys.REGDATE, new Date(System.currentTimeMillis())));
             srcDstDao.put(srcKey, new MappingEntry<>(SubKeys.RECORD, value));
@@ -162,8 +162,8 @@ public class MultiTableMapCache implements IMapCache {
 
         // a map-request for an actual SrcDst LCAF, ignore src eid
         if (dstEid.getAddress() instanceof SourceDestKey) {
-            Eid srcAddr = SourceDestKeyHelper.getSrc(dstEid);
-            Eid dstAddr = SourceDestKeyHelper.getDst(dstEid);
+            Eid srcAddr = SourceDestKeyHelper.getSrcBinary(dstEid);
+            Eid dstAddr = SourceDestKeyHelper.getDstBinary(dstEid);
             return getMappingLpmSD(srcAddr, dstAddr, table);
         }
 
@@ -181,7 +181,7 @@ public class MultiTableMapCache implements IMapCache {
         if (key.getAddress() instanceof SourceDestKey) {
             ILispDAO db = getSDInnerDao(key, table);
             if (db != null) {
-                db.removeSpecific(SourceDestKeyHelper.getSrc(key),
+                db.removeSpecific(SourceDestKeyHelper.getSrcBinary(key),
                         SubKeys.RECORD);
             }
         } else {
@@ -195,7 +195,7 @@ public class MultiTableMapCache implements IMapCache {
 
         if (key.getAddress() instanceof SourceDestKey) {
             ILispDAO srcDstDao = getOrInstantiateSDInnerDao(key, table);
-            srcDstDao.put(SourceDestKeyHelper.getSrc(key), new MappingEntry<>(SubKeys.AUTH_KEY, authKey));
+            srcDstDao.put(SourceDestKeyHelper.getSrcBinary(key), new MappingEntry<>(SubKeys.AUTH_KEY, authKey));
         } else {
             table.put(key, new MappingEntry<>(SubKeys.AUTH_KEY, authKey));
         }
@@ -225,7 +225,7 @@ public class MultiTableMapCache implements IMapCache {
                 // NOTE: this is an exact match, not a longest prefix match
                 ILispDAO srcDstDao = getSDInnerDao(eid, table);
                 if (srcDstDao != null) {
-                    return getAuthKeyLpm(SourceDestKeyHelper.getSrc(eid), srcDstDao);
+                    return getAuthKeyLpm(SourceDestKeyHelper.getSrcBinary(eid), srcDstDao);
                 }
                 return null;
             } else {
@@ -263,7 +263,7 @@ public class MultiTableMapCache implements IMapCache {
     // SrcDst LCAFs are stored in a 2-tier DAO with dst having priority over src.
     // This method returns the DAO associated to a dst or creates it if it doesn't exist.
     private ILispDAO getOrInstantiateSDInnerDao(Eid address, ILispDAO dao) {
-        Eid dstKey = SourceDestKeyHelper.getDst(address);
+        Eid dstKey = SourceDestKeyHelper.getDstBinary(address);
         ILispDAO srcDstDao = (ILispDAO) dao.getSpecific(dstKey, SubKeys.LCAF_SRCDST);
         if (srcDstDao == null) {
             // inserts nested table for source
@@ -275,7 +275,7 @@ public class MultiTableMapCache implements IMapCache {
     // SrcDst LCAFs are stored in a 2-tier DAO with dst having priority over src.
     // This method returns the DAO associated to dst or null if it doesn't exist.
     private ILispDAO getSDInnerDao(Eid address, ILispDAO dao) {
-        return (ILispDAO) dao.getSpecific(SourceDestKeyHelper.getDst(address), SubKeys.LCAF_SRCDST);
+        return (ILispDAO) dao.getSpecific(SourceDestKeyHelper.getDstBinary(address), SubKeys.LCAF_SRCDST);
     }
 
     public String printMappings() {
@@ -345,7 +345,7 @@ public class MultiTableMapCache implements IMapCache {
 
         if (key.getAddress() instanceof SourceDestKey) {
             ILispDAO srcDstDao = getOrInstantiateSDInnerDao(key, table);
-            srcDstDao.put(SourceDestKeyHelper.getSrc(key), new MappingEntry<Object>(subKey, data));
+            srcDstDao.put(SourceDestKeyHelper.getSrcBinary(key), new MappingEntry<Object>(subKey, data));
         } else {
             table.put(key, new MappingEntry<Object>(subKey, data));
         }
@@ -361,7 +361,7 @@ public class MultiTableMapCache implements IMapCache {
 
         if (key.getAddress() instanceof SourceDestKey) {
             ILispDAO srcDstDao = getSDInnerDao(key, table);
-            return srcDstDao.getSpecific(SourceDestKeyHelper.getSrc(key), subKey);
+            return srcDstDao.getSpecific(SourceDestKeyHelper.getSrcBinary(key), subKey);
         } else {
             return table.getSpecific(key, subKey);
         }
@@ -377,7 +377,7 @@ public class MultiTableMapCache implements IMapCache {
         if (key.getAddress() instanceof SourceDestKey) {
             ILispDAO db = getSDInnerDao(key, table);
             if (db != null) {
-                db.removeSpecific(SourceDestKeyHelper.getSrc(key), subKey);
+                db.removeSpecific(SourceDestKeyHelper.getSrcBinary(key), subKey);
             }
         } else {
             table.removeSpecific(key, subKey);

diff --git a/mappingservice/mapcache/src/test/java/org/opendaylight/lispflowmapping/mapcache/MultiTableMapCacheTest.java b/mappingservice/mapcache/src/test/java/org/opendaylight/lispflowmapping/mapcache/MultiTableMapCacheTest.java
index 9f2b8195d7d119844abf99b1080cf9addb7de8f1..1a4d22957bc8c1728c06404af033bdc2cb89aaa2 100644 (file)
--- a/mappingservice/mapcache/src/test/java/org/opendaylight/lispflowmapping/mapcache/MultiTableMapCacheTest.java
+++ b/mappingservice/mapcache/src/test/java/org/opendaylight/lispflowmapping/mapcache/MultiTableMapCacheTest.java
@@ -105,8 +105,8 @@ public class MultiTableMapCacheTest {
     public void addMappingTest_withSourceDestKey() {
 
         final Eid normalized_Eid = MaskUtil.normalize(EID_SOURCE_DEST_KEY_TYPE);
-        final Eid dstKey = SourceDestKeyHelper.getDst(normalized_Eid);
-        final Eid srcKey = SourceDestKeyHelper.getSrc(normalized_Eid);
+        final Eid dstKey = SourceDestKeyHelper.getDstBinary(normalized_Eid);
+        final Eid srcKey = SourceDestKeyHelper.getSrcBinary(normalized_Eid);
 
         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
         when(tableDaoMock.getSpecific(dstKey, SubKeys.LCAF_SRCDST)).thenReturn(srcDstDaoMock);
@@ -135,10 +135,10 @@ public class MultiTableMapCacheTest {
     public void getMappingTest_withSourceDestKey() {
         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
 
-        final Eid dstAddr = SourceDestKeyHelper.getDst(EID_SOURCE_DEST_KEY_TYPE);
+        final Eid dstAddr = SourceDestKeyHelper.getDstBinary(EID_SOURCE_DEST_KEY_TYPE);
         final Eid normalizedDstAddr = MaskUtil.normalize(dstAddr);
 
-        final Eid srcAddr = SourceDestKeyHelper.getSrc(EID_SOURCE_DEST_KEY_TYPE);
+        final Eid srcAddr = SourceDestKeyHelper.getSrcBinary(EID_SOURCE_DEST_KEY_TYPE);
         final Eid normalizedSrcAddr = MaskUtil.normalize(srcAddr);
 
         final Map<String, Object> entry = getEntry1();
@@ -199,10 +199,10 @@ public class MultiTableMapCacheTest {
 
         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
         when(tableDaoMock.getSpecific(SourceDestKeyHelper
-                .getDst(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST)).thenReturn(dbMock);
+                .getDstBinary(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST)).thenReturn(dbMock);
 
         multiTableMapCache.removeMapping(EID_SOURCE_DEST_KEY_TYPE, true);
-        verify(dbMock).removeSpecific(SourceDestKeyHelper.getSrc(NORMALIZED_SRCDST_EID),
+        verify(dbMock).removeSpecific(SourceDestKeyHelper.getSrcBinary(NORMALIZED_SRCDST_EID),
                 SubKeys.RECORD);
     }
 
@@ -237,11 +237,11 @@ public class MultiTableMapCacheTest {
     @Test
     public void addAuthenticationKeyTest() {
         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
-        when(tableDaoMock.putNestedTable(SourceDestKeyHelper.getDst(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST))
+        when(tableDaoMock.putNestedTable(SourceDestKeyHelper.getDstBinary(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST))
                 .thenReturn(srcDstDaoMock);
 
         multiTableMapCache.addAuthenticationKey(EID_SOURCE_DEST_KEY_TYPE, MAPPING_AUTHKEY);
-        verify(srcDstDaoMock).put(SourceDestKeyHelper.getSrc(NORMALIZED_SRCDST_EID),
+        verify(srcDstDaoMock).put(SourceDestKeyHelper.getSrcBinary(NORMALIZED_SRCDST_EID),
                 new MappingEntry<>(SubKeys.AUTH_KEY, MAPPING_AUTHKEY));
 
         multiTableMapCache.addAuthenticationKey(EID_TEST, MAPPING_AUTHKEY);
@@ -267,8 +267,8 @@ public class MultiTableMapCacheTest {
      */
     @Test
     public void getAuthenticationKeyTest_withSourceDestKey() {
-        final Eid eidSrc = SourceDestKeyHelper.getSrc(EID_SOURCE_DEST_KEY_TYPE);
-        final Eid eidDst = SourceDestKeyHelper.getDst(EID_SOURCE_DEST_KEY_TYPE);
+        final Eid eidSrc = SourceDestKeyHelper.getSrcBinary(EID_SOURCE_DEST_KEY_TYPE);
+        final Eid eidDst = SourceDestKeyHelper.getDstBinary(EID_SOURCE_DEST_KEY_TYPE);
         final short maskLength = MaskUtil.getMaskForAddress(eidSrc.getAddress());
         final Eid key = MaskUtil.normalize(eidSrc, maskLength);
 
@@ -285,7 +285,7 @@ public class MultiTableMapCacheTest {
      */
     @Test
     public void getAuthenticationKeyTest_withSourceDestKey_nullDao() {
-        final Eid eidDst = SourceDestKeyHelper.getDst(EID_SOURCE_DEST_KEY_TYPE);
+        final Eid eidDst = SourceDestKeyHelper.getDstBinary(EID_SOURCE_DEST_KEY_TYPE);
 
         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
         when(tableDaoMock.getSpecific(eidDst, SubKeys.LCAF_SRCDST))
@@ -335,7 +335,7 @@ public class MultiTableMapCacheTest {
     @Test
     public void removeAuthenticationKeyTest_withSourceDestKey() {
         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
-        when(tableDaoMock.getSpecific(SourceDestKeyHelper.getDst(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST))
+        when(tableDaoMock.getSpecific(SourceDestKeyHelper.getDstBinary(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST))
                 .thenReturn(srcDstDaoMock);
 
         multiTableMapCache.removeAuthenticationKey(EID_SOURCE_DEST_KEY_TYPE);
@@ -370,11 +370,11 @@ public class MultiTableMapCacheTest {
     @Test
     public void addDataTest_withSourceDestKey() {
         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
-        when(tableDaoMock.getSpecific(SourceDestKeyHelper.getDst(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST))
+        when(tableDaoMock.getSpecific(SourceDestKeyHelper.getDstBinary(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST))
                 .thenReturn(srcDstDaoMock);
 
         multiTableMapCache.addData(EID_SOURCE_DEST_KEY_TYPE, SubKeys.RECORD, DUMMY_OBJECT);
-        verify(srcDstDaoMock).put(SourceDestKeyHelper.getSrc(NORMALIZED_SRCDST_EID),
+        verify(srcDstDaoMock).put(SourceDestKeyHelper.getSrcBinary(NORMALIZED_SRCDST_EID),
                 new MappingEntry<>(SubKeys.RECORD, DUMMY_OBJECT));
     }
 
@@ -395,9 +395,9 @@ public class MultiTableMapCacheTest {
     @Test
     public void getDataTest_withSourceDestKey() {
         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
-        when(tableDaoMock.getSpecific(SourceDestKeyHelper.getDst(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST))
+        when(tableDaoMock.getSpecific(SourceDestKeyHelper.getDstBinary(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST))
                 .thenReturn(srcDstDaoMock);
-        when(srcDstDaoMock.getSpecific(SourceDestKeyHelper.getSrc(NORMALIZED_SRCDST_EID), SubKeys.RECORD))
+        when(srcDstDaoMock.getSpecific(SourceDestKeyHelper.getSrcBinary(NORMALIZED_SRCDST_EID), SubKeys.RECORD))
                 .thenReturn(DUMMY_OBJECT);
 
         assertEquals(DUMMY_OBJECT, multiTableMapCache.getData(EID_SOURCE_DEST_KEY_TYPE, SubKeys.RECORD));
@@ -429,11 +429,11 @@ public class MultiTableMapCacheTest {
     @Test
     public void removeDataTest_withSourceDestKey() {
         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
-        when(tableDaoMock.getSpecific(SourceDestKeyHelper.getDst(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST))
+        when(tableDaoMock.getSpecific(SourceDestKeyHelper.getDstBinary(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST))
                 .thenReturn(srcDstDaoMock);
 
         multiTableMapCache.removeData(EID_SOURCE_DEST_KEY_TYPE, SubKeys.RECORD);
-        verify(srcDstDaoMock).removeSpecific(SourceDestKeyHelper.getSrc(NORMALIZED_SRCDST_EID), SubKeys.RECORD);
+        verify(srcDstDaoMock).removeSpecific(SourceDestKeyHelper.getSrcBinary(NORMALIZED_SRCDST_EID), SubKeys.RECORD);
     }
 
     /**

diff --git a/mappingservice/southbound/src/main/java/org/opendaylight/lispflowmapping/southbound/lisp/AuthenticationKeyDataListener.java b/mappingservice/southbound/src/main/java/org/opendaylight/lispflowmapping/southbound/lisp/AuthenticationKeyDataListener.java
index 5cab1364557d10ccaa2ce7d644f683a47b042614..bf46250a02b5693e0bb16aa37c89be246efbf9d4 100644 (file)
--- a/mappingservice/southbound/src/main/java/org/opendaylight/lispflowmapping/southbound/lisp/AuthenticationKeyDataListener.java
+++ b/mappingservice/southbound/src/main/java/org/opendaylight/lispflowmapping/southbound/lisp/AuthenticationKeyDataListener.java
@@ -18,10 +18,6 @@ import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
 import org.opendaylight.lispflowmapping.mapcache.SimpleMapCache;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Prefix;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingDatabase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.AuthenticationKey;
@@ -99,8 +95,7 @@ public class AuthenticationKeyDataListener implements DataTreeChangeListener<Aut
 
     private static AuthenticationKey convertToBinaryIfNecessary(AuthenticationKey authKey) {
         Eid originalEid = authKey.getEid();
-        if (originalEid.getAddress() instanceof Ipv4Prefix || originalEid.getAddress() instanceof Ipv6Prefix ||
-                originalEid.getAddress() instanceof Ipv4 || originalEid.getAddress() instanceof Ipv6) {
+        if (LispAddressUtil.addressNeedsConversionToBinary(originalEid.getAddress())) {
             AuthenticationKeyBuilder akb = new AuthenticationKeyBuilder(authKey);
             akb.setEid(LispAddressUtil.convertToBinary(originalEid));
             return akb.build();