Files
road-compiler/src/compile/road-revisions.js
T

315 lines
12 KiB
JavaScript

'use strict';
const crypto = require('crypto');
const fs = require('fs');
const path = require('path');
const { emptyEditDocument, loadEditDocument, saveEditDocument, validateEditDocument } = require('./native-road-edits');
const REVISION_SCHEMA = 'road-workbench-revision/v1';
const ACTIVE_STATE_SCHEMA = 'road-workbench-active/v1';
const AREA_CONFIG_SNAPSHOT_SCHEMA = 'road-workbench-area-config/v1';
const PACKAGE_VERSION = require('../../package.json').version;
const GEOMETRY_SCHEMA = 'native-road-package/v1.1';
function sha256(bytes) {
return crypto.createHash('sha256').update(bytes).digest('hex');
}
function readFile(file) {
if (!fs.existsSync(file)) throw new Error(`Revision source is missing: ${file}`);
return fs.readFileSync(file);
}
function writeFileAtomic(file, bytes) {
fs.mkdirSync(path.dirname(file), { recursive: true });
const staging = `${file}.${process.pid}.tmp`;
fs.writeFileSync(staging, bytes);
fs.renameSync(staging, file);
}
function writeJsonAtomic(file, value) {
writeFileAtomic(file, `${JSON.stringify(value, null, 2)}\n`);
}
function pathsFor(workspace) {
return {
workspace,
sourceOsm: path.join(workspace, 'source.osm'),
overrides: path.join(workspace, 'native-road-overrides.json'),
trafficSignals: path.join(workspace, 'native-traffic-signals.json'),
osmDirectory: path.join(workspace, 'osm'),
activeDirectory: path.join(workspace, 'active'),
activeEdits: path.join(workspace, 'active', 'native-road-edits.json'),
activeAreaConfig: path.join(workspace, 'active', 'area-config.snapshot.json'),
activeState: path.join(workspace, 'active', 'state.json'),
revisionsDirectory: path.join(workspace, 'revisions'),
};
}
function storeOsm(paths) {
const bytes = readFile(paths.sourceOsm);
const digest = sha256(bytes);
const file = path.join(paths.osmDirectory, `${digest}.osm`);
if (fs.existsSync(file)) {
if (sha256(fs.readFileSync(file)) !== digest) throw new Error(`Content-addressed OSM is corrupt: ${file}`);
} else {
writeFileAtomic(file, bytes);
}
return { file, digest };
}
function revisionId(revisionsDirectory) {
const numbers = fs.existsSync(revisionsDirectory)
? fs
.readdirSync(revisionsDirectory, { withFileTypes: true })
.filter((entry) => entry.isDirectory())
.map((entry) => /^rev-(\d{4})$/.exec(entry.name))
.filter(Boolean)
.map((match) => Number(match[1]))
: [];
return `rev-${String(Math.max(0, ...numbers) + 1).padStart(4, '0')}`;
}
function activeDocument(paths, osmSha256, areaConfigSha256) {
if (fs.existsSync(paths.activeEdits)) {
const document = validateEditDocument(readJson(paths.activeEdits));
if (areaConfigSha256 && document.base.areaConfigSha256 !== areaConfigSha256) {
document.base.areaConfigSha256 = areaConfigSha256;
writeJsonAtomic(paths.activeEdits, document);
}
return document;
}
const document = emptyEditDocument({ osmSha256, areaConfigSha256, compilerGeometryVersion: GEOMETRY_SCHEMA });
writeJsonAtomic(paths.activeEdits, document);
return document;
}
function writeActiveAreaConfig(paths, options) {
if (!options || typeof options !== 'object') throw new Error('Area config options must be an object.');
const snapshot = { schema: AREA_CONFIG_SNAPSHOT_SCHEMA, options };
const bytes = `${JSON.stringify(snapshot, null, 2)}\n`;
writeFileAtomic(paths.activeAreaConfig, bytes);
return { bytes, options, digest: sha256(bytes) };
}
function setActiveAreaConfig(workspace, options) {
const paths = pathsFor(workspace);
const areaConfig = writeActiveAreaConfig(paths, options);
if (fs.existsSync(paths.activeEdits)) {
const document = loadEditDocument(paths.activeEdits);
const saved = saveEditDocument(paths.activeEdits, {
...document,
base: { ...document.base, areaConfigSha256: areaConfig.digest },
});
if (fs.existsSync(paths.activeState)) {
writeJsonAtomic(paths.activeState, { ...readJson(paths.activeState), documentVersion: saved.documentVersion });
}
}
return { paths, areaConfig };
}
function readAreaConfigSnapshot(file) {
if (!fs.existsSync(file)) throw new Error(`Area config snapshot is missing: ${file}`);
const snapshot = readJson(file);
if (
!snapshot ||
snapshot.schema !== AREA_CONFIG_SNAPSHOT_SCHEMA ||
!snapshot.options ||
typeof snapshot.options !== 'object'
)
throw new Error(`Invalid area config snapshot: ${file}`);
return snapshot.options;
}
function activeAreaConfig(paths) {
const bytes = readFile(paths.activeAreaConfig);
return { bytes, options: readAreaConfigSnapshot(paths.activeAreaConfig), digest: sha256(bytes) };
}
function ensureRevisionStore(workspace, options) {
const paths = pathsFor(workspace);
const osm = storeOsm(paths);
const snapshot = fs.existsSync(paths.activeAreaConfig)
? activeAreaConfig(paths)
: writeActiveAreaConfig(paths, options);
const edits = activeDocument(paths, osm.digest, snapshot.digest);
if (fs.existsSync(path.join(paths.revisionsDirectory, 'rev-0001', 'manifest.json'))) {
backfillAreaConfigSnapshots(paths, snapshot);
const baseline = readRevision(workspace, 'rev-0001');
const active = fs.existsSync(paths.activeState)
? readJson(paths.activeState)
: {
schema: ACTIVE_STATE_SCHEMA,
activeRevisionId: baseline.manifest.id,
documentVersion: edits.documentVersion,
};
if (!fs.existsSync(paths.activeState)) writeJsonAtomic(paths.activeState, active);
return { paths, active, baseline };
}
const baseline = createRevision(paths, {
id: 'rev-0001',
directEdits: edits,
areaConfig: snapshot,
label: 'Import baseline',
});
writeJsonAtomic(paths.activeState, {
schema: ACTIVE_STATE_SCHEMA,
activeRevisionId: baseline.manifest.id,
documentVersion: edits.documentVersion,
});
return { paths, active: readJson(paths.activeState), baseline };
}
function backfillAreaConfigSnapshots(paths, areaConfig) {
if (!fs.existsSync(paths.revisionsDirectory)) return;
for (const entry of fs.readdirSync(paths.revisionsDirectory, { withFileTypes: true })) {
if (!entry.isDirectory() || !/^rev-\d{4}$/.test(entry.name)) continue;
const directory = path.join(paths.revisionsDirectory, entry.name);
const manifestFile = path.join(directory, 'manifest.json');
if (!fs.existsSync(manifestFile)) continue;
const manifest = readJson(manifestFile);
if (manifest.source?.areaConfigFile && manifest.source?.areaConfigSha256) continue;
const directEditsFile = path.join(directory, 'native-road-edits.json');
const directEdits = validateEditDocument(readJson(directEditsFile));
directEdits.base.areaConfigSha256 = areaConfig.digest;
writeJsonAtomic(directEditsFile, directEdits);
writeFileAtomic(path.join(directory, 'area-config.snapshot.json'), areaConfig.bytes);
manifest.source = {
...manifest.source,
areaConfigFile: 'area-config.snapshot.json',
areaConfigSha256: areaConfig.digest,
};
manifest.digests = {
...manifest.digests,
directEdits: sha256(`${JSON.stringify(directEdits, null, 2)}\n`),
areaConfigSnapshot: areaConfig.digest,
};
writeJsonAtomic(manifestFile, manifest);
}
}
function createCheckpoint(workspace, label) {
if (typeof label !== 'string' || !label.trim())
throw new Error('Revision checkpoint label must be a non-empty string.');
const initialized = ensureRevisionStore(workspace);
const directEdits = validateEditDocument(readJson(initialized.paths.activeEdits));
const areaConfig = activeAreaConfig(initialized.paths);
const revision = createRevision(initialized.paths, {
id: revisionId(initialized.paths.revisionsDirectory),
directEdits,
areaConfig,
label: label.trim(),
parentRevisionId: initialized.active.activeRevisionId,
});
writeJsonAtomic(initialized.paths.activeState, {
...initialized.active,
activeRevisionId: revision.manifest.id,
documentVersion: directEdits.documentVersion,
});
return revision;
}
function createRevision(paths, { id, directEdits, areaConfig, label, parentRevisionId = undefined }) {
assertRevisionId(id);
const osm = storeOsm(paths);
const overrides = readFile(paths.overrides);
const trafficSignals = readFile(paths.trafficSignals);
const revisions = paths.revisionsDirectory;
fs.mkdirSync(revisions, { recursive: true });
const destination = path.join(revisions, id);
if (fs.existsSync(destination)) throw new Error(`Revision already exists: ${id}`);
const staging = fs.mkdtempSync(path.join(revisions, '.staging-'));
try {
const files = {
nativeRoadOverrides: 'native-road-overrides.json',
directEdits: 'native-road-edits.json',
trafficSignals: 'native-traffic-signals.json',
};
writeFileAtomic(path.join(staging, files.nativeRoadOverrides), overrides);
writeJsonAtomic(path.join(staging, files.directEdits), directEdits);
writeFileAtomic(path.join(staging, files.trafficSignals), trafficSignals);
writeFileAtomic(path.join(staging, 'area-config.snapshot.json'), areaConfig.bytes);
const manifest = {
schema: REVISION_SCHEMA,
id,
createdAt: new Date().toISOString(),
...(label ? { label } : {}),
...(parentRevisionId ? { parentRevisionId } : {}),
source: {
osmFile: path.relative(paths.workspace, osm.file),
osmSha256: osm.digest,
areaConfigFile: 'area-config.snapshot.json',
areaConfigSha256: areaConfig.digest,
},
documents: files,
digests: {
nativeRoadOverrides: sha256(overrides),
directEdits: sha256(`${JSON.stringify(directEdits, null, 2)}\n`),
trafficSignals: sha256(trafficSignals),
areaConfigSnapshot: areaConfig.digest,
},
compiler: { packageVersion: PACKAGE_VERSION, geometrySchema: GEOMETRY_SCHEMA },
};
writeJsonAtomic(path.join(staging, 'manifest.json'), manifest);
fs.renameSync(staging, destination);
return readRevision(paths.workspace, id);
} catch (error) {
fs.rmSync(staging, { recursive: true, force: true });
throw error;
}
}
function readRevision(workspace, id) {
assertRevisionId(id);
const paths = pathsFor(workspace);
const directory = path.join(paths.revisionsDirectory, id);
const manifest = readJson(path.join(directory, 'manifest.json'));
if (manifest.schema !== REVISION_SCHEMA || manifest.id !== id) throw new Error(`Invalid revision manifest: ${id}`);
const osmFile = path.resolve(paths.workspace, manifest.source.osmFile);
if (!isWithin(paths.osmDirectory, osmFile)) throw new Error(`Revision ${id} OSM path escapes the workspace store.`);
const osm = readFile(osmFile);
if (sha256(osm) !== manifest.source.osmSha256)
throw new Error(`Revision ${id} OSM digest does not match its manifest.`);
const areaConfigFile = path.resolve(directory, manifest.source.areaConfigFile);
if (!isWithin(directory, areaConfigFile)) throw new Error(`Revision ${id} area config path escapes the revision.`);
const areaConfigBytes = readFile(areaConfigFile);
if (sha256(areaConfigBytes) !== manifest.source.areaConfigSha256)
throw new Error(`Revision ${id} area config digest does not match its manifest.`);
const documents = Object.fromEntries(
Object.entries(manifest.documents).map(([name, file]) => {
const document = path.resolve(directory, file);
if (!isWithin(directory, document)) throw new Error(`Revision ${id} ${name} path escapes the revision.`);
const bytes = readFile(document);
if (sha256(bytes) !== manifest.digests[name])
throw new Error(`Revision ${id} ${name} digest does not match its manifest.`);
return [name, JSON.parse(bytes.toString('utf8'))];
}),
);
return { manifest, osm: osm.toString('utf8'), areaConfig: readAreaConfigSnapshot(areaConfigFile), ...documents };
}
function assertRevisionId(id) {
if (typeof id !== 'string' || !/^rev-\d{4}$/.test(id)) throw new Error(`Invalid revision id: ${id}`);
}
function isWithin(directory, file) {
const resolvedDirectory = `${path.resolve(directory)}${path.sep}`;
return file.startsWith(resolvedDirectory);
}
function readJson(file) {
return JSON.parse(fs.readFileSync(file, 'utf8'));
}
module.exports = {
REVISION_SCHEMA,
ACTIVE_STATE_SCHEMA,
AREA_CONFIG_SNAPSHOT_SCHEMA,
sha256,
ensureRevisionStore,
setActiveAreaConfig,
readAreaConfigSnapshot,
createCheckpoint,
readRevision,
};