You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
208 lines
7.5 KiB
208 lines
7.5 KiB
import { TelemetryEvent, TelemetryMetadataByLevel } from 'app/common/Telemetry';
|
|
import { Document } from 'app/gen-server/entity/Document';
|
|
import { Workspace } from 'app/gen-server/entity/Workspace';
|
|
import { Housekeeper } from 'app/gen-server/lib/Housekeeper';
|
|
import { Telemetry } from 'app/server/lib/Telemetry';
|
|
import { assert } from 'chai';
|
|
import * as fse from 'fs-extra';
|
|
import moment from 'moment';
|
|
import * as sinon from 'sinon';
|
|
import { TestServer } from 'test/gen-server/apiUtils';
|
|
import { openClient } from 'test/server/gristClient';
|
|
import * as testUtils from 'test/server/testUtils';
|
|
|
|
describe('Housekeeper', function() {
|
|
testUtils.setTmpLogLevel('error');
|
|
this.timeout(60000);
|
|
|
|
const org: string = 'testy';
|
|
const sandbox = sinon.createSandbox();
|
|
let home: TestServer;
|
|
let keeper: Housekeeper;
|
|
|
|
before(async function() {
|
|
home = new TestServer(this);
|
|
await home.start(['home', 'docs']);
|
|
const api = await home.createHomeApi('chimpy', 'docs');
|
|
await api.newOrg({name: org, domain: org});
|
|
keeper = home.server.housekeeper;
|
|
await keeper.stop();
|
|
});
|
|
|
|
after(async function() {
|
|
await home.stop();
|
|
sandbox.restore();
|
|
});
|
|
|
|
async function getDoc(docId: string) {
|
|
const manager = home.dbManager.connection.manager;
|
|
return manager.findOneOrFail(Document, {where: {id: docId}});
|
|
}
|
|
|
|
async function getWorkspace(wsId: number) {
|
|
const manager = home.dbManager.connection.manager;
|
|
return manager.findOneOrFail(Workspace, {where: {id: wsId}});
|
|
}
|
|
|
|
|
|
function daysAgo(days: number): Date {
|
|
return moment().subtract(days, 'days').toDate();
|
|
}
|
|
|
|
async function ageDoc(docId: string, days: number) {
|
|
const dbDoc = await getDoc(docId);
|
|
dbDoc.removedAt = daysAgo(days);
|
|
await dbDoc.save();
|
|
}
|
|
|
|
async function ageWorkspace(wsId: number, days: number) {
|
|
const dbWorkspace = await getWorkspace(wsId);
|
|
dbWorkspace.removedAt = daysAgo(days);
|
|
await dbWorkspace.save();
|
|
}
|
|
|
|
async function ageFork(forkId: string, days: number) {
|
|
const dbFork = await getDoc(forkId);
|
|
dbFork.updatedAt = daysAgo(days);
|
|
await dbFork.save();
|
|
}
|
|
|
|
it('can delete old soft-deleted docs and workspaces', async function() {
|
|
// Make four docs in one workspace, two in another.
|
|
const api = await home.createHomeApi('chimpy', org);
|
|
const ws1 = await api.newWorkspace({name: 'ws1'}, 'current');
|
|
const ws2 = await api.newWorkspace({name: 'ws2'}, 'current');
|
|
const doc11 = await api.newDoc({name: 'doc11'}, ws1);
|
|
const doc12 = await api.newDoc({name: 'doc12'}, ws1);
|
|
const doc13 = await api.newDoc({name: 'doc13'}, ws1);
|
|
const doc14 = await api.newDoc({name: 'doc14'}, ws1);
|
|
const doc21 = await api.newDoc({name: 'doc21'}, ws2);
|
|
const doc22 = await api.newDoc({name: 'doc22'}, ws2);
|
|
|
|
// Soft-delete some of the docs, and one workspace.
|
|
await api.softDeleteDoc(doc11);
|
|
await api.softDeleteDoc(doc12);
|
|
await api.softDeleteDoc(doc13);
|
|
await api.softDeleteWorkspace(ws2);
|
|
|
|
// Check that nothing is deleted by housekeeper.
|
|
await keeper.deleteTrash();
|
|
await assert.isFulfilled(getDoc(doc11));
|
|
await assert.isFulfilled(getDoc(doc12));
|
|
await assert.isFulfilled(getDoc(doc13));
|
|
await assert.isFulfilled(getDoc(doc14));
|
|
await assert.isFulfilled(getDoc(doc21));
|
|
await assert.isFulfilled(getDoc(doc22));
|
|
await assert.isFulfilled(getWorkspace(ws1));
|
|
await assert.isFulfilled(getWorkspace(ws2));
|
|
|
|
// Age a doc and workspace somewhat, but not enough to trigger hard-deletion.
|
|
await ageDoc(doc11, 10);
|
|
await ageWorkspace(ws2, 20);
|
|
await keeper.deleteTrash();
|
|
await assert.isFulfilled(getDoc(doc11));
|
|
await assert.isFulfilled(getWorkspace(ws2));
|
|
|
|
// Prematurely age two of the soft-deleted docs, and the soft-deleted workspace.
|
|
await ageDoc(doc11, 40);
|
|
await ageDoc(doc12, 40);
|
|
await ageWorkspace(ws2, 40);
|
|
|
|
// Make sure that exactly those docs are deleted by housekeeper.
|
|
await keeper.deleteTrash();
|
|
await assert.isRejected(getDoc(doc11));
|
|
await assert.isRejected(getDoc(doc12));
|
|
await assert.isFulfilled(getDoc(doc13));
|
|
await assert.isFulfilled(getDoc(doc14));
|
|
await assert.isRejected(getDoc(doc21));
|
|
await assert.isRejected(getDoc(doc22));
|
|
await assert.isFulfilled(getWorkspace(ws1));
|
|
await assert.isRejected(getWorkspace(ws2));
|
|
});
|
|
|
|
it('enforces exclusivity of housekeeping', async function() {
|
|
const first = keeper.deleteTrashExclusively();
|
|
const second = keeper.deleteTrashExclusively();
|
|
assert.equal(await first, true);
|
|
assert.equal(await second, false);
|
|
assert.equal(await keeper.deleteTrashExclusively(), false);
|
|
await keeper.testClearExclusivity();
|
|
assert.equal(await keeper.deleteTrashExclusively(), true);
|
|
});
|
|
|
|
it('can delete old forks', async function() {
|
|
// Make a document with some forks.
|
|
const api = await home.createHomeApi('chimpy', org);
|
|
const ws3 = await api.newWorkspace({name: 'ws3'}, 'current');
|
|
const trunk = await api.newDoc({name: 'trunk'}, ws3);
|
|
const session = await api.getSessionActive();
|
|
const client = await openClient(home.server, session.user.email, session.org?.domain || 'docs');
|
|
await client.openDocOnConnect(trunk);
|
|
const forkResponse1 = await client.send('fork', 0);
|
|
const forkResponse2 = await client.send('fork', 0);
|
|
const forkPath1 = home.server.getStorageManager().getPath(forkResponse1.data.docId);
|
|
const forkPath2 = home.server.getStorageManager().getPath(forkResponse2.data.docId);
|
|
const forkId1 = forkResponse1.data.forkId;
|
|
const forkId2 = forkResponse2.data.forkId;
|
|
|
|
// Age the forks somewhat, but not enough to trigger hard-deletion.
|
|
await ageFork(forkId1, 10);
|
|
await ageFork(forkId2, 20);
|
|
await keeper.deleteTrash();
|
|
await assert.isFulfilled(getDoc(forkId1));
|
|
await assert.isFulfilled(getDoc(forkId2));
|
|
assert.equal(await fse.pathExists(forkPath1), true);
|
|
assert.equal(await fse.pathExists(forkPath2), true);
|
|
|
|
// Age one of the forks beyond the cleanup threshold.
|
|
await ageFork(forkId2, 40);
|
|
|
|
// Make sure that only that fork is deleted by housekeeper.
|
|
await keeper.deleteTrash();
|
|
await assert.isFulfilled(getDoc(forkId1));
|
|
await assert.isRejected(getDoc(forkId2));
|
|
assert.equal(await fse.pathExists(forkPath1), true);
|
|
assert.equal(await fse.pathExists(forkPath2), false);
|
|
});
|
|
|
|
it('can log metrics about sites', async function() {
|
|
const logMessages: [TelemetryEvent, TelemetryMetadataByLevel?][] = [];
|
|
sandbox.stub(Telemetry.prototype, 'shouldLogEvent').callsFake((name) => true);
|
|
sandbox.stub(Telemetry.prototype, 'logEvent').callsFake((_, name, meta) => {
|
|
// Skip document usage events that could be arriving in the
|
|
// middle of this test.
|
|
if (name !== 'documentUsage') {
|
|
logMessages.push([name, meta]);
|
|
}
|
|
return Promise.resolve();
|
|
});
|
|
await keeper.logMetrics();
|
|
assert.isNotEmpty(logMessages);
|
|
let [event, meta] = logMessages[0];
|
|
assert.equal(event, 'siteUsage');
|
|
assert.hasAllKeys(meta?.limited, [
|
|
'siteId',
|
|
'siteType',
|
|
'inGoodStanding',
|
|
'numDocs',
|
|
'numWorkspaces',
|
|
'numMembers',
|
|
'lastActivity',
|
|
'earliestDocCreatedAt',
|
|
]);
|
|
assert.hasAllKeys(meta?.full, [
|
|
'stripePlanId',
|
|
]);
|
|
[event, meta] = logMessages[logMessages.length - 1];
|
|
assert.equal(event, 'siteMembership');
|
|
assert.hasAllKeys(meta?.limited, [
|
|
'siteId',
|
|
'siteType',
|
|
'numOwners',
|
|
'numEditors',
|
|
'numViewers',
|
|
]);
|
|
assert.isUndefined(meta?.full);
|
|
});
|
|
});
|