*/
package org.opendaylight.lispflowmapping.implementation.util;
+import static org.opendaylight.yangtools.yang.common.UintConversions.fromJava;
+
import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import org.opendaylight.lispflowmapping.config.ConfigIni;
+import org.opendaylight.lispflowmapping.lisp.type.MappingData;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
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.source.dest.key.SourceDestKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKeyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
+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.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;
*
*/
public final class MappingMergeUtil {
- protected static final Logger LOG = LoggerFactory.getLogger(MappingMergeUtil.class);
+ private static final Logger LOG = LoggerFactory.getLogger(MappingMergeUtil.class);
// Utility class, should not be instantiated
private MappingMergeUtil() {
}
- public static boolean mappingIsExpired(MappingRecord mapping) {
- Preconditions.checkNotNull(mapping, "mapping should not be null!");
- if (mapping.getTimestamp() != null) {
- return timestampIsExpired(mapping.getTimestamp());
+ private static void mergeCommonMappingRecordFields(MappingRecordBuilder mrb, MappingRecord record) {
+ // Set xTR-ID and site-ID from the current mapping, it help with determining the timestamp
+ mrb.setXtrId(record.getXtrId());
+ mrb.setSiteId(record.getSiteId());
+ // For the TTL value we take the minimum of all records
+ mrb.setRecordTtl(Math.min(mrb.getRecordTtl(), record.getRecordTtl()));
+ if (!mrb.getAction().equals(record.getAction())) {
+ LOG.warn("Mapping merge operation: actions are different, which one is used is undefined");
+ }
+ if (mrb.isAuthoritative() != record.isAuthoritative()) {
+ LOG.warn("Mapping merge operation: authoritative status is different, which one is used is undefined");
+ }
+ if (!mrb.getEid().equals(record.getEid())) {
+ LOG.warn("Mapping merge operation: EID records are different, which one is used is undefined");
+ }
+ }
+
+ private static LocatorRecord mergeLocators(LocatorRecord existingLocator, LocatorRecord newLocator) {
+ if (existingLocator.isLocalLocator()) {
+ return existingLocator;
+ }
+ return newLocator;
+ }
+
+ private static int compareLocators(LocatorRecord one, LocatorRecord two) {
+ byte[] oneIp = LispAddressUtil.ipAddressToByteArray(one.getRloc().getAddress());
+ byte[] twoIp = LispAddressUtil.ipAddressToByteArray(two.getRloc().getAddress());
+ return LispAddressUtil.compareIpAddressByteArrays(oneIp, twoIp);
+ }
+
+ private static void mergeLocatorRecords(MappingRecordBuilder mrb, MappingRecord newRecord) {
+ List<LocatorRecord> locators = mrb.getLocatorRecord();
+
+ // We assume locators are unique and sorted and don't show up several times (with different or identical
+ // p/w/mp/mw), so we create a LinkedHashMap (which preserves order) of the locators from the existing merged
+ // record, keyed by the Rloc
+ Map<Rloc, LocatorRecord> locatorMap = new LinkedHashMap<Rloc, LocatorRecord>();
+
+ // All locators to be added to the merge set are first stored in this list
+ List<LocatorRecord> newLocatorList = new ArrayList<LocatorRecord>();
+
+ for (LocatorRecord locator : locators) {
+ locatorMap.put(locator.getRloc(), locator);
+ }
+ for (LocatorRecord newLocator : newRecord.getLocatorRecord()) {
+ Rloc newRloc = newLocator.getRloc();
+ if (locatorMap.containsKey(newRloc)) {
+ // overlapping locator
+ if (!locatorMap.get(newRloc).equals(newLocator)) {
+ LocatorRecord mergedLocator = mergeLocators(locatorMap.get(newRloc), newLocator);
+ newLocatorList.add(mergedLocator);
+ }
+ } else {
+ // new locator
+ newLocatorList.add(newLocator);
+ }
+ }
+
+ // Build new merged and sorted locator set if need be
+ if (!newLocatorList.isEmpty()) {
+ List<LocatorRecord> mergedLocators = new ArrayList<LocatorRecord>();
+
+ int mlocIt = 0;
+ int locIt = 0;
+ while (mlocIt < newLocatorList.size() && locIt < locators.size()) {
+ int cmp = compareLocators(locators.get(locIt), newLocatorList.get(mlocIt));
+ if (cmp < 0) {
+ mergedLocators.add(locators.get(locIt));
+ locIt++;
+ } else if (cmp > 0) {
+ mergedLocators.add(newLocatorList.get(mlocIt));
+ mlocIt++;
+ } else {
+ // when a locator appears in both lists, keep the new (merged) one and skip the old
+ mergedLocators.add(newLocatorList.get(mlocIt));
+ mlocIt++;
+ locIt++;
+ }
+ }
+ while (locIt < locators.size()) {
+ mergedLocators.add(locators.get(locIt));
+ locIt++;
+ }
+ while (mlocIt < newLocatorList.size()) {
+ mergedLocators.add(newLocatorList.get(mlocIt));
+ mlocIt++;
+ }
+ mrb.setLocatorRecord(mergedLocators);
+ }
+ }
+
+ public static MappingRecord mergeMappings(MappingRecord currentMergedMapping, MappingRecord newMapping,
+ XtrId xtrId, Date regdate) {
+ if (currentMergedMapping == null) {
+ return newMapping;
+ }
+
+ MappingRecordBuilder mrb = new MappingRecordBuilder(currentMergedMapping);
+ mergeCommonMappingRecordFields(mrb, newMapping);
+ mergeLocatorRecords(mrb, newMapping);
+
+ if (xtrId != null) {
+ mrb.setXtrId(xtrId);
+ mrb.setTimestamp(regdate.getTime());
+ }
+
+ return mrb.build();
+ }
+
+ public static MappingData mergeXtrIdMappings(List<Object> mappingDataList, List<MappingData> expiredMappingDataList,
+ Set<IpAddressBinary> sourceRlocs) {
+ MappingRecordBuilder mrb = null;
+ XtrId xtrId = null;
+ Long timestamp = Long.MAX_VALUE;
+
+ for (int i = 0; i < mappingDataList.size(); i++) {
+ MappingData mappingData = (MappingData) mappingDataList.get(i);
+ MappingRecord record = mappingData.getRecord();
+
+ // Skip expired mappings and add them to a list to be returned to the caller
+ if (timestampIsExpired(mappingData.getTimestamp())) {
+ expiredMappingDataList.add(mappingData);
+ continue;
+ }
+
+ if (mrb == null) {
+ mrb = new MappingRecordBuilder(record);
+ }
+
+ // Save the oldest valid timestamp
+ if (mappingData.getTimestamp().getTime() < timestamp) {
+ timestamp = mappingData.getTimestamp().getTime();
+ xtrId = mappingData.getXtrId();
+ }
+
+ // Merge record fields and locators
+ mergeCommonMappingRecordFields(mrb, record);
+ mergeLocatorRecords(mrb, record);
+
+ // Save source locator for use in Map-Notify
+ sourceRlocs.add(record.getSourceRloc());
+ }
+
+ if (mrb == null) {
+ LOG.warn("All mappings expired when merging! Unexpected!");
+ return null;
+ }
+ mrb.setXtrId(xtrId);
+
+ return new MappingData(mrb.build(), new Date(timestamp));
+ }
+
+ /*
+ * The following three methods intentionally throw an exception when their argument is null, because they can't
+ * decide based on that to return true or false, so the calling function should do that and only call these with
+ * non-null arguments
+ */
+ public static boolean mappingIsExpired(MappingData mappingData) {
+ Preconditions.checkNotNull(mappingData, "mapping should not be null!");
+ if (mappingData.getTimestamp() != null) {
+ return timestampIsExpired(mappingData.getTimestamp());
}
return false;
}
return timestampIsExpired(timestamp.getTime());
}
- public static boolean timestampIsExpired(Long timestamp) {
+ private static boolean timestampIsExpired(Long timestamp) {
Preconditions.checkNotNull(timestamp, "timestamp should not be null!");
- if ((System.currentTimeMillis() - timestamp) > ConfigIni.getInstance().getRegistrationValiditySb() ) {
+ if ((System.currentTimeMillis() - timestamp) > ConfigIni.getInstance().getRegistrationValiditySb()) {
return true;
}
return false;
}
- public static Object computeNbSbIntersection(MappingRecord nbMapping, MappingRecord sbMapping) {
+ public static MappingData computeNbSbIntersection(MappingData nbMappingData,
+ MappingData sbMappingData) {
+ return new MappingData(computeNbSbIntersection(nbMappingData.getRecord(), sbMappingData.getRecord()));
+ }
+
+ private static MappingRecord computeNbSbIntersection(MappingRecord nbMapping, MappingRecord sbMapping) {
// returns a MappingRecord which has the more specific EID, and intersection of locator records.
// If locators intersection is empty, original NB mapping is returned.
// The intersection is only computed for mappings with maskable EIDs.
if (nbMapping.getEid().getAddress() instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey) {
nbMask = SourceDestKeyHelper.getDstMask(nbMapping.getEid());
- if ( nbMask < sbMask) {
+ if (nbMask < sbMask) {
// We have to create a new SourceDest EID, where the source is same as the
// one in NB record, and dest EID is the more specific from SB mapping record.
if (sbLocatorMap.containsKey(nbRloc)) {
// common locator found. use the NB record as the common locator.
- if (sbLocatorMap.get(nbRloc).getPriority() == (short) 255) {
+ if (sbLocatorMap.get(nbRloc).getPriority().toJava() == (short) 255) {
// if SB locator has p == 255 then common locator takes all NB fields except for p
// which must be set to 255
LocatorRecordBuilder lrb = new LocatorRecordBuilder(nbLocator);
- lrb.setPriority((short) 255);
+ lrb.setPriority(fromJava((short) 255));
commonLocators.add(lrb.build());
} else {
commonLocators.add(nbLocator);
Code Review / lispflowmapping.git / blobdiff