public interface SubKeys {
String AUTH_KEY = "password";
String RECORD = "address";
+ String EXT_RECORD = "ext_address";
String XTRID_RECORDS = "xtrid";
String SUBSCRIBERS = "subscribers";
String SRC_RLOCS = "src_rlocs";
builder.getLocatorRecord().add(LocatorRecordSerializer.getInstance().deserialize(buffer));
}
- builder.setTimestamp(System.currentTimeMillis());
-
return builder;
}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.lispflowmapping.mapcache;
+
+import java.util.Date;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
+
+/**
+ * Wrapper class for MappingRecord with timestamp added.
+ *
+ * @author Lorand Jakab
+ *
+ */
+public class ExtendedMappingRecord {
+ private MappingRecord record;
+ private Date timestamp;
+
+ public ExtendedMappingRecord(MappingRecord record, Date timestamp) {
+ setRecord(record);
+ setTimestamp(timestamp);
+ }
+
+ public ExtendedMappingRecord(MappingRecord record) {
+ this(record, null);
+ }
+
+ public MappingRecord getRecord() {
+ return record;
+ }
+
+ public void setRecord(MappingRecord record) {
+ this.record = record;
+ }
+
+ public Date getTimestamp() {
+ return timestamp;
+ }
+
+ public void setTimestamp(Date timestamp) {
+ this.timestamp = timestamp;
+ }
+}
return mrb.build();
}
- public static MappingRecord mergeXtrIdMappings(List<Object> records, List<XtrId> expiredMappings,
+ public static ExtendedMappingRecord mergeXtrIdMappings(List<Object> extendedRecords, List<XtrId> expiredMappings,
Set<IpAddressBinary> sourceRlocs) {
MappingRecordBuilder mrb = null;
XtrId xtrId = null;
Long timestamp = Long.MAX_VALUE;
- for (int i = 0; i < records.size(); i++) {
- MappingRecord record = (MappingRecord) records.get(i);
+ for (int i = 0; i < extendedRecords.size(); i++) {
+ ExtendedMappingRecord extendedRecord = (ExtendedMappingRecord) extendedRecords.get(i);
+ MappingRecord record = extendedRecord.getRecord();
// Skip expired mappings and add them to a list to be returned to the caller
- if (timestampIsExpired(record.getTimestamp())) {
+ if (timestampIsExpired(extendedRecord.getTimestamp())) {
expiredMappings.add(record.getXtrId());
continue;
}
if (mrb == null) {
- mrb = new MappingRecordBuilder((MappingRecord) records.get(i));
+ mrb = new MappingRecordBuilder(record);
}
// Save the oldest valid timestamp
- if (record.getTimestamp() < timestamp) {
- timestamp = record.getTimestamp();
+ if (extendedRecord.getTimestamp().getTime() < timestamp) {
+ timestamp = extendedRecord.getTimestamp().getTime();
xtrId = record.getXtrId();
}
return null;
}
mrb.setXtrId(xtrId);
- mrb.setTimestamp(timestamp);
- return mrb.build();
+ return new ExtendedMappingRecord(mrb.build(), new Date(timestamp));
}
- public static boolean mappingIsExpired(MappingRecord mapping) {
+ public static boolean mappingIsExpired(ExtendedMappingRecord mapping) {
Preconditions.checkNotNull(mapping, "mapping should not be null!");
if (mapping.getTimestamp() != null) {
return timestampIsExpired(mapping.getTimestamp());
private void removeExpiredXtrIdTableEntries(ILispDAO xtrIdDao, List<XtrId> expiredMappings) {
for (XtrId xtrId : expiredMappings) {
- xtrIdDao.removeSpecific(xtrId, SubKeys.RECORD);
+ xtrIdDao.removeSpecific(xtrId, SubKeys.EXT_RECORD);
}
}
return;
}
- Date regdate = new Date(record.getTimestamp()); // The serializer always sets it
+ Date regdate = new Date(System.currentTimeMillis());
Eid eid = MaskUtil.normalize(key);
ILispDAO table = getOrInstantiateVniTable(key);
ILispDAO xtrIdDao = null;
if (!shouldOverwrite && record.getXtrId() != null) {
xtrIdDao = getOrInstantiateXtrIdTable(eid, table);
- xtrIdDao.put(record.getXtrId(), new MappingEntry<>(SubKeys.RECORD, value));
+ xtrIdDao.put(record.getXtrId(), new MappingEntry<>(SubKeys.EXT_RECORD,
+ new ExtendedMappingRecord(record, regdate)));
}
if (shouldMerge) {
List<XtrId> expiredMappings = new ArrayList<>();
Set<IpAddressBinary> sourceRlocs = new HashSet<>();
- MappingRecord mergedEntry = MappingMergeUtil.mergeXtrIdMappings(getXtrIdMappingList(xtrIdDao),
+ ExtendedMappingRecord mergedEntry = MappingMergeUtil.mergeXtrIdMappings(getXtrIdMappingList(xtrIdDao),
expiredMappings, sourceRlocs);
removeExpiredXtrIdTableEntries(xtrIdDao, expiredMappings);
if (mergedEntry == null) {
return;
}
- regdate = new Date(mergedEntry.getTimestamp());
+ regdate = mergedEntry.getTimestamp();
table.put(eid, new MappingEntry<>(SubKeys.REGDATE, regdate));
- table.put(eid, new MappingEntry<>(SubKeys.RECORD, mergedEntry));
+ table.put(eid, new MappingEntry<>(SubKeys.RECORD, mergedEntry.getRecord()));
table.put(eid, new MappingEntry<>(SubKeys.SRC_RLOCS, sourceRlocs));
} else {
table.put(eid, new MappingEntry<>(SubKeys.REGDATE, regdate));
final List<Object> records = new ArrayList<>();
dao.getAll(new IRowVisitor() {
public void visitRow(Object keyId, String valueKey, Object value) {
- if (valueKey.equals(SubKeys.RECORD)) {
+ if (valueKey.equals(SubKeys.EXT_RECORD)) {
records.add(value);
}
}
if (xtrId != null) {
ILispDAO xtrIdTable = getXtrIdTable(eid, (ILispDAO) daoEntry.getValue().get(SubKeys.XTRID_RECORDS));
if (xtrIdTable != null) {
- MappingRecord xtrIdRecord = (MappingRecord) xtrIdTable.getSpecific(xtrId, SubKeys.RECORD);
+ ExtendedMappingRecord xtrIdRecord = (ExtendedMappingRecord) xtrIdTable.getSpecific(xtrId,
+ SubKeys.EXT_RECORD);
if (xtrIdRecord.getTimestamp() != null
&& MappingMergeUtil.timestampIsExpired(xtrIdRecord.getTimestamp())) {
- xtrIdTable.removeSpecific(xtrId, SubKeys.RECORD);
+ xtrIdTable.removeSpecific(xtrId, SubKeys.EXT_RECORD);
return null;
} else {
- return xtrIdRecord;
+ return xtrIdRecord.getRecord();
}
} else {
return null;
if (daoEntry != null) {
daoEntry.put(SubKeys.REGDATE, new Date(timestamp));
}
+
+ XtrId xtrId = ((MappingRecord) daoEntry.get(SubKeys.RECORD)).getXtrId();
+ if (xtrId != null) {
+ ILispDAO xtrIdTable = getXtrIdTable(eid, (ILispDAO) daoEntry.get(SubKeys.XTRID_RECORDS));
+ ExtendedMappingRecord extRecord = (ExtendedMappingRecord) xtrIdTable.getSpecific(xtrId,
+ SubKeys.EXT_RECORD);
+ if (extRecord != null) {
+ extRecord.setTimestamp(new Date(timestamp));
+ }
+ }
}
@Override
*/
@Test
public void mergeXtrIdMappingsTest_verifyExpiredMappings() {
- MappingRecord expiredMappingRecord1 = getDefaultMappingRecordBuilder().setTimestamp(1L).build();
- MappingRecord expiredMappingRecord2 = getDefaultMappingRecordBuilder()
- .setXtrId(XTR_ID_2)
- .setTimestamp(1L).build();
+ ExtendedMappingRecord expiredRecord1 = new ExtendedMappingRecord(getDefaultMappingRecordBuilder().build());
+ expiredRecord1.setTimestamp(new Date(1L));
+ ExtendedMappingRecord expiredRecord2 = new ExtendedMappingRecord(getDefaultMappingRecordBuilder()
+ .setXtrId(XTR_ID_2).build());
+ expiredRecord2.setTimestamp(new Date(1L));
List<XtrId> expiredMappings = Lists.newArrayList();
- List<Object> mappingRecords =
- Lists.newArrayList(expiredMappingRecord1, expiredMappingRecord2);
+ List<Object> records =
+ Lists.newArrayList(expiredRecord1, expiredRecord2);
- assertNull(MappingMergeUtil.mergeXtrIdMappings(mappingRecords, expiredMappings, null));
+ assertNull(MappingMergeUtil.mergeXtrIdMappings(records, expiredMappings, null));
assertEquals(2, expiredMappings.size());
assertTrue(expiredMappings.contains(XTR_ID_1));
assertTrue(expiredMappings.contains(XTR_ID_2));
final long timestamp_2 = timestamp - 300L; // oldest mapping
final long timestamp_3 = timestamp - 100L;
- final MappingRecord expiredMappingRecord_1 = getDefaultMappingRecordBuilder()
- .setTimestamp(timestamp_1).build();
- final MappingRecord expiredMappingRecord_2 = getDefaultMappingRecordBuilder()
+ ExtendedMappingRecord expiredRecord1 = new ExtendedMappingRecord(getDefaultMappingRecordBuilder().build());
+ expiredRecord1.setTimestamp(new Date(timestamp_1));
+ ExtendedMappingRecord expiredRecord2 = new ExtendedMappingRecord(getDefaultMappingRecordBuilder()
.setSourceRloc(IPV4_SOURCE_RLOC_2)
- .setXtrId(XTR_ID_2)
- .setTimestamp(timestamp_2).build();
- final MappingRecord expiredMappingRecord_3 = getDefaultMappingRecordBuilder()
+ .setXtrId(XTR_ID_2).build());
+ expiredRecord2.setTimestamp(new Date(timestamp_2));
+ ExtendedMappingRecord expiredRecord3 = new ExtendedMappingRecord(getDefaultMappingRecordBuilder()
.setSourceRloc(IPV4_SOURCE_RLOC_3)
- .setXtrId(XTR_ID_3)
- .setTimestamp(timestamp_3).build();
+ .setXtrId(XTR_ID_3).build());
+ expiredRecord3.setTimestamp(new Date(timestamp_3));
Set<IpAddressBinary> sourceRlocs = Sets.newHashSet();
final List<XtrId> expiredMappings = Lists.newArrayList();
final List<Object> mappingRecords =
- Lists.newArrayList(expiredMappingRecord_1, expiredMappingRecord_2, expiredMappingRecord_3);
+ Lists.newArrayList(expiredRecord1, expiredRecord2, expiredRecord3);
// result
- MappingRecord result = MappingMergeUtil.mergeXtrIdMappings(mappingRecords, expiredMappings, sourceRlocs);
- assertEquals(timestamp_2, (long) result.getTimestamp());
- assertEquals(XTR_ID_2, result.getXtrId());
+ ExtendedMappingRecord result = MappingMergeUtil.mergeXtrIdMappings(
+ mappingRecords, expiredMappings, sourceRlocs);
+ assertEquals(timestamp_2, (long) result.getTimestamp().getTime());
+ assertEquals(XTR_ID_2, result.getRecord().getXtrId());
assertTrue(sourceRlocs.size() == 3);
assertTrue(sourceRlocs.contains(IPV4_SOURCE_RLOC_1));
@Test
public void mappingIsExpiredTest() {
long timestamp = new Date().getTime();
- MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
- assertTrue(MappingMergeUtil.mappingIsExpired(mappingRecordBuilder
- .setTimestamp(timestamp - (REGISTRATION_VALIDITY + 1L)).build()));
- assertFalse(MappingMergeUtil.mappingIsExpired(mappingRecordBuilder.setTimestamp(timestamp).build()));
- assertFalse(MappingMergeUtil.mappingIsExpired(mappingRecordBuilder.setTimestamp(null).build()));
+ ExtendedMappingRecord emr = new ExtendedMappingRecord(getDefaultMappingRecordBuilder().build());
+ emr.setTimestamp(new Date(timestamp - (REGISTRATION_VALIDITY + 1L)));
+ assertTrue(MappingMergeUtil.mappingIsExpired(emr));
+ emr.setTimestamp(new Date(timestamp));
+ assertFalse(MappingMergeUtil.mappingIsExpired(emr));
+ emr.setTimestamp(null);
+ assertFalse(MappingMergeUtil.mappingIsExpired(emr));
}
/**
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
private static ILispDAO tableMock;
private static ILispDAO xtrIdDaoMock;
+ private static ILispDAO xtrIdTableDaoMock;
private static MappingRecord mappingRecordMock;
+ private static ExtendedMappingRecord extendedMappingRecordMock;
private static ILispDAO daoMock;
private static SimpleMapCache simpleMapCache;
daoMock = Mockito.mock(ILispDAO.class, "dao");
tableMock = Mockito.mock(ILispDAO.class);
xtrIdDaoMock = Mockito.mock(ILispDAO.class);
+ xtrIdTableDaoMock = Mockito.mock(ILispDAO.class);
mappingRecordMock = Mockito.mock(MappingRecord.class);
+ extendedMappingRecordMock = Mockito.mock(ExtendedMappingRecord.class);
simpleMapCache = new SimpleMapCache(daoMock);
}
final SimpleImmutableEntry<Eid, Map<String, ?>> mapPair = new SimpleImmutableEntry<>(
NORMALIZED_EID_IPV4_PREFIX_DST, mapMock);
final ILispDAO xtrIdRecordsMock = Mockito.mock(ILispDAO.class);
- final MappingRecord expiredMappingRecord = getDefaultMappingRecordBuilder().setTimestamp(1L).build(); // expired
- final MappingRecord mappingRecord = getDefaultMappingRecordBuilder().build(); // not expired
+ final ExtendedMappingRecord expiredMappingRecord = new ExtendedMappingRecord(getDefaultMappingRecordBuilder()
+ .build());
+ expiredMappingRecord.setTimestamp(new Date(1L)); //expired
+ final ExtendedMappingRecord mappingRecord = new ExtendedMappingRecord(getDefaultMappingRecordBuilder().build());
Mockito.when(daoMock.getSpecific(VNI_0, SubKeys.VNI)).thenReturn(tableMock);
Mockito.when(tableMock.getBestPair(NORMALIZED_EID_IPV4_PREFIX_DST)).thenReturn(mapPair);
Mockito.when(mapMock.get(SubKeys.XTRID_RECORDS)).thenReturn(xtrIdRecordsMock);
Mockito.when(xtrIdRecordsMock.getSpecific(EID_IPV4_PREFIX_DST, SubKeys.XTRID_RECORDS)).thenReturn(xtrIdDaoMock);
- Mockito.when(xtrIdDaoMock.getSpecific(XTR_ID, SubKeys.RECORD))
+ Mockito.when(xtrIdDaoMock.getSpecific(XTR_ID, SubKeys.EXT_RECORD))
.thenReturn(expiredMappingRecord) // first invocation
.thenReturn(mappingRecord); // second invocation
// with expired mapping record
assertNull(simpleMapCache.getMapping(null, EID_IPV4_PREFIX_DST, XTR_ID));
- Mockito.verify(xtrIdDaoMock, Mockito.atMost(1)).removeSpecific(XTR_ID, SubKeys.RECORD);
+ Mockito.verify(xtrIdDaoMock, Mockito.atMost(1)).removeSpecific(XTR_ID, SubKeys.EXT_RECORD);
// with non-expired mapping record
- assertEquals(mappingRecord, simpleMapCache.getMapping(null, EID_IPV4_PREFIX_DST, XTR_ID));
+ assertEquals(mappingRecord.getRecord(), simpleMapCache.getMapping(null, EID_IPV4_PREFIX_DST, XTR_ID));
}
/**
final Map<String, Object> entryMock = Mockito.mock(Map.class);
Mockito.when(daoMock.getSpecific(VNI_0, SubKeys.VNI)).thenReturn(tableMock);
Mockito.when(tableMock.getBest(NORMALIZED_EID_IPV4)).thenReturn(entryMock);
+ Mockito.when(entryMock.get(SubKeys.RECORD)).thenReturn(mappingRecordMock);
+ Mockito.when(entryMock.get(SubKeys.XTRID_RECORDS)).thenReturn(xtrIdDaoMock);
+ Mockito.when(xtrIdDaoMock.getSpecific(EID_IPV4, SubKeys.XTRID_RECORDS)).thenReturn(xtrIdTableDaoMock);
+ Mockito.when(mappingRecordMock.getXtrId()).thenReturn(new XtrId(XTR_ID));
+ Mockito.when(xtrIdTableDaoMock.getSpecific(new XtrId(XTR_ID), SubKeys.EXT_RECORD))
+ .thenReturn(extendedMappingRecordMock);
simpleMapCache.updateMappingRegistration(EID_IPV4, null);
Mockito.verify(entryMock).put(Mockito.eq(SubKeys.REGDATE), Mockito.any(Date.class));
@Test
@SuppressWarnings("unchecked")
public void addMappingTest_mappingMergeTrue() throws Exception {
- Mockito.when(mappingRecordMock.getTimestamp()).thenReturn(System.currentTimeMillis());
+ final Date timestamp = new Date(System.currentTimeMillis());
Mockito.when(daoMock.getSpecific(VNI_100, SubKeys.VNI)).thenReturn(tableMock);
Mockito.when(tableMock.getSpecific(NORMALIZED_EID_1, SubKeys.XTRID_RECORDS)).thenReturn(xtrIdDaoMock);
Mockito.when(mappingRecordMock.getXtrId()).thenReturn(new XtrId(XTR_ID));
PowerMockito.mockStatic(MappingMergeUtil.class);
PowerMockito.when(MappingMergeUtil.mergeXtrIdMappings(Mockito.anyList(), Mockito.anyList(), Mockito.anySet()))
- .thenReturn(getDefaultMappingRecordBuilder().build());
+ .thenReturn(new ExtendedMappingRecord(getDefaultMappingRecordBuilder().build(), timestamp));
+ final ArgumentCaptor<MappingEntry> captor = ArgumentCaptor.forClass(MappingEntry.class);
simpleMapCache.addMapping(EID_IPV4_PREFIX_1_VNI, mappingRecordMock, false, true);
- Mockito.verify(xtrIdDaoMock).put(new XtrId(XTR_ID), new MappingEntry<>(SubKeys.RECORD, mappingRecordMock));
+
+ Mockito.verify(xtrIdDaoMock).put(Mockito.eq(new XtrId(XTR_ID)), captor.capture());
Mockito.verify(tableMock)
- .put(NORMALIZED_EID_1, new MappingEntry<>(SubKeys.REGDATE, new Date(Long.MAX_VALUE)));
+ .put(NORMALIZED_EID_1, new MappingEntry<>(SubKeys.REGDATE, timestamp));
Mockito.verify(tableMock)
.put(NORMALIZED_EID_1, new MappingEntry<>(SubKeys.RECORD, getDefaultMappingRecordBuilder().build()));
+ assertEquals(mappingRecordMock, ((ExtendedMappingRecord) captor.getValue().getValue()).getRecord());
}
/**
*/
@Test
public void addMappingTest_mappingMergeFalse() throws Exception {
- Mockito.when(mappingRecordMock.getTimestamp()).thenReturn(Long.MAX_VALUE);
+ final Date timestamp = new Date(System.currentTimeMillis());
+ Mockito.when(mappingRecordMock.getTimestamp()).thenReturn(timestamp.getTime());
Mockito.when(daoMock.getSpecific(VNI_100, SubKeys.VNI)).thenReturn(tableMock);
Mockito.when(tableMock.getSpecific(NORMALIZED_EID_1, SubKeys.XTRID_RECORDS)).thenReturn(xtrIdDaoMock);
Mockito.when(mappingRecordMock.getXtrId()).thenReturn(new XtrId(XTR_ID));
simpleMapCache.addMapping(EID_IPV4_PREFIX_1_VNI, mappingRecordMock, false, false);
- Mockito.verify(xtrIdDaoMock).put(new XtrId(XTR_ID), new MappingEntry<>(SubKeys.RECORD, mappingRecordMock));
+ final ArgumentCaptor<MappingEntry> captor = ArgumentCaptor.forClass(MappingEntry.class);
- Mockito.verify(tableMock)
- .put(NORMALIZED_EID_1, new MappingEntry<>(SubKeys.REGDATE, new Date(Long.MAX_VALUE)));
+ Mockito.verify(xtrIdDaoMock).put(Mockito.eq(new XtrId(XTR_ID)), captor.capture());
Mockito.verify(tableMock)
.put(NORMALIZED_EID_1, new MappingEntry<>(SubKeys.RECORD, mappingRecordMock));
+ assertEquals(mappingRecordMock, ((ExtendedMappingRecord) captor.getValue().getValue()).getRecord());
}
/**
Code Review / lispflowmapping.git / commitdiff