Make part of the Subscribers object modeled

[lispflowmapping.git] / mappingservice / implementation / src / main / java / org / opendaylight / lispflowmapping / implementation / lisp / MapResolver.java

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 7b983cb06b6b94430bae2a1051e5aa2e48ed1237..b8bfe9f806e25230733cd749459b962028365569 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
@@ -15,10 +15,13 @@ import java.util.List;
 import java.util.Set;
 import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
-import org.opendaylight.lispflowmapping.interfaces.dao.SubscriberRLOC;
+import org.opendaylight.lispflowmapping.interfaces.dao.Subscriber;
 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapRequestResultHandler;
 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapResolverAsync;
+import org.opendaylight.lispflowmapping.interfaces.lisp.ISmrNotificationListener;
+import org.opendaylight.lispflowmapping.interfaces.lisp.SmrEvent;
 import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
+import org.opendaylight.lispflowmapping.lisp.type.MappingData;
 import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
 import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
@@ -64,9 +67,10 @@ public class MapResolver implements IMapResolverAsync {
     private String elpPolicy;
     private IMapRequestResultHandler requestHandler;
     private boolean authenticate = true;
+    private ISmrNotificationListener smrNotificationListener;
 
     public MapResolver(IMappingService mapService, boolean smr, String elpPolicy,
-            IMapRequestResultHandler requestHandler) {
+                       IMapRequestResultHandler requestHandler) {
         Preconditions.checkNotNull(mapService);
         this.subscriptionService = smr;
         this.mapService = mapService;
@@ -84,6 +88,14 @@ public class MapResolver implements IMapResolverAsync {
             LOG.debug("Map-Resolver ignoring incoming RLOC probe control message.");
             return;
         }
+        if (request.isSmrInvoked()) {
+            LOG.debug("SMR-invoked request received.");
+            for (EidItem eidItem : request.getEidItem()) {
+                final SmrEvent event = new SmrEvent(LispAddressUtil.addressBinariesFromItrRlocs(request.getItrRloc()),
+                        eidItem.getEid(), request.getNonce());
+                smrNotificationListener.onSmrInvokedReceived(event);
+            }
+        }
         Eid srcEid = null;
         if (request.getSourceEid() != null) {
             srcEid = request.getSourceEid().getEid();
@@ -98,20 +110,24 @@ public class MapResolver implements IMapResolverAsync {
         final IpAddressBinary sourceRloc = request.getSourceRloc();
 
         for (EidItem eidRecord : request.getEidItem()) {
-            MappingRecord mapping = (MappingRecord) mapService.getMapping(srcEid,
-                    eidRecord.getEid());
-            if (mapping != null) {
-                if (itrRlocs != null && itrRlocs.size() != 0) {
-                    if (subscriptionService) {
-                        final Rloc resolvedRloc = resolveRloc(itrRlocs, sourceRloc);
-                        updateSubscribers(resolvedRloc, eidRecord.getEid(), mapping.getEid(), srcEid);
-                    }
-                    mapping = updateLocators(mapping, itrRlocs);
-                }
-                mapping = fixIfNotSDRequest(mapping, eidRecord.getEid());
-            } else {
+            MappingData mappingData = mapService.getMapping(srcEid, eidRecord.getEid());
+            MappingRecord mapping;
+            if (mappingData == null) {
                 mapping = getNegativeMapping(eidRecord.getEid());
+                mapService.addMapping(MappingOrigin.Southbound, mapping.getEid(), null, new MappingData(mapping));
+            } else {
+                mapping = mappingData.getRecord();
+            }
+
+            if (itrRlocs != null && itrRlocs.size() != 0) {
+                if (subscriptionService) {
+                    final Rloc resolvedRloc = resolveRloc(itrRlocs, sourceRloc);
+                    updateSubscribers(resolvedRloc, eidRecord.getEid(), mapping.getEid(),
+                            srcEid, mapping.getRecordTtl());
+                }
+                mapping = updateLocators(mapping, itrRlocs);
             }
+            mapping = fixIfNotSDRequest(mapping, eidRecord.getEid());
             replyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(mapping).build());
         }
         requestHandler.handleMapReply(replyBuilder.build());
@@ -171,11 +187,13 @@ public class MapResolver implements IMapResolverAsync {
         MappingRecordBuilder recordBuilder = new MappingRecordBuilder();
         recordBuilder.setAuthoritative(false);
         recordBuilder.setMapVersion((short) 0);
+        recordBuilder.setEid(eid);
         if (eid.getAddressType().equals(Ipv4PrefixBinaryAfi.class)
                 || eid.getAddressType().equals(Ipv6PrefixBinaryAfi.class)) {
-            recordBuilder.setEid(mapService.getWidestNegativePrefix(eid));
-        } else {
-            recordBuilder.setEid(eid);
+            Eid widestNegativePrefix = mapService.getWidestNegativePrefix(eid);
+            if (widestNegativePrefix != null) {
+                recordBuilder.setEid(widestNegativePrefix);
+            }
         }
         recordBuilder.setAction(Action.NativelyForward);
         if (authenticate && mapService.getAuthenticationKey(eid) != null) {
@@ -186,8 +204,8 @@ public class MapResolver implements IMapResolverAsync {
         return recordBuilder.build();
     }
 
-    private void updateSubscribers(Rloc itrRloc, Eid reqEid, Eid mapEid, Eid srcEid) {
-        SubscriberRLOC subscriberRloc = new SubscriberRLOC(itrRloc, srcEid);
+    private void updateSubscribers(Rloc itrRloc, Eid reqEid, Eid mapEid, Eid srcEid, Integer recordTtl) {
+        Subscriber subscriber = new Subscriber(itrRloc, srcEid, Subscriber.recordTtlToSubscriberTime(recordTtl));
         Eid subscribedEid = mapEid;
 
         // If the eid in the matched mapping is SourceDest and the requested eid IS NOT then we subscribe itrRloc only
@@ -198,18 +216,17 @@ public class MapResolver implements IMapResolverAsync {
             subscribedEid = SourceDestKeyHelper.getDstBinary(mapEid);
         }
 
-        Set<SubscriberRLOC> subscribers = getSubscribers(subscribedEid);
+        Set<Subscriber> subscribers = getSubscribers(subscribedEid);
         if (subscribers == null) {
             subscribers = Sets.newConcurrentHashSet();
-        } else if (subscribers.contains(subscriberRloc)) {
-            // If there is an entry already for this subscriberRloc, remove it, so that it gets the new
-            // timestamp
-            subscribers.remove(subscriberRloc);
+        } else if (subscribers.contains(subscriber)) {
+            // If there is an entry already for this subscriber, remove it, so that it gets the new timestamp
+            subscribers.remove(subscriber);
         }
         if (LOG.isTraceEnabled()) {
-            LOG.trace("Adding new subscriber: " + LispAddressStringifier.getString(subscriberRloc.getSrcRloc()));
+            LOG.trace("Adding new subscriber: " + LispAddressStringifier.getString(subscriber.getSrcRloc()));
         }
-        subscribers.add(subscriberRloc);
+        subscribers.add(subscriber);
         addSubscribers(subscribedEid, subscribers);
     }
 
@@ -224,6 +241,11 @@ public class MapResolver implements IMapResolverAsync {
     }
 
     private boolean locatorsNeedFixing(List<LocatorRecord> locatorRecords) {
+        // no locators - no fixing needed ;)
+        if (locatorRecords == null) {
+            return false;
+        }
+
         for (LocatorRecord record : locatorRecords) {
             if (record.getRloc().getAddress() instanceof ExplicitLocatorPath) {
                 return true;
@@ -327,11 +349,11 @@ public class MapResolver implements IMapResolverAsync {
     }
 
     @SuppressWarnings("unchecked")
-    private Set<SubscriberRLOC> getSubscribers(Eid address) {
-        return (Set<SubscriberRLOC>) mapService.getData(MappingOrigin.Southbound, address, SubKeys.SUBSCRIBERS);
+    private Set<Subscriber> getSubscribers(Eid address) {
+        return (Set<Subscriber>) mapService.getData(MappingOrigin.Southbound, address, SubKeys.SUBSCRIBERS);
     }
 
-    private void addSubscribers(Eid address, Set<SubscriberRLOC> subscribers) {
+    private void addSubscribers(Eid address, Set<Subscriber> subscribers) {
         mapService.addData(MappingOrigin.Southbound, address, SubKeys.SUBSCRIBERS, subscribers);
     }
 
@@ -349,4 +371,9 @@ public class MapResolver implements IMapResolverAsync {
     public void setShouldAuthenticate(boolean shouldAuthenticate) {
         this.authenticate = shouldAuthenticate;
     }
+
+    @Override
+    public void setSmrNotificationListener(ISmrNotificationListener smrNotificationListener) {
+        this.smrNotificationListener = smrNotificationListener;
+    }
 }