mirror of https://codeberg.org/pzp/pzp-goals.git
350 lines
9.0 KiB
JavaScript
350 lines
9.0 KiB
JavaScript
// @ts-ignore
|
|
const Obz = require('obz')
|
|
// @ts-ignore
|
|
const p = (fn) => (...args) => {
|
|
return new Promise((res, rej) => {
|
|
// @ts-ignore
|
|
fn(...args, (err, val) => {
|
|
if (err) return rej(err)
|
|
return res(val)
|
|
})
|
|
})
|
|
}
|
|
|
|
/**
|
|
* @typedef {ReturnType<import('pzp-db').init>} PZPDB
|
|
* @typedef {ReturnType<import('pzp-dict').init>} PZPDict
|
|
* @typedef {ReturnType<import('pzp-set').init>} PZPSet
|
|
* @typedef {import('pzp-db').RecPresent} RecPresent
|
|
* @typedef {import('pzp-db').Tangle} Tangle
|
|
* @typedef {import('pzp-db').Msg} Msg
|
|
* @typedef {NonNullable<ReturnType<PZPDB['getTangle']>>} DBTangle
|
|
* @typedef {string} MsgID
|
|
* @typedef {'none'|'all'|`newest-${number}`|'dict'|'set'} GoalDSL
|
|
* @typedef {'none'|'all'|'newest'|'dict'|'set'} GoalType
|
|
* @typedef {[number, number]} Range
|
|
* @typedef {{ id: string, type: GoalType, count: number }} Goal
|
|
* @typedef {{ tangleID: MsgID, span: number }} GhostDetails
|
|
*/
|
|
|
|
/**
|
|
* @template T
|
|
* @typedef {[T] extends [void] ?
|
|
* (...args: [Error] | []) => void :
|
|
* (...args: [Error] | [null, T]) => void
|
|
* } CB
|
|
*/
|
|
|
|
/**
|
|
* @template T
|
|
* @typedef {(args?: CB<Array<T>>) => any} Multicb
|
|
*/
|
|
|
|
/**
|
|
* A *purpose* is a tag that explains why a msg exists in the database.
|
|
* - "none" means the msg has no purpose, and should not exist in the database.
|
|
* - "ghost" means the msg has no purpose, should not exist in the database, but
|
|
* we should still register it as a ghost so that we don't accidentally
|
|
* re-request it during replication.
|
|
* - "trail" means the msg does not meet any goal, but it is required to be in
|
|
* the database because it is along the path of goalful msgs to the root of the
|
|
* tangle. See "Lipmaa certificate pool" concept from Bamboo.
|
|
* - "goal" means the msg perfectly meets the requirements of some goal.
|
|
*
|
|
* These tags are ordered, "none" < "ghost" < "trail" < "goal", meaning that a
|
|
* msg with purpose "goal" may *also* fulfill the purpose of "trail", and a
|
|
* "trail" also prevents accidental re-request like "ghost" does.
|
|
* @typedef {['none']
|
|
* | ['ghost', GhostDetails]
|
|
* | ['trail']
|
|
* | ['goal']
|
|
* } PurposeWithDetails
|
|
*/
|
|
|
|
/**
|
|
* @implements {Goal}
|
|
*/
|
|
class GoalImpl {
|
|
/** @type {string} */
|
|
#id
|
|
|
|
/** @type {GoalType} */
|
|
#type
|
|
|
|
/** @type {number} */
|
|
#count
|
|
|
|
/**
|
|
* @param {string} tangleID
|
|
* @param {GoalDSL} goalDSL
|
|
* @returns
|
|
*/
|
|
constructor(tangleID, goalDSL) {
|
|
this.#id = tangleID
|
|
|
|
if (goalDSL === 'none') {
|
|
this.#type = 'none'
|
|
this.#count = 0
|
|
return
|
|
}
|
|
|
|
if (goalDSL === 'all') {
|
|
this.#type = 'all'
|
|
this.#count = Infinity
|
|
return
|
|
}
|
|
|
|
if (goalDSL === 'set') {
|
|
this.#type = 'set'
|
|
this.#count = Infinity
|
|
return
|
|
}
|
|
|
|
if (goalDSL === 'dict') {
|
|
this.#type = 'dict'
|
|
this.#count = Infinity
|
|
return
|
|
}
|
|
|
|
const matchN = goalDSL.match(/^newest-(\d+)$/)
|
|
if (matchN) {
|
|
this.#type = 'newest'
|
|
this.#count = Number(matchN[1])
|
|
return
|
|
}
|
|
|
|
throw new Error(`Unrecognized goal DSL: ${goalDSL}`)
|
|
}
|
|
|
|
get id() {
|
|
return this.#id
|
|
}
|
|
|
|
get type() {
|
|
return this.#type
|
|
}
|
|
|
|
get count() {
|
|
return this.#count
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {{ db: PZPDB, dict: PZPDict, set: PZPSet }} peer
|
|
* @param {unknown} config
|
|
*/
|
|
function initGoals(peer, config) {
|
|
// Constants:
|
|
const EMPTY_RANGE = /** @type {Range} */ ([1, 0])
|
|
|
|
// State:
|
|
const goals = /** @type {Map<string, Goal>} */ (new Map())
|
|
const watch = Obz()
|
|
|
|
/**
|
|
* @param {Range} range
|
|
* @returns {boolean}
|
|
*/
|
|
function isEmptyRange(range) {
|
|
const [min, max] = range
|
|
return min > max
|
|
}
|
|
|
|
/**
|
|
* Determine the range of msg depths that are goalful for this given tangle.
|
|
* @private
|
|
* @param {Goal} goal
|
|
* @param {Tangle} tangle
|
|
* @param {CB<Range>} cb
|
|
*/
|
|
function crossGoalWithTangle(goal, tangle, cb) {
|
|
const maxDepth = tangle.maxDepth
|
|
switch (goal.type) {
|
|
case 'newest':
|
|
const start = Math.max(0, maxDepth - goal.count + 1)
|
|
return cb(null, [start, maxDepth])
|
|
|
|
case 'all':
|
|
return cb(null, [0, maxDepth])
|
|
|
|
case 'set':
|
|
return peer.set.minRequiredDepth(goal.id, (err, minSetDepth) => {
|
|
if (err) return cb(err)
|
|
return cb(null, [minSetDepth, maxDepth])
|
|
})
|
|
|
|
case 'dict':
|
|
return peer.dict.minRequiredDepth(goal.id, (err, minDictDepth) => {
|
|
if (err) return cb(err)
|
|
return cb(null, [minDictDepth, maxDepth])
|
|
})
|
|
|
|
case 'none':
|
|
return cb(null, EMPTY_RANGE)
|
|
|
|
default:
|
|
return cb(Error(`Unrecognized goal type: ${goal.type}`))
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @public
|
|
* @param {GoalDSL} goalDSL
|
|
* @returns {Goal}
|
|
*/
|
|
function parse(goalDSL) {
|
|
return new GoalImpl('?', goalDSL)
|
|
}
|
|
|
|
/**
|
|
* @param {Pick<Goal, 'type' | 'count'>} goal
|
|
* @returns {GoalDSL}
|
|
*/
|
|
function serialize(goal) {
|
|
switch (goal.type) {
|
|
case 'newest':
|
|
return `newest-${goal.count}`
|
|
case 'all':
|
|
return 'all'
|
|
case 'set':
|
|
return 'set'
|
|
case 'dict':
|
|
return 'dict'
|
|
case 'none':
|
|
return 'none'
|
|
default:
|
|
throw new Error(`Unrecognized goal type: ${goal.type}`)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @public
|
|
* @param {string} tangleID
|
|
* @param {GoalDSL} goalDSL
|
|
* @returns {void}
|
|
*/
|
|
function set(tangleID, goalDSL) {
|
|
const goal = new GoalImpl(tangleID, goalDSL)
|
|
goals.set(tangleID, goal)
|
|
watch.set(goal)
|
|
}
|
|
|
|
/**
|
|
* @public
|
|
* @param {string} tangleID
|
|
* @returns {Goal | null}
|
|
*/
|
|
function get(tangleID) {
|
|
return goals.get(tangleID) ?? null
|
|
}
|
|
|
|
/**
|
|
* @public
|
|
* @param {MsgID} msgID
|
|
* @param {Msg} msg
|
|
* @param {CB<PurposeWithDetails>} cb
|
|
*/
|
|
function getMsgPurpose(msgID, msg, cb) {
|
|
let servesAsTrail = false
|
|
|
|
/** @return {Promise<PurposeWithDetails>} */
|
|
async function getPurpose() {
|
|
// Check whether this msg is a goalful root of some tangle:
|
|
asRoot: if (goals.has(msgID)) {
|
|
const goal = /** @type {GoalImpl} */ (goals.get(msgID))
|
|
if (goal.type === 'none') break asRoot
|
|
const tangle = await p(peer.db.getTangle)(msgID)
|
|
if (!tangle) break asRoot
|
|
const range = await p(crossGoalWithTangle)(goal, tangle)
|
|
if (isEmptyRange(range)) break asRoot
|
|
const [min] = range
|
|
if (min === 0) return ['goal']
|
|
if (min > 0) servesAsTrail = true
|
|
}
|
|
|
|
// Check whether this msg is a goalful affix of some tangle:
|
|
const validTangles =
|
|
/** @type {Array<[DBTangle, number, number, number, GoalType]>} */ ([])
|
|
asAffix: for (const tangleID in msg.metadata.tangles) {
|
|
if (!goals.has(tangleID)) continue asAffix
|
|
const goal = /** @type {GoalImpl} */ (goals.get(tangleID))
|
|
if (goal.type === 'none') continue asAffix
|
|
const tangle = await p(peer.db.getTangle)(tangleID)
|
|
if (!tangle) continue asAffix
|
|
const [min, max] = await p(crossGoalWithTangle)(goal, tangle)
|
|
if (min > max) continue asAffix
|
|
const recDepth = tangle.getDepth(msgID)
|
|
if (recDepth < 0) continue asAffix
|
|
validTangles.push([tangle, min, max, recDepth, goal.type])
|
|
}
|
|
// (Loop over once without heavy computations and maybe return early:)
|
|
for (const [, min, max, recDepth] of validTangles) {
|
|
if (min <= recDepth && recDepth <= max) return ['goal']
|
|
}
|
|
// At this point we know that the msg *cannot* serve as 'goal',
|
|
// so if it serves as trail, that'll do:
|
|
if (servesAsTrail) return ['trail']
|
|
// Check whether this msg is a trail affix of some tangle:
|
|
// (Loop again with heavy computations now that it's inevitable:)
|
|
for (const [ tangle, min] of validTangles) {
|
|
const minMsgIDs = tangle
|
|
// @ts-ignore
|
|
.topoSort()
|
|
// @ts-ignore
|
|
.filter((msgID) => tangle.getDepth(msgID) === min)
|
|
// @ts-ignore
|
|
const { erasables } = tangle.getDeletablesAndErasables(...minMsgIDs)
|
|
if (erasables.has(msgID)) return ['trail']
|
|
}
|
|
|
|
// Check whether this msg is a ghost affix of some tangle:
|
|
for (const [tangle, min, max, recDepth, goalType] of validTangles) {
|
|
if (goalType === 'dict') {
|
|
const span = peer.dict.getGhostSpan()
|
|
// @ts-ignore
|
|
if (await p(peer.dict.isGhostable)(msgID, tangle.id)) {
|
|
// @ts-ignore
|
|
return ['ghost', { tangleID: tangle.id, span }]
|
|
}
|
|
}
|
|
if (goalType === 'set') {
|
|
const span = peer.set.getGhostSpan()
|
|
// @ts-ignore
|
|
if (await p(peer.set.isGhostable)(msgID, tangle.id)) {
|
|
// @ts-ignore
|
|
return ['ghost', { tangleID: tangle.id, span }]
|
|
}
|
|
}
|
|
}
|
|
|
|
return ['none']
|
|
}
|
|
|
|
getPurpose()
|
|
.then(purpose => cb(null, purpose))
|
|
.catch(err => cb(err))
|
|
}
|
|
|
|
/**
|
|
* @public
|
|
* @returns {IterableIterator<Goal>}
|
|
*/
|
|
function list() {
|
|
return goals.values()
|
|
}
|
|
|
|
return {
|
|
parse,
|
|
serialize,
|
|
set,
|
|
get,
|
|
getMsgPurpose,
|
|
list,
|
|
watch,
|
|
}
|
|
}
|
|
|
|
exports.name = 'goals'
|
|
exports.needs = ['db', 'dict', 'set']
|
|
exports.init = initGoals
|