227 lines
20 KiB
TypeScript
227 lines
20 KiB
TypeScript
import assert from "node:assert/strict"
|
|
import { configurationRows, isOrderedRosResource, resourceById, rosSnapshotVersion, splitOspfUnsetUpdate, type ConfigurationRow, type RosSnapshot, type RosStep } from "./resources.js"
|
|
import { fingerprint } from "./security.js"
|
|
import { proveRosDriftExpectation, verifyRosStepSnapshots } from "./ros-step-verification.js"
|
|
import { readOspfTemplateFlags } from "../../services/ospf-template-flags.js"
|
|
|
|
function snapshot(resource: string, rows: ConfigurationRow[]): RosSnapshot {
|
|
return { serverId: 1, resource, rows, fingerprint: fingerprint(rows) }
|
|
}
|
|
function check(step: RosStep, result: unknown, before: ConfigurationRow[], after: ConfigurationRow[]): boolean {
|
|
return verifyRosStepSnapshots(step, result, snapshot(step.resource, before), snapshot(step.resource, after))
|
|
}
|
|
const create: RosStep = { serverId: 1, resource: "ip_filter", action: "create", fields: { chain: "forward", action: "accept" } }
|
|
const a = { ".id": "*A", chain: "forward", action: "drop", comment: "keep", disabled: "false" }
|
|
const b = { ...a, ".id": "*B", chain: "input" }
|
|
const c = { ".id": "*C", chain: "forward", action: "accept", disabled: "no" }
|
|
const ack = { ".id": "*C" }
|
|
assert.equal(check(create, ack, [a, b], [a, b, c]), true)
|
|
assert.equal(check(create, { ".id": "*A" }, [a, b], [a, b, c]), false, "Existing assigned ID cannot acknowledge a new object")
|
|
assert.equal(check(create, ack, [a, b], [a, b, c, { ...c, ".id": "*D" }]), false, "Two added rows are not one CREATE")
|
|
assert.equal(check(create, ack, [a, b], [a, c]), false, "Replacement/removal cannot hide behind matching cardinality")
|
|
assert.equal(check(create, ack, [a, b], [{ ...a, comment: "collateral" }, b, c]), false)
|
|
assert.equal(check(create, ack, [a, b], [a, b, { ...c, action: "drop" }]), false)
|
|
assert.equal(check(create, undefined, [a], [a, c]), false, "Observed object never substitutes a lost acknowledgement")
|
|
assert.equal(check({ ...create, id: "*A" }, ack, [a], [a, c]), false)
|
|
|
|
const update: RosStep = { ...create, action: "update", id: "*A", fields: { action: "accept" } }
|
|
const updated = { ...a, action: "accept" }
|
|
assert.equal(check(update, {}, [a, b], [updated, b]), true)
|
|
assert.equal(check(update, {}, [a, b], [{ ...updated, comment: "collateral" }, b]), false)
|
|
assert.equal(check(update, {}, [a, b], [updated, { ...b, action: "accept" }]), false)
|
|
assert.equal(check(update, {}, [a, b], [updated]), false)
|
|
assert.equal(check(update, {}, [a, b], [updated, b, c]), false)
|
|
assert.equal(check(update, {}, [a, b], [{ ...updated, ".id": "*X" }, b]), false)
|
|
assert.equal(check(update, {}, [a, b], [{ ...updated, comment: undefined }, b]), false, "Absent/unknown unsupplied properties cannot replace a known value")
|
|
assert.equal(check({ ...update, fields: { invented: "field" } }, {}, [a], [{ ...a, invented: "field" }]), false)
|
|
const remove: RosStep = { ...update, action: "delete", fields: {} }
|
|
assert.equal(check(remove, undefined, [a, b], [b]), true)
|
|
assert.equal(check(remove, undefined, [a, b], []), false)
|
|
assert.equal(check(remove, undefined, [a, b], [{ ...b, comment: "collateral" }]), false)
|
|
assert.equal(check(remove, undefined, [b], [b]), false, "Deleting an already absent ID does not prove the step")
|
|
|
|
for (const rows of [[a, a], [{ ...a, ".id": undefined }], [{ ...a, ".id": "" }], [{ ...a, ".id": 4 }], [{ ...a, ".id": " *A" }]]) {
|
|
assert.equal(check(create, ack, rows, [...rows, c]), false)
|
|
assert.equal(check(create, ack, [], rows), false)
|
|
}
|
|
assert.equal(check(create, ack, [a], [a, c, c]), false, "Duplicate IDs after a mutation are unknown")
|
|
|
|
const ordered = ["ip_filter", "ip_nat", "ip_mangle", "ip_raw", "ipv6_filter", "ipv6_nat", "ipv6_mangle", "ipv6_raw", "routing_rule", "vrf", "bfd_configuration", "ospf_template"]
|
|
for (const resource of ordered) {
|
|
assert.equal(isOrderedRosResource(resource), true)
|
|
const rows = [{ ".id": "*Z", comment: "first" }, { ".id": "*A", comment: "second" }]
|
|
assert.deepEqual(configurationRows(resourceById(resource), rows).map(row => row[".id"]), ["*Z", "*A"], `${resource} preserves the native order`)
|
|
const step = { ...update, resource, id: "*Z", fields: { comment: "changed" } }
|
|
assert.equal(check(step, {}, rows, [{ ...rows[0], comment: "changed" }, rows[1]]), true)
|
|
assert.equal(check(step, {}, rows, [rows[1], { ...rows[0], comment: "changed" }]), false, `${resource} rejects reordering`)
|
|
}
|
|
assert.equal(check(create, ack, [a, b], [a, c, b]), false, "Ordered CREATE must append without place-before")
|
|
assert.equal(check(remove, {}, [a, b, c], [c, b]), false, "DELETE must retain survivor order")
|
|
const vrf: RosStep = { ...create, resource: "vrf", fields: { name: "new", interfaces: "ether3" }, placeBeforeId: "*B" }
|
|
const va = { ".id": "*A", name: "first", interfaces: "ether1" }, vb = { ".id": "*B", name: "main", interfaces: "all" }, vc = { ".id": "*C", name: "new", interfaces: "ether3" }
|
|
assert.equal(check(vrf, ack, [va, vb], [va, vc, vb]), true)
|
|
assert.equal(check(vrf, ack, [va, vb], [vc, va, vb]), false, "place-before is exact insertion, not any earlier position")
|
|
assert.equal(check(vrf, ack, [va, vb], [va, vb, vc]), false)
|
|
assert.equal(check({ ...vrf, placeBeforeId: "*MISSING" }, ack, [va, vb], [va, vc, vb]), false)
|
|
assert.equal(check({ ...create, placeBeforeId: "*B" }, ack, [a, b], [a, c, b]), false, "Firewall creation does not accept place-before")
|
|
const bfd: RosStep = { ...create, resource: "bfd_configuration", fields: { interfaces: "ether1", addresses: "192.0.2.5/32", vrf: "main" }, placeBeforeId: "*B" }
|
|
const insertedBfd = { ".id": "*C", ...bfd.fields }
|
|
assert.equal(check(bfd, ack, [a, b], [a, insertedBfd, b]), true)
|
|
assert.equal(check(bfd, ack, [a, b], [a, b, insertedBfd]), false)
|
|
assert.equal(check(bfd, ack, [a, b], [a, insertedBfd, { ...b, comment: "changed" }]), false)
|
|
assert.equal(check({ ...bfd, placeBeforeId: "*D" }, ack, [a, b], [a, insertedBfd, b]), false)
|
|
const bfdRows = (rows: ConfigurationRow[]) => configurationRows(resourceById("bfd_configuration"), rows)
|
|
const interfaceBfd: RosStep = { ...bfd, fields: { interfaces: "ether1", vrf: "main" } }
|
|
assert.equal(check(interfaceBfd, ack, [a, b], [a, { ".id": "*C", ...interfaceBfd.fields }, b]), true)
|
|
assert.equal(check(interfaceBfd, ack, [a, b], bfdRows([a, { ".id": "*C", ...interfaceBfd.fields, "address-list": "unexpected" }, b])), false)
|
|
const bfdIntervalUpdate: RosStep = { ...bfd, action: "update", id: "*A", placeBeforeId: undefined, fields: { "min-rx": "200ms", "min-tx": "1s" } }
|
|
const originalBfd = { ...a, "min-rx": "500ms", "min-tx": "2s" }
|
|
const formattedBfd = { ...a, "min-rx": "00:00:00.200", "min-tx": "1000ms" }
|
|
assert.equal(check(bfdIntervalUpdate, {}, bfdRows([originalBfd]), bfdRows([formattedBfd])), true)
|
|
assert.equal(check(bfdIntervalUpdate, {}, bfdRows([originalBfd]), bfdRows([{ ...formattedBfd, "min-rx": "200001us" }])), false)
|
|
assert.equal(check(bfd, ack, bfdRows([a, { ...b, "address-list": "previous" }]), bfdRows([a, insertedBfd, { ...b, "address-list": "changed" }])), false)
|
|
const unordered = { ...update, resource: "bridge", fields: { name: "renamed" } }
|
|
const ua = { ".id": "*A", name: "one" }, ub = { ".id": "*B", name: "two" }
|
|
assert.equal(isOrderedRosResource("bridge"), false)
|
|
assert.equal(check(unordered, {}, [ua, ub], [ub, { ...ua, name: "renamed" }]), true)
|
|
assert.deepEqual(configurationRows(resourceById("bridge"), [ub, ua]).map(row => row[".id"]), ["*A", "*B"])
|
|
|
|
const booleanStep = { ...update, fields: { disabled: "false" } }
|
|
for (const value of [false, "false", "no"]) assert.equal(check(booleanStep, {}, [a, b], [{ ...a, disabled: value }, { ...b, disabled: false }]), true)
|
|
for (const value of [undefined, "", 0, null, "unknown", true]) assert.equal(check(booleanStep, {}, [a], [{ ...a, disabled: value }]), false)
|
|
assert.equal(check(update, {}, [{ ...a, comment: "yes" }], [{ ...updated, comment: true }]), false, "Boolean normalization applies only to schema boolean fields")
|
|
assert.equal(check(update, {}, [{ ...a, dynamic: "yes" }], [{ ...updated, dynamic: true }]), false, "Native metadata has no boolean schema to authorize equivalence")
|
|
|
|
const settings: RosStep = { serverId: 1, resource: "ip_settings", action: "update", fields: { "rp-filter": "strict" } }
|
|
const s0 = { "rp-filter": "loose", "ipv4-multipath-hash-policy": "l3" }, s1 = { ...s0, "rp-filter": "strict" }
|
|
assert.equal(check(settings, {}, [s0], [s1]), true)
|
|
assert.equal(check(settings, {}, [], [s1]), false)
|
|
assert.equal(check(settings, {}, [s0, s0], [s1]), false)
|
|
assert.equal(check(settings, {}, [s0], [s1, s1]), false)
|
|
assert.equal(check({ ...settings, id: "singleton" }, {}, [s0], [s1]), false)
|
|
assert.equal(check(settings, {}, [s0], [{ ...s1, "ipv4-multipath-hash-policy": "l4" }]), false)
|
|
assert.equal(check(settings, {}, [s0], [{ ...s1, ".id": "fabricated" }]), false)
|
|
assert.equal(check({ ...settings, resource: "ipv6_settings", fields: { "multipath-hash-policy": "l4" } }, {}, [{ "multipath-hash-policy": "l3" }], [{ "multipath-hash-policy": "l4" }]), true)
|
|
|
|
const ospf: RosStep = { serverId: 1, resource: "ospf_template", action: "update", id: "*A", fields: { passive: "false" } }
|
|
const redistribution: RosStep = { serverId: 1, resource: "ospf_instance", action: "update", id: "*I", fields: { redistribute: "connected,static", "originate-default": "if-installed" } }
|
|
const instanceRows = (row: ConfigurationRow) => configurationRows(resourceById("ospf_instance"), [row])
|
|
const oldInstance = { ".id": "*I", redistribute: "", "originate-default": "never", "out-filter-chain": "ospf-out" }
|
|
const newInstance = { ...oldInstance, redistribute: "static,connected", "originate-default": "if-installed" }
|
|
assert.equal(check(redistribution, {}, instanceRows(oldInstance), instanceRows(newInstance)), true)
|
|
assert.equal(check(redistribution, {}, instanceRows(oldInstance), instanceRows({ ...newInstance, redistribute: "static" })), false)
|
|
assert.equal(check(redistribution, {}, instanceRows(oldInstance), instanceRows({ ...newInstance, "out-filter-chain": "other" })), false)
|
|
const networkTemplate: RosStep = { serverId: 1, resource: "ospf_template", action: "create", fields: { area: "backbone", networks: "fd00::/64" } }
|
|
const networkRows = (row: ConfigurationRow) => configurationRows(resourceById("ospf_template"), [row])
|
|
const networkRow = { ".id": "*N", area: "backbone", networks: "FD00:0:0:0::/64" }
|
|
assert.equal(check(networkTemplate, { ".id": "*N" }, [], networkRows(networkRow)), true)
|
|
assert.equal(check(networkTemplate, { ".id": "*N" }, [], networkRows({ ...networkRow, "instance-id": "0" })), true)
|
|
assert.equal(check(networkTemplate, { ".id": "*N" }, [], networkRows({ ...networkRow, "instance-id": "7" })), false)
|
|
const instanceIdUpdate: RosStep = { ...ospf, id: "*N", fields: { "instance-id": "7" } }
|
|
const withDefaultId = networkRows({ ...networkRow, "instance-id": "0" })
|
|
assert.equal(check(instanceIdUpdate, {}, withDefaultId, networkRows({ ...networkRow, "instance-id": "7" })), true)
|
|
assert.equal(check(instanceIdUpdate, {}, withDefaultId, networkRows(networkRow)), false)
|
|
assert.equal(check(networkTemplate, { ".id": "*N" }, [], networkRows({ ...networkRow, networks: "fd00::/48" })), false)
|
|
assert.equal(check(networkTemplate, { ".id": "*N" }, [], networkRows({ ...networkRow, interfaces: "ether1" })), false)
|
|
assert.equal(check(networkTemplate, { ".id": "*N" }, [], networkRows({ ...networkRow, "prefix-list": "unexpected" })), false)
|
|
const prefixTemplate = { ...networkTemplate, fields: { ...networkTemplate.fields, "prefix-list": "advertise" } }
|
|
assert.equal(check(prefixTemplate, { ".id": "*N" }, [], networkRows({ ...networkRow, "prefix-list": "advertise" })), true)
|
|
const detachPrefix: RosStep = { ...ospf, id: "*N", fields: { "prefix-list": "" } }
|
|
const attached = networkRows({ ...networkRow, "prefix-list": "advertise" })
|
|
assert.equal(check(detachPrefix, [], attached, networkRows(networkRow)), true)
|
|
assert.equal(check(detachPrefix, [], attached, networkRows({ ...networkRow, "prefix-list": "" })), true)
|
|
assert.equal(check(detachPrefix, [], attached, networkRows({ ...networkRow, "prefix-list": null })), false)
|
|
assert.equal(check(detachPrefix, [], attached, attached), false)
|
|
assert.equal(check(detachPrefix, [], attached, networkRows({ ...networkRow, area: "foreign" })), false)
|
|
assert.deepEqual(splitOspfUnsetUpdate({ ...detachPrefix, fields: { area: "other", "prefix-list": "", passive: "false" } }).map(step => step.fields),
|
|
[{ "prefix-list": "" }, { area: "other" }, { passive: "false" }])
|
|
assert.equal(check(networkTemplate, {}, [], networkRows(networkRow)), false)
|
|
const nbmaTemplate: RosStep = { ...networkTemplate, fields: { ...networkTemplate.fields, type: "nbma", priority: "0" } }
|
|
assert.equal(check(nbmaTemplate, { ".id": "*N" }, [], networkRows({ ...networkRow, type: "nbma", priority: "0" })), true)
|
|
assert.equal(check(nbmaTemplate, { ".id": "*N" }, [], networkRows({ ...networkRow, type: "nbma", priority: "128" })), false)
|
|
const priorityUpdate: RosStep = { ...ospf, id: "*N", fields: { type: "ptmp-broadcast", priority: "255" } }
|
|
const prior = networkRows({ ...networkRow, type: "nbma", priority: "0" })
|
|
assert.equal(check(priorityUpdate, {}, prior, networkRows({ ...networkRow, type: "ptmp-broadcast", priority: "255" })), true)
|
|
assert.equal(check(priorityUpdate, {}, prior, networkRows({ ...networkRow, type: "nbma", priority: "255" })), false)
|
|
const timers = { "hello-interval": "10s", "dead-interval": "60s" }
|
|
const timedTemplate = { ...networkTemplate, fields: { ...networkTemplate.fields, ...timers } }
|
|
const clockTimers = networkRows({ ...networkRow, "hello-interval": "00:00:10", "dead-interval": "1m" })
|
|
assert.deepEqual(clockTimers, networkRows({ ...networkRow, ...timers }))
|
|
assert.equal(check(timedTemplate, { ".id": "*N" }, [], clockTimers), true)
|
|
assert.equal(check(timedTemplate, { ".id": "*N" }, [], networkRows({ ...networkRow, "hello-interval": "10001ms", "dead-interval": "1m" })), false)
|
|
assert.equal(check(timedTemplate, { ".id": "*N" }, [], networkRows({ ...networkRow, ...timers, "dead-interval": "60" })), false)
|
|
const linkStateTimers: RosStep = { ...ospf, id: "*N", fields: { "retransmit-interval": "5s", "transmit-delay": "1s" } }
|
|
const linkStateBefore = networkRows({ ...networkRow, "retransmit-interval": "6s", "transmit-delay": "2s" })
|
|
assert.equal(check(linkStateTimers, {}, linkStateBefore, networkRows({ ...networkRow, "retransmit-interval": "00:00:05", "transmit-delay": "1000ms" })), true)
|
|
assert.equal(check(linkStateTimers, {}, linkStateBefore, networkRows({ ...networkRow, "retransmit-interval": "5s", "transmit-delay": "1001ms" })), false)
|
|
const os = { ".id": "*A", passive: "true", disabled: "false", cost: "10" }
|
|
assert.equal(check(ospf, {}, [os], [{ ...os, passive: "false" }]), true)
|
|
const { passive: _passive, ...unset } = os
|
|
assert.equal(check(ospf, {}, [os], [unset]), false, "An omitted switch alone never proves false")
|
|
const effective = await readOspfTemplateFlags([unset], async () => ({ ret: "" }), undefined, async () => ({ present: [], absent: [{ ".id": "*A" }] }))
|
|
assert.equal(check(ospf, {}, [os], effective), true, "Existing complete complementary switch-query receipt proves unset passive=false")
|
|
|
|
const frozenBefore = Object.freeze([Object.freeze(a), Object.freeze(b)]) as unknown as ConfigurationRow[]
|
|
const frozenAfter = Object.freeze([Object.freeze(updated), Object.freeze(b)]) as unknown as ConfigurationRow[]
|
|
const frozenStep = Object.freeze({ ...update, fields: Object.freeze(update.fields) })
|
|
assert.equal(check(frozenStep, Object.freeze({}), frozenBefore, frozenAfter), true)
|
|
const raw = Object.freeze([Object.freeze({ ...a, opaque: "outside-projection" })])
|
|
const projected = configurationRows(resourceById("ip_filter"), raw)
|
|
assert.equal(Object.hasOwn(projected[0], "opaque"), false)
|
|
assert.equal(raw[0].opaque, "outside-projection")
|
|
assert.equal(verifyRosStepSnapshots(update, {}, { ...snapshot("ip_filter", [a]), serverId: 2 }, snapshot("ip_filter", [updated])), false)
|
|
assert.equal(verifyRosStepSnapshots(update, {}, snapshot("bridge", [a]), snapshot("ip_filter", [updated])), false)
|
|
console.log("ROS projected whole-catalog verifier: acknowledged assigned ID, exact membership/field conservation, 12 ordered catalogs including OSPF templates, singleton settings, schema booleans, effective OSPF unset, immutable inputs")
|
|
|
|
const sourceProof = "a".repeat(64)
|
|
function driftSnapshot(resource: string, rows: ConfigurationRow[]): RosSnapshot {
|
|
return { ...snapshot(resource, rows), projectionVersion: rosSnapshotVersion(resource), sourceProof }
|
|
}
|
|
function expectDrift(step: RosStep, receipt: unknown, before: ConfigurationRow[], after: ConfigurationRow[]) {
|
|
const expectation = proveRosDriftExpectation(step, receipt, driftSnapshot(step.resource, before), driftSnapshot(step.resource, after))
|
|
assert.ok(expectation)
|
|
assert.equal(expectation.sourceProof, sourceProof)
|
|
return expectation
|
|
}
|
|
|
|
const settingsDrift = expectDrift(settings, {}, [s0], [s1])
|
|
assert.equal(settingsDrift.nativeId, undefined)
|
|
assert.equal(settingsDrift.matches(driftSnapshot("ip_settings", [{ ...s1, "ipv4-multipath-hash-policy": "l4" }])), true)
|
|
assert.equal(settingsDrift.matches(driftSnapshot("ip_settings", [s0])), false)
|
|
for (const rows of [[], [s1, s1], [{}], [{ "rp-filter": "unknown" }], [{ "rp-filter": null }], [{ "rp-filter": ["loose"] }]]) {
|
|
assert.equal(settingsDrift.matches(driftSnapshot("ip_settings", rows)), undefined)
|
|
}
|
|
const verifiedSettings = driftSnapshot("ip_settings", [s1])
|
|
assert.equal(settingsDrift.matches({ ...verifiedSettings, sourceProof: "b".repeat(64) }), undefined)
|
|
assert.equal(settingsDrift.matches({ ...verifiedSettings, serverId: 2 }), undefined)
|
|
assert.equal(settingsDrift.matches({ ...verifiedSettings, fingerprint: "b".repeat(64) }), undefined)
|
|
assert.equal(proveRosDriftExpectation(settings, {}, snapshot("ip_settings", [s0]), verifiedSettings), undefined, "Legacy evidence without a source/version cannot prove drift")
|
|
assert.equal(proveRosDriftExpectation(settings, {}, driftSnapshot("ip_settings", [s0]), { kind: "vrf-production-private-checkpoint-v1" }), undefined)
|
|
assert.equal(proveRosDriftExpectation(settings, {}, driftSnapshot("ip_settings", [s0]), { ...verifiedSettings, sourceProof: "b".repeat(64) }), undefined)
|
|
assert.equal(proveRosDriftExpectation(settings, undefined, driftSnapshot("ip_settings", [s0]), verifiedSettings), undefined)
|
|
|
|
const createDrift = expectDrift(create, ack, [a, b], [a, b, c])
|
|
assert.equal(createDrift.nativeId, "*C")
|
|
assert.equal(createDrift.matches(driftSnapshot("ip_filter", [{ ...b, comment: "unrelated" }, c])), true)
|
|
assert.equal(createDrift.matches(driftSnapshot("ip_filter", [a, b])), false)
|
|
assert.equal(createDrift.matches(driftSnapshot("ip_filter", [a, b, c, c])), undefined)
|
|
assert.equal(proveRosDriftExpectation(create, {}, driftSnapshot("ip_filter", [a, b]), driftSnapshot("ip_filter", [a, b, c])), undefined)
|
|
|
|
const updateDrift = expectDrift(update, {}, [a, b], [updated, b])
|
|
assert.equal(updateDrift.nativeId, "*A")
|
|
assert.equal(updateDrift.matches(driftSnapshot("ip_filter", [{ ...updated, comment: "unrelated" }, c])), true)
|
|
assert.equal(updateDrift.matches(driftSnapshot("ip_filter", [a, c])), false)
|
|
assert.equal(updateDrift.matches(driftSnapshot("ip_filter", [b, c])), false)
|
|
|
|
const booleanDrift = expectDrift(booleanStep, {}, [a], [a])
|
|
assert.equal(booleanDrift.matches(driftSnapshot("ip_filter", [{ ...a, disabled: "no" }])), true)
|
|
assert.equal(booleanDrift.matches(driftSnapshot("ip_filter", [{ ...a, disabled: "yes" }])), false)
|
|
assert.equal(booleanDrift.matches(driftSnapshot("ip_filter", [{ ...a, disabled: "" }])), undefined)
|
|
|
|
const deleteDrift = expectDrift(remove, null, [a, b], [b])
|
|
assert.equal(deleteDrift.nativeId, "*A")
|
|
assert.equal(deleteDrift.matches(driftSnapshot("ip_filter", [{ ...b, comment: "unrelated" }, c])), true)
|
|
assert.equal(deleteDrift.matches(driftSnapshot("ip_filter", [{ ...a, disabled: "no" }, c])), false)
|
|
assert.equal(deleteDrift.matches(driftSnapshot("ip_filter", [{ ...a, chain: "output", comment: "a different rule reused this ID" }, b])), undefined)
|
|
console.log("ROS drift proof: bound source and verified transition, scoped typed fields, unknown observations and delete ID reuse")
|