mystiq/hydrogen-web
Archived
4
1
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity

work on filling gaps + test (draft only)

Browse source
This commit is contained in:
Bruno Windels 2019-03-21 21:35:33 +01:00
parent cc3a181128
commit 8f7e5a799c
1 changed files with 150 additions and 59 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

209
src/matrix/room/persister.js
View file

@ -8,6 +8,24 @@ function gapEntriesAreEqual(a, b) {
return gapA.prev_batch === gapB.prev_batch && gapA.next_batch === gapB.next_batch;
}
function replaceGapEntries(roomTimeline, newEntries, gapKey, neighbourEventKey, backwards) {
let replacedRange;
if (neighbourEventKey) {
replacedRange = backwards ?
roomTimeline.boundRange(neighbourEventKey, gapKey, false, true) :
roomTimeline.boundRange(gapKey, neighbourEventKey, true, false);
} else {
replacedRange = roomTimeline.onlyRange(gapKey);
}
const removedEntries = roomTimeline.getAndRemoveRange(this._roomId, replacedRange);
for (let entry of newEntries) {
roomTimeline.add(entry);
}
return removedEntries;
}
export default class RoomPersister {
constructor({roomId, storage}) {
this._roomId = roomId;
@ -26,77 +44,38 @@ export default class RoomPersister {
}
}
async persistGapFill(gapEntry, response) {
async persistGapFill(gapEntry, response) {
const backwards = !!gapEntry.prev_batch;
const {chunk, start, end} = response;
if (!Array.isArray(chunk)) {
throw new Error("Invalid chunk in response");
}
if (typeof start !== "string" || typeof end !== "string") {
throw new Error("Invalid start or end token in response");
if (typeof end !== "string") {
throw new Error("Invalid end token in response");
}
if ((backwards && start !== gapEntry.prev_batch) || (!backwards && start !== gapEntry.next_batch)) {
throw new Error("start is not equal to prev_batch or next_batch");
}
const gapKey = gapEntry.sortKey;
const txn = await this._storage.readWriteTxn([this._storage.storeNames.roomTimeline]);
let result;
try {
const roomTimeline = txn.roomTimeline;
// make sure what we've been given is actually persisted
// in the timeline, otherwise we're replacing something
// that doesn't exist (maybe it has been replaced already, or ...)
const persistedEntry = await roomTimeline.findEntry(this._roomId, gapKey);
const persistedEntry = await roomTimeline.get(this._roomId, gapKey);
if (!gapEntriesAreEqual(gapEntry, persistedEntry)) {
throw new Error("Gap is not present in the timeline");
}
// find the previous event before the gap we could blend with
const backwards = !!gapEntry.prev_batch;
let neighbourEventEntry;
if (backwards) {
neighbourEventEntry = await roomTimeline.previousEventFromGap(this._roomId, gapKey);
} else {
neighbourEventEntry = await roomTimeline.nextEventFromGap(this._roomId, gapKey);
}
const neighbourEvent = neighbourEventEntry && neighbourEventEntry.event;
const newEntries = [];
let sortKey = gapKey;
let eventFound = false;
if (backwards) {
for (let i = chunk.length - 1; i >= 0; i--) {
const event = chunk[i];
if (event.id === neighbourEvent.id) {
eventFound = true;
break;
}
newEntries.splice(0, 0, this._createEventEntry(sortKey, event));
sortKey = sortKey.previousKey();
}
if (!eventFound) {
newEntries.splice(0, 0, this._createBackwardGapEntry(sortKey, end));
}
} else {
for (let i = 0; i < chunk.length; i++) {
const event = chunk[i];
if (event.id === neighbourEvent.id) {
eventFound = true;
break;
}
newEntries.push(this._createEventEntry(sortKey, event));
sortKey = sortKey.nextKey();
}
if (!eventFound) {
// need to check start is correct here
newEntries.push(this._createForwardGapEntry(sortKey, start));
}
}
if (eventFound) {
// remove gap on the other side as well,
// or while we're at it, remove all gaps between gapKey and neighbourEventEntry.sortKey
} else {
roomTimeline.deleteEntry(this._roomId, gapKey);
}
for (let entry of newEntries) {
roomTimeline.add(entry);
}
// find the previous event before the gap we could merge with
const neighbourEventEntry = await roomTimeline.findSubsequentEvent(this._roomId, gapKey, backwards);
const neighbourEventId = neighbourEventEntry ? neighbourEventEntry.event.event_id : undefined;
const {newEntries, eventFound} = this._createNewGapEntries(chunk, end, gapKey, neighbourEventId, backwards);
const neighbourEventKey = eventFound ? neighbourEventEntry.sortKey : undefined;
const replacedEntries = replaceGapEntries(roomTimeline, newEntries, gapKey, neighbourEventKey, backwards);
result = {newEntries, replacedEntries};
} catch (err) {
txn.abort();
throw err;
@ -104,9 +83,35 @@ export default class RoomPersister {
await txn.complete();
// somehow also return all the gaps we removed so the timeline can do the same
return {newEntries};
}
return result;
}
_createNewGapEntries(chunk, nextPaginationToken, gapKey, neighbourEventId, backwards) {
if (backwards) {
// if backwards, the last events are the ones closest to the gap,
// and need to be assigned a key derived from the gap first,
// so swap order to only need one loop for both directions
chunk.reverse();
}
let sortKey = gapKey;
const {newEntries, eventFound} = chunk.reduce((acc, event) => {
acc.eventFound = acc.eventFound || event.event_id === neighbourEventId;
if (!acc.eventFound) {
acc.newEntries.push(this._createEventEntry(sortKey, event));
sortKey = backwards ? sortKey.previousKey() : sortKey.nextKey();
}
}, {newEntries: [], eventFound: false});
if (!eventFound) {
// as we're replacing an existing gap, no need to increment the gap index
newEntries.push(this._createGapEntry(sortKey, nextPaginationToken, backwards));
}
if (backwards) {
// swap resulting array order again if needed
newEntries.reverse();
}
return {newEntries, eventFound};
}
persistSync(roomResponse, txn) {
let nextKey = this._lastSortKey;
@ -182,3 +187,89 @@ export default class RoomPersister {
};
}
}
//#ifdef TESTS
import {StorageMock, RoomTimelineMock} from "../../src/mocks/storage.js";
export async function tests() {
const roomId = "!abc:hs.tld";
function areSorted(entries) {
for (var i = 1; i < entries.length; i++) {
const isSorted = entries[i - 1].sortKey.compare(entries[i].sortKey) < 0;
if(!isSorted) {
return false
}
}
return true;
}
return {
"test backwards gap fill with overlapping neighbouring event": async function(assert) {
const currentPaginationToken = "abc";
const gap = {gap: {prev_batch: currentPaginationToken}};
// assigns roomId and sortKey
const roomTimeline = RoomTimelineMock.forRoom(roomId, [
{event: {event_id: "b"}},
{gap: {next_batch: "ghi"}},
gap,
]);
const persister = new RoomPersister(roomId, new StorageMock({roomTimeline}));
const response = {
start: currentPaginationToken,
end: "def",
chunk: [
{event_id: "a"},
{event_id: "b"},
{event_id: "c"},
{event_id: "d"},
]
};
const {newEntries, replacedEntries} = await persister.persistGapFill(gap, response);
// should only have taken events up till existing event
assert.equal(newEntries.length, 2);
assert.equal(newEntries[0].event.event_id, "c");
assert.equal(newEntries[1].event.event_id, "d");
assert.equal(replacedEntries.length, 2);
assert.equal(replacedEntries[0].gap.next_batch, "hij");
assert.equal(replacedEntries[1].gap.prev_batch, currentPaginationToken);
assert(areSorted(newEntries));
assert(areSorted(replacedEntries));
},
"test backwards gap fill with non-overlapping neighbouring event": async function(assert) {
const currentPaginationToken = "abc";
const newPaginationToken = "def";
const gap = {gap: {prev_batch: currentPaginationToken}};
// assigns roomId and sortKey
const roomTimeline = RoomTimelineMock.forRoom(roomId, [
{event: {event_id: "a"}},
{gap: {next_batch: "ghi"}},
gap,
]);
const persister = new RoomPersister(roomId, new StorageMock({roomTimeline}));
const response = {
start: currentPaginationToken,
end: newPaginationToken,
chunk: [
{event_id: "c"},
{event_id: "d"},
{event_id: "e"},
{event_id: "f"},
]
};
const {newEntries, replacedEntries} = await persister.persistGapFill(gap, response);
// should only have taken events up till existing event
assert.equal(newEntries.length, 5);
assert.equal(newEntries[0].gap.prev_batch, newPaginationToken);
assert.equal(newEntries[1].event.event_id, "c");
assert.equal(newEntries[2].event.event_id, "d");
assert.equal(newEntries[3].event.event_id, "e");
assert.equal(newEntries[4].event.event_id, "f");
assert(areSorted(newEntries));
assert.equal(replacedEntries.length, 1);
assert.equal(replacedEntries[0].gap.prev_batch, currentPaginationToken);
},
}
}
//#endif