import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
-
+import org.opendaylight.lispflowmapping.dsbackend.DataStoreBackEnd;
import org.opendaylight.lispflowmapping.implementation.config.ConfigIni;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.lispflowmapping.implementation.mapcache.FlatMapCache;
-import org.opendaylight.lispflowmapping.implementation.mapcache.MultiTableMapCache;
-import org.opendaylight.lispflowmapping.implementation.mapcache.SimpleMapCache;
-import org.opendaylight.lispflowmapping.implementation.mdsal.DataStoreBackEnd;
import org.opendaylight.lispflowmapping.implementation.util.DSBEInputUtil;
import org.opendaylight.lispflowmapping.implementation.util.MappingMergeUtil;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
import org.opendaylight.lispflowmapping.interfaces.mapcache.IMapCache;
import org.opendaylight.lispflowmapping.interfaces.mapcache.IMappingSystem;
+import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.lispflowmapping.mapcache.FlatMapCache;
+import org.opendaylight.lispflowmapping.mapcache.MultiTableMapCache;
+import org.opendaylight.lispflowmapping.mapcache.SimpleMapCache;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ExplicitLocatorPath;
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.Ipv6;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ServicePath;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.Hop;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.SiteId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
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.authkey.container.MappingAuthkey;
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.lisp.proto.rev151105.rloc.container.Rloc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.SiteId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.AuthenticationKey;
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.mapping.authkey.container.MappingAuthkey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* The Mapping System coordinates caching of md-sal stored mappings and if so configured enables longest prefix match
- * mapping lookups
+ * mapping lookups.
*
* @author Florin Coras
*
*/
public class MappingSystem implements IMappingSystem {
- private final static Logger LOG = LoggerFactory.getLogger(MappingSystem.class);
+ private static final Logger LOG = LoggerFactory.getLogger(MappingSystem.class);
private boolean iterateMask;
private boolean notificationService;
private boolean overwrite;
private IMapCache pmc;
private final EnumMap<MappingOrigin, IMapCache> tableMap = new EnumMap<>(MappingOrigin.class);
private DataStoreBackEnd dsbe;
- private BindingAwareBroker bindingAwareBroker;
+ private boolean isMaster = false;
public MappingSystem(ILispDAO dao, boolean iterateMask, boolean notifications, boolean overwrite) {
this.dao = dao;
tableMap.put(MappingOrigin.Southbound, smc);
}
- public void addMapping(MappingOrigin origin, SiteId siteId, Eid key, Object data) {
- // Store data first in MapCache and only afterwards persist to datastore. This should be used only for SB
- // registrations
- addMapping(origin, key, data);
- dsbe.addMapping(DSBEInputUtil.toMapping(origin, key, siteId, (MappingRecord) data));
- }
-
- public void addMapping(MappingOrigin origin, Eid key, Object value) {
- tableMap.get(origin).addMapping(key, value, origin == MappingOrigin.Southbound ? overwrite : true);
+ public void addMapping(MappingOrigin origin, Eid key, Object value, boolean merge) {
+ tableMap.get(origin).addMapping(key, value, origin == MappingOrigin.Southbound ? overwrite : true, merge);
}
- public void updateMappingRegistration(MappingOrigin origin, Eid key) {
- tableMap.get(origin).updateMappingRegistration(key);
+ public void updateMappingRegistration(MappingOrigin origin, Eid key, Long timestamp) {
+ tableMap.get(origin).updateMappingRegistration(key, timestamp);
}
private MappingRecord updateServicePathMappingRecord(MappingRecord mapping, Eid eid) {
@Override
public Object getMapping(Eid src, Eid dst) {
// NOTE: Currently we have two lookup algorithms implemented, which are configurable
- // using lookupPolicy in ConfigIni.java
- if (ConfigIni.getInstance().getLookupPolicy() == ConfigIni.NB_AND_SB) {
+ if (ConfigIni.getInstance().getLookupPolicy() == IMappingService.LookupPolicy.NB_AND_SB) {
return getMappingNbSbIntersection(src, dst);
} else {
return getMappingNbFirst(src, dst);
}
}
+ @Override
+ public Object getMapping(Eid dst) {
+ return getMapping((Eid)null, dst);
+ }
+
+ @Override
+ public Object getMapping(Eid src, Eid dst, XtrId xtrId) {
+ // Note: If xtrId is null, we need to go through regular policy checking else Policy doesn't matter
+
+ if (xtrId == null) {
+ return getMapping(src, dst);
+ }
+
+ return smc.getMapping(src, dst, xtrId.getValue());
+ }
+
+ @Override
+ public Object getMapping(MappingOrigin origin, Eid key) {
+ if (origin.equals(MappingOrigin.Southbound)) {
+ return getSbMappingWithExpiration(null, key);
+ }
+ return tableMap.get(origin).getMapping(null, key);
+ }
+
private Object getMappingNbFirst(Eid src, Eid dst) {
// Default lookup policy is northboundFirst
Object nbMapping = pmc.getMapping(src, dst);
if (nbMapping == null) {
- return smc.getMapping(src, dst);
+ return getSbMappingWithExpiration(src, dst);
}
if (dst.getAddress() instanceof ServicePath) {
return updateServicePathMappingRecord((MappingRecord) nbMapping, dst);
if (dst.getAddress() instanceof ServicePath) {
return updateServicePathMappingRecord((MappingRecord)nbMapping, dst);
}
- Object sbMapping = smc.getMapping(src, dst);
+ Object sbMapping = getSbMappingWithExpiration(src, dst);
if (sbMapping == null) {
return nbMapping;
}
return MappingMergeUtil.computeNbSbIntersection((MappingRecord)nbMapping, (MappingRecord)sbMapping);
}
- @Override
- public Object getMapping(Eid dst) {
- return getMapping((Eid)null, dst);
+ private Object getSbMappingWithExpiration(Eid src, Eid dst) {
+ Object mappingObject = smc.getMapping(src, dst);
+ if (mappingObject instanceof MappingRecord) {
+ MappingRecord mapping = (MappingRecord) mappingObject;
+ if (MappingMergeUtil.mappingIsExpired(mapping)) {
+ dsbe.removeMapping(DSBEInputUtil.toMapping(MappingOrigin.Southbound, mapping.getEid(),
+ new SiteId(mapping.getSiteId()), mapping));
+ return null;
+ }
+ }
+ return mappingObject;
}
@Override
- public Object getMapping(MappingOrigin origin, Eid key) {
- return tableMap.get(origin).getMapping(null, key);
+ public Eid getWidestNegativePrefix(Eid key) {
+ Eid nbPrefix = pmc.getWidestNegativeMapping(key);
+ if (nbPrefix == null) {
+ return null;
+ }
+
+ Eid sbPrefix = smc.getWidestNegativeMapping(key);
+ if (sbPrefix == null) {
+ return null;
+ }
+
+ // since prefixes overlap, just return the more specific (larger mask)
+ if (LispAddressUtil.getIpPrefixMask(nbPrefix) < LispAddressUtil.getIpPrefixMask(sbPrefix)) {
+ return sbPrefix;
+ } else {
+ return nbPrefix;
+ }
}
@Override
@Override
public void addAuthenticationKey(Eid key, MappingAuthkey authKey) {
- LOG.debug("Adding authentication key '{}' for {}", authKey.getKeyString(),
+ LOG.debug("Adding authentication key '{}' with key-ID {} for {}", authKey.getKeyString(), authKey.getKeyType(),
LispAddressStringifier.getString(key));
smc.addAuthenticationKey(key, authKey);
}
@Override
public MappingAuthkey getAuthenticationKey(Eid key) {
- LOG.debug("Retrieving authentication key for {}", LispAddressStringifier.getString(key));
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Retrieving authentication key for {}", LispAddressStringifier.getString(key));
+ }
return smc.getAuthenticationKey(key);
}
@Override
public void removeAuthenticationKey(Eid key) {
- LOG.debug("Removing authentication key for {}", LispAddressStringifier.getString(key));
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Removing authentication key for {}", LispAddressStringifier.getString(key));
+ }
smc.removeAuthenticationKey(key);
}
@Override
public void addData(MappingOrigin origin, Eid key, String subKey, Object data) {
- LOG.debug("Add data of class {} for key {} and subkey {}", data.getClass(),
- LispAddressStringifier.getString(key), subKey);
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Add data of class {} for key {} and subkey {}", data.getClass(),
+ LispAddressStringifier.getString(key), subKey);
+ }
tableMap.get(origin).addData(key, subKey, data);
}
@Override
public Object getData(MappingOrigin origin, Eid key, String subKey) {
- LOG.debug("Retrieving data for key {} and subkey {}", LispAddressStringifier.getString(key), subKey);
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Retrieving data for key {} and subkey {}", LispAddressStringifier.getString(key), subKey);
+ }
return tableMap.get(origin).getData(key, subKey);
}
@Override
public void removeData(MappingOrigin origin, Eid key, String subKey) {
- LOG.debug("Removing data for key {} and subkey {}", LispAddressStringifier.getString(key), subKey);
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Removing data for key {} and subkey {}", LispAddressStringifier.getString(key), subKey);
+ }
tableMap.get(origin).removeData(key, subKey);
}
/**
- * Restore all mappings and keys from mdsal datastore
+ * Restore all mappings and keys from mdsal datastore.
*/
private void restoreDaoFromDatastore() {
List<Mapping> mappings = dsbe.getAllMappings();
LOG.info("Restoring {} mappings and {} keys from datastore into DAO", mappings.size(), authKeys.size());
+ int expiredMappings = 0;
for (Mapping mapping : mappings) {
- addMapping(mapping.getOrigin(), mapping.getMappingRecord().getEid(), mapping.getMappingRecord());
+ if (MappingMergeUtil.mappingIsExpired(mapping.getMappingRecord())) {
+ dsbe.removeMapping(mapping);
+ expiredMappings++;
+ continue;
+ }
+ addMapping(mapping.getOrigin(), mapping.getMappingRecord().getEid(), mapping.getMappingRecord(), false);
}
+ LOG.info("{} mappings were expired and were not restored", expiredMappings);
for (AuthenticationKey authKey : authKeys) {
addAuthenticationKey(authKey.getEid(), authKey.getMappingAuthkey());
dao.removeAll();
buildMapCaches();
}
+
+ @Override
+ public void setIsMaster(boolean isMaster) {
+ this.isMaster = isMaster;
+ }
+
+ @Override
+ public boolean isMaster() {
+ return isMaster;
+ }
}
Code Review / lispflowmapping.git / blobdiff