ehmry
/
syndicate-nim
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Migrate to non-generic Preserves

This commit is contained in:
Emery Hemingway 2023-12-31 19:15:06 +02:00
parent b5aa2a7b8f
commit c0cff79313
27 changed files with 828 additions and 576 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/syndicate.nim
View File

@ -6,7 +6,7 @@
import std/[asyncdispatch, macros, tables, typetraits] import std/[asyncdispatch, macros, tables, typetraits]
import preserves import preserves
export fromPreserve, toPreserve export fromPreserves, toPreserves
import ./syndicate/[actors, dataspaces, durings, patterns] import ./syndicate/[actors, dataspaces, durings, patterns]
import ./syndicate/protocols/dataspace import ./syndicate/protocols/dataspace
@ -32,7 +32,7 @@ proc `??`*(pat: Pattern; bindings: openArray[(int, Pattern)]): Pattern {.inline.
patterns.inject(pat, bindings) patterns.inject(pat, bindings)
type type
Observe* = dataspace.Observe[Cap] Observe* = dataspace.Observe
PublishProc = proc (turn: var Turn; v: Assertion; h: Handle) {.closure, gcsafe.} PublishProc = proc (turn: var Turn; v: Assertion; h: Handle) {.closure, gcsafe.}
RetractProc = proc (turn: var Turn; h: Handle) {.closure, gcsafe.} RetractProc = proc (turn: var Turn; h: Handle) {.closure, gcsafe.}
MessageProc = proc (turn: var Turn; v: Assertion) {.closure, gcsafe.} MessageProc = proc (turn: var Turn; v: Assertion) {.closure, gcsafe.}
@ -94,7 +94,7 @@ proc wrapPublishHandler(turn, handler: NimNode): NimNode =
quote do: quote do:
proc `handlerSym`(`turn`: var Turn; `bindingsSym`: Assertion; `handleSym`: Handle) = proc `handlerSym`(`turn`: var Turn; `bindingsSym`: Assertion; `handleSym`: Handle) =
`varSection` `varSection`
if fromPreserve(`valuesSym`, bindings): if fromPreserves(`valuesSym`, bindings):
`publishBody` `publishBody`
proc wrapMessageHandler(turn, handler: NimNode): NimNode = proc wrapMessageHandler(turn, handler: NimNode): NimNode =
@ -106,7 +106,7 @@ proc wrapMessageHandler(turn, handler: NimNode): NimNode =
quote do: quote do:
proc `handlerSym`(`turn`: var Turn; `bindingsSym`: Assertion) = proc `handlerSym`(`turn`: var Turn; `bindingsSym`: Assertion) =
`varSection` `varSection`
if fromPreserve(`valuesSym`, bindings): if fromPreserves(`valuesSym`, bindings):
`body` `body`
proc wrapDuringHandler(turn, entryBody, exitBody: NimNode): NimNode = proc wrapDuringHandler(turn, entryBody, exitBody: NimNode): NimNode =
@ -120,13 +120,13 @@ proc wrapDuringHandler(turn, entryBody, exitBody: NimNode): NimNode =
quote do: quote do:
proc `duringSym`(`turn`: var Turn; `bindingsSym`: Assertion; `handleSym`: Handle): TurnAction = proc `duringSym`(`turn`: var Turn; `bindingsSym`: Assertion; `handleSym`: Handle): TurnAction =
`varSection` `varSection`
if fromPreserve(`valuesSym`, `bindingsSym`): if fromPreserves(`valuesSym`, `bindingsSym`):
`publishBody` `publishBody`
else: else:
quote do: quote do:
proc `duringSym`(`turn`: var Turn; `bindingsSym`: Assertion; `handleSym`: Handle): TurnAction = proc `duringSym`(`turn`: var Turn; `bindingsSym`: Assertion; `handleSym`: Handle): TurnAction =
`varSection` `varSection`
if fromPreserve(`valuesSym`, `bindingsSym`): if fromPreserves(`valuesSym`, `bindingsSym`):
`publishBody` `publishBody`
proc action(`turn`: var Turn) = proc action(`turn`: var Turn) =
`exitBody` `exitBody`

76
src/syndicate/actors.nim
View File

@ -27,14 +27,14 @@ generateIdType(TurnId)
type type
Oid = sturdy.Oid Oid = sturdy.Oid
Assertion* = Preserve[Cap] Assertion* = Value
Caveat = sturdy.Caveat[Cap] Caveat = sturdy.Caveat
Attenuation = seq[Caveat] Attenuation = seq[Caveat]
Rewrite = sturdy.Rewrite[Cap] Rewrite = sturdy.Rewrite
AssertionRef* = ref object AssertionRef* = ref object
value*: Preserve[Cap] value*: Value
# if the Enity methods take a Preserve[Cap] object then the generated # if the Enity methods take a Value object then the generated
# C code has "redefinition of struct" problems when orc is enabled # C code has "redefinition of struct" problems when orc is enabled
Entity* = ref object of RootObj Entity* = ref object of RootObj
@ -75,7 +75,7 @@ type
facet: Facet facet: Facet
queues: Queues # a ref object that can outlive Turn queues: Queues # a ref object that can outlive Turn
when tracing: when tracing:
desc: TurnDescription[void] desc: TurnDescription
Facet* = ref FacetObj Facet* = ref FacetObj
FacetObj = object FacetObj = object
@ -96,17 +96,17 @@ when tracing:
proc trace(actor: Actor; act: ActorActivation) = proc trace(actor: Actor; act: ActorActivation) =
if not actor.traceStream.isNil: if not actor.traceStream.isNil:
var entry = TraceEntry[void]( var entry = TraceEntry(
timestamp: getTime().toUnixFloat(), timestamp: getTime().toUnixFloat(),
actor: initRecord("named", actor.name.toPreserve(void)), actor: initRecord("named", actor.name.toPreserves),
item: act) item: act)
actor.traceStream.writeText entry.toPreserve(void) actor.traceStream.writeText entry.toPreserves
actor.traceStream.writeLine() actor.traceStream.writeLine()
proc path(facet: Facet): seq[trace.FacetId[void]] = proc path(facet: Facet): seq[trace.FacetId] =
var f = facet var f = facet
while not f.isNil: while not f.isNil:
result.add f.id.toPreserve result.add f.id.toPreserves
f = f.parent f = f.parent
method publish*(e: Entity; turn: var Turn; v: AssertionRef; h: Handle) {.base, gcsafe.} = discard method publish*(e: Entity; turn: var Turn; v: AssertionRef; h: Handle) {.base, gcsafe.} = discard
@ -164,7 +164,7 @@ proc enqueue(turn: var Turn; target: Facet; action: TurnAction) =
else: else:
turn.queues[target] = @[action] turn.queues[target] = @[action]
type Bindings = Table[Preserve[Cap], Preserve[Cap]] type Bindings = Table[Value, Value]
proc match(bindings: var Bindings; p: Pattern; v: Assertion): bool = proc match(bindings: var Bindings; p: Pattern; v: Assertion): bool =
case p.orKind case p.orKind
@ -182,7 +182,7 @@ proc match(bindings: var Bindings; p: Pattern; v: Assertion): bool =
result = v.isEmbedded result = v.isEmbedded
of PatternKind.Pbind: of PatternKind.Pbind:
if match(bindings, p.pbind.pattern, v): if match(bindings, p.pbind.pattern, v):
bindings[toPreserve(p.pbind.pattern, Cap)] = v bindings[p.pbind.pattern.toPreserves] = v
result = true result = true
of PatternKind.Pand: of PatternKind.Pand:
for pp in p.pand.patterns: for pp in p.pand.patterns:
@ -234,7 +234,7 @@ proc instantiate(t: Template; bindings: Bindings): Assertion =
result = embed(attenuate(v.embed, t.tattenuate.attenuation)) result = embed(attenuate(v.embed, t.tattenuate.attenuation))
of TemplateKind.TRef: of TemplateKind.TRef:
let n = $t.tref.binding.int let n = $t.tref.binding.int
try: result = bindings[toPreserve(n, Cap)] try: result = bindings[n.toPreserves]
except KeyError: except KeyError:
raise newException(ValueError, "unbound reference: " & n) raise newException(ValueError, "unbound reference: " & n)
of TemplateKind.Lit: of TemplateKind.Lit:
@ -246,11 +246,11 @@ proc instantiate(t: Template; bindings: Bindings): Assertion =
for i, tt in t.tcompound.rec.fields: for i, tt in t.tcompound.rec.fields:
result[i] = instantiate(tt, bindings) result[i] = instantiate(tt, bindings)
of TCompoundKind.arr: of TCompoundKind.arr:
result = initSequence(t.tcompound.arr.items.len, Cap) result = initSequence(t.tcompound.arr.items.len)
for i, tt in t.tcompound.arr.items: for i, tt in t.tcompound.arr.items:
result[i] = instantiate(tt, bindings) result[i] = instantiate(tt, bindings)
of TCompoundKind.dict: of TCompoundKind.dict:
result = initDictionary(Cap) result = initDictionary()
for key, tt in t.tcompound.dict.entries: for key, tt in t.tcompound.dict.entries:
result[key] = instantiate(tt, bindings) result[key] = instantiate(tt, bindings)
@ -286,13 +286,13 @@ proc publish(turn: var Turn; r: Cap; v: Assertion; h: Handle) =
e.established = true e.established = true
publish(r.target, turn, AssertionRef(value: a), e.handle) publish(r.target, turn, AssertionRef(value: a), e.handle)
when tracing: when tracing:
var act = ActionDescription[void](orKind: ActionDescriptionKind.enqueue) var act = ActionDescription(orKind: ActionDescriptionKind.enqueue)
act.enqueue.event.target.actor = turn.facet.actor.id.toPreserve act.enqueue.event.target.actor = turn.facet.actor.id.toPreserves
act.enqueue.event.target.facet = turn.facet.id.toPreserve act.enqueue.event.target.facet = turn.facet.id.toPreserves
act.enqueue.event.target.oid = r.target.oid.toPreserve act.enqueue.event.target.oid = r.target.oid.toPreserves
act.enqueue.event.detail = trace.TurnEvent[void](orKind: TurnEventKind.assert) act.enqueue.event.detail = trace.TurnEvent(orKind: TurnEventKind.assert)
act.enqueue.event.detail.assert.assertion.value.value = act.enqueue.event.detail.assert.assertion.value.value =
contract(v) do (r: Cap) -> Preserve[void]: contract(v) do (r: Cap) -> Value:
discard discard
act.enqueue.event.detail.assert.handle = h act.enqueue.event.detail.assert.handle = h
turn.desc.actions.add act turn.desc.actions.add act
@ -303,7 +303,7 @@ proc publish*(turn: var Turn; r: Cap; a: Assertion): Handle =
publish(turn, r, a, result) publish(turn, r, a, result)
proc publish*[T](turn: var Turn; r: Cap; a: T): Handle = proc publish*[T](turn: var Turn; r: Cap; a: T): Handle =
publish(turn, r, toPreserve(a, Cap)) publish(turn, r, a.toPreserves)
proc retract(turn: var Turn; e: OutboundAssertion) = proc retract(turn: var Turn; e: OutboundAssertion) =
enqueue(turn, e.peer.relay) do (turn: var Turn): enqueue(turn, e.peer.relay) do (turn: var Turn):
@ -323,7 +323,7 @@ proc message*(turn: var Turn; r: Cap; v: Assertion) =
r.target.message(turn, AssertionRef(value: a)) r.target.message(turn, AssertionRef(value: a))
proc message*[T](turn: var Turn; r: Cap; v: T) = proc message*[T](turn: var Turn; r: Cap; v: T) =
message(turn, r, toPreserve(v, Cap)) message(turn, r, v.toPreserves)
proc sync(turn: var Turn; e: Entity; peer: Cap) = proc sync(turn: var Turn; e: Entity; peer: Cap) =
e.sync(turn, peer) e.sync(turn, peer)
@ -405,7 +405,7 @@ proc terminate(facet; turn: var Turn; orderly: bool) {.gcsafe.} =
else: else:
terminate(facet.actor, turn, nil) terminate(facet.actor, turn, nil)
when tracing: when tracing:
var act = ActionDescription[void](orKind: ActionDescriptionKind.facetStop) var act = ActionDescription(orKind: ActionDescriptionKind.facetStop)
act.facetstop.path = facet.path act.facetstop.path = facet.path
turn.desc.actions.add act turn.desc.actions.add act
@ -424,7 +424,7 @@ proc newFacet*(turn: var Turn): Facet = newFacet(turn.facet.actor, turn.facet)
proc inFacet*(turn: var Turn; bootProc: TurnAction): Facet = proc inFacet*(turn: var Turn; bootProc: TurnAction): Facet =
result = newFacet(turn) result = newFacet(turn)
when tracing: when tracing:
var act = ActionDescription[void](orKind: ActionDescriptionKind.facetstart) var act = ActionDescription(orKind: ActionDescriptionKind.facetstart)
act.facetstart.path.add result.path act.facetstart.path.add result.path
turn.desc.actions.add act turn.desc.actions.add act
inFacet(turn, result, stopIfInertAfter(bootProc)) inFacet(turn, result, stopIfInertAfter(bootProc))
@ -442,9 +442,9 @@ proc newActor(name: string; handleAlloc: ref Handle): Actor =
) )
result.root = newFacet(result, nil) result.root = newFacet(result, nil)
when tracing: when tracing:
var act = ActorActivation[void](orKind: ActorActivationKind.start) var act = ActorActivation(orKind: ActorActivationKind.start)
act.start.actorName = Name[void](orKind: NameKind.named) act.start.actorName = Name(orKind: NameKind.named)
act.start.actorName.named.name = name.toPreserve(void) act.start.actorName.named.name = name.toPreserves
trace(result, act) trace(result, act)
proc run(actor; bootProc: TurnAction; initialAssertions: OutboundTable) = proc run(actor; bootProc: TurnAction; initialAssertions: OutboundTable) =
@ -471,8 +471,8 @@ proc spawn*(name: string; turn: var Turn; bootProc: TurnAction; initialAssertion
when tracing: when tracing:
actor.turnIdAllocator = turn.facet.actor.turnIdAllocator actor.turnIdAllocator = turn.facet.actor.turnIdAllocator
actor.traceStream = turn.facet.actor.traceStream actor.traceStream = turn.facet.actor.traceStream
var act = ActionDescription[void](orKind: ActionDescriptionKind.spawn) var act = ActionDescription(orKind: ActionDescriptionKind.spawn)
act.spawn.id = actor.id.toPreserve act.spawn.id = actor.id.toPreserves
turn.desc.actions.add act turn.desc.actions.add act
run(actor, bootProc, newOutBound) run(actor, bootProc, newOutBound)
actor actor
@ -488,7 +488,7 @@ proc terminate(actor; turn; reason: ref Exception) =
actor.exiting = true actor.exiting = true
actor.exitReason = reason actor.exitReason = reason
when tracing: when tracing:
var act = ActorActivation[void](orKind: ActorActivationKind.stop) var act = ActorActivation(orKind: ActorActivationKind.stop)
if not reason.isNil: if not reason.isNil:
act.stop.status = ExitStatus(orKind: ExitStatusKind.Error) act.stop.status = ExitStatus(orKind: ExitStatusKind.Error)
act.stop.status.error.message = reason.msg act.stop.status.error.message = reason.msg
@ -525,8 +525,8 @@ proc run*(facet; action: TurnAction; zombieTurn = false) =
var turn = Turn(facet: facet, queues: queues) var turn = Turn(facet: facet, queues: queues)
action(turn) action(turn)
when tracing: when tracing:
turn.desc.id = facet.nextTurnId.toPreserve turn.desc.id = facet.nextTurnId.toPreserves
facet.actor.trace ActorActivation[void]( facet.actor.trace ActorActivation(
orKind: ActorActivationKind.turn, turn: turn.desc) orKind: ActorActivationKind.turn, turn: turn.desc)
for facet, queue in queues: for facet, queue in queues:
for action in queue: run(facet, action) for action in queue: run(facet, action)
@ -543,8 +543,8 @@ proc addCallback*(fut: FutureBase; facet: Facet; act: TurnAction) =
else: else:
when tracing: when tracing:
run(facet) do (turn: var Turn): run(facet) do (turn: var Turn):
turn.desc.cause = TurnCause[void](orKind: TurnCauseKind.external) turn.desc.cause = TurnCause(orKind: TurnCauseKind.external)
turn.desc.cause.external.description = "Future".toPreserve turn.desc.cause.external.description = "Future".toPreserves
act(turn) act(turn)
else: else:
run(facet, act) run(facet, act)
@ -564,8 +564,8 @@ proc addCallback*[T](fut: Future[T]; turn: var Turn; act: proc (t: var Turn, x:
if fut.failed: terminate(turn.facet, fut.error) if fut.failed: terminate(turn.facet, fut.error)
else: else:
when tracing: when tracing:
turn.desc.cause = TurnCause[void](orKind: TurnCauseKind.external) turn.desc.cause = TurnCause(orKind: TurnCauseKind.external)
turn.desc.cause.external.description = "Future".toPreserve turn.desc.cause.external.description = "Future".toPreserves
act(turn, read fut) act(turn, read fut)
proc stop*(turn: var Turn, facet: Facet) = proc stop*(turn: var Turn, facet: Facet) =

2
src/syndicate/actors/timers.nim
View File

@ -10,7 +10,7 @@ from syndicate/protocols/dataspace import Observe
export timer export timer
type Observe = dataspace.Observe[Cap] type Observe = dataspace.Observe
proc now: float64 = getTime().toUnixFloat() proc now: float64 = getTime().toUnixFloat()

8
src/syndicate/capabilities.nim
View File

@ -19,16 +19,16 @@ export `$`
proc hmac(key, data: openarray[byte]): seq[byte] = proc hmac(key, data: openarray[byte]): seq[byte] =
count[Hmac[BLAKE2S_256]](key, data).data[0..15].toSeq count[Hmac[BLAKE2S_256]](key, data).data[0..15].toSeq
proc mint*[T](key: openarray[byte]; oid: Preserve[T]): SturdyRef[T] = proc mint*(key: openarray[byte]; oid: Value): SturdyRef =
SturdyRef[T](parameters: { SturdyRef[T](parameters: {
"oid": oid, "oid": oid,
"sig": hmac(key, encode(oid)).toPreserve(T), "sig": hmac(key, encode(oid)).toPreserves(T),
}.toDictionary, }.toDictionary,
) )
proc mint*(): SturdyRef[Cap] = proc mint*(): SturdyRef =
var key: array[16, byte] var key: array[16, byte]
mint(key, toPreserve("syndicate", Cap)) mint(key, "syndicate".toPreserves)
proc attenuate*[T](r: SturdyRef[T]; caveats: seq[Caveat]): SturdyRef[T] = proc attenuate*[T](r: SturdyRef[T]; caveats: seq[Caveat]): SturdyRef[T] =
result = SturdyRef[T]( result = SturdyRef[T](

8
src/syndicate/dataspaces.nim
View File

@ -8,8 +8,8 @@ import ./actors, ./protocols/dataspace, ./skeletons
from ./protocols/protocol import Handle from ./protocols/protocol import Handle
type type
Assertion = Preserve[Cap] Assertion = Value
Observe = dataspace.Observe[Cap] Observe = dataspace.Observe
Turn = actors.Turn Turn = actors.Turn
Dataspace {.final.} = ref object of Entity Dataspace {.final.} = ref object of Entity
@ -19,7 +19,7 @@ type
method publish(ds: Dataspace; turn: var Turn; a: AssertionRef; h: Handle) {.gcsafe.} = method publish(ds: Dataspace; turn: var Turn; a: AssertionRef; h: Handle) {.gcsafe.} =
if add(ds.index, turn, a.value): if add(ds.index, turn, a.value):
var obs: Observe var obs: Observe
if obs.fromPreserve a.value: if obs.fromPreserves(a.value):
ds.index.add(turn, obs.pattern, obs.observer) ds.index.add(turn, obs.pattern, obs.observer)
ds.handleMap[h] = a.value ds.handleMap[h] = a.value
@ -28,7 +28,7 @@ method retract(ds: Dataspace; turn: var Turn; h: Handle) {.gcsafe.} =
if remove(ds.index, turn, v): if remove(ds.index, turn, v):
ds.handleMap.del h ds.handleMap.del h
var obs: Observe var obs: Observe
if obs.fromPreserve v: if obs.fromPreserves v:
ds.index.remove(turn, obs.pattern, obs.observer) ds.index.remove(turn, obs.pattern, obs.observer)
method message(ds: Dataspace; turn: var Turn; a: AssertionRef) {.gcsafe.} = method message(ds: Dataspace; turn: var Turn; a: AssertionRef) {.gcsafe.} =

2
src/syndicate/durings.nim
View File

@ -8,7 +8,7 @@ import ./actors, ./patterns, ./protocols/dataspace
from ./protocols/protocol import Handle from ./protocols/protocol import Handle
type type
Observe = dataspace.Observe[Cap] Observe = dataspace.Observe
Turn = actors.Turn Turn = actors.Turn
type type

67
src/syndicate/patterns.nim
View File

@ -10,15 +10,14 @@ from ./actors import Cap
export dataspacePatterns.`$`, PatternKind, DCompoundKind, AnyAtomKind export dataspacePatterns.`$`, PatternKind, DCompoundKind, AnyAtomKind
type type
Value = Preserve[Cap] AnyAtom = dataspacePatterns.AnyAtom
AnyAtom = dataspacePatterns.AnyAtom[Cap] DBind = dataspacePatterns.DBind
DBind = dataspacePatterns.DBind[Cap] DCompound = dataspacePatterns.DCompound
DCompound = dataspacePatterns.DCompound[Cap] DCompoundArr = dataspacePatterns.DCompoundArr
DCompoundArr = dataspacePatterns.DCompoundArr[Cap] DCompoundDict = dataspacePatterns.DCompoundDict
DCompoundDict = dataspacePatterns.DCompoundDict[Cap] DCompoundRec = dataspacePatterns.DCompoundRec
DCompoundRec = dataspacePatterns.DCompoundRec[Cap] DLit = dataspacePatterns.DLit
DLit = dataspacePatterns.DLit[Cap] Pattern* = dataspacePatterns.Pattern
Pattern* = dataspacePatterns.Pattern[Cap]
iterator orderedEntries*(dict: DCompoundDict): (Value, Pattern) = iterator orderedEntries*(dict: DCompoundDict): (Value, Pattern) =
## Iterate a `DCompoundDict` in Preserves order. ## Iterate a `DCompoundDict` in Preserves order.
@ -58,7 +57,7 @@ proc drop*(): Pattern {.inline.} = Pattern(orKind: PatternKind.DDiscard)
proc grab*(): Pattern {.inline.} = DBind(pattern: drop()).toPattern proc grab*(): Pattern {.inline.} = DBind(pattern: drop()).toPattern
## Create a pattern to capture any value. ## Create a pattern to capture any value.
proc grab*[T](pr: Preserve[T]): Pattern = proc grab*[T](pr: Value): Pattern =
## Convert a `Preserve` value to a `Pattern`. ## Convert a `Preserve` value to a `Pattern`.
runnableExamples: runnableExamples:
from std/unittest import check from std/unittest import check
@ -88,15 +87,15 @@ proc grab*[T](pr: Preserve[T]): Pattern =
drop() drop()
else: else:
DCompoundRec( DCompoundRec(
label: cast[Preserve[Cap]](pr.label), # TODO: don't cast like this label: pr.label,
fields: map[Preserve[T], Pattern](pr.fields, grab)).toPattern fields: map[Value, Pattern](pr.fields, grab)).toPattern
of pkSequence: of pkSequence:
DCompoundArr(items: map(pr.sequence, grab)).toPattern DCompoundArr(items: map(pr.sequence, grab)).toPattern
of pkSet: of pkSet:
raiseAssert "cannot construct a pattern over a set literal" raiseAssert "cannot construct a pattern over a set literal"
of pkDictionary: of pkDictionary:
var dict = DCompoundDict() var dict = DCompoundDict()
for key, val in pr.pairs: dict.entries[cast[Preserve[Cap]](key)] = grab val for key, val in pr.pairs: dict.entries[key] = grab val
dict.toPattern dict.toPattern
of pkEmbedded: of pkEmbedded:
# TODO: can patterns be constructed over embedded literals? # TODO: can patterns be constructed over embedded literals?
@ -112,20 +111,20 @@ proc grab*[T](val: T): Pattern =
$grab(true) == "<lit #t>" $grab(true) == "<lit #t>"
$grab(3.14) == "<lit 3.14>" $grab(3.14) == "<lit 3.14>"
$grab([0, 1, 2, 3]) == "<arr [<lit 0> <lit 1> <lit 2> <lit 3>]>" $grab([0, 1, 2, 3]) == "<arr [<lit 0> <lit 1> <lit 2> <lit 3>]>"
grab (toPreserve(val, Cap)) grab(val)
proc patternOfType(typ: static typedesc; `bind`: static bool): Pattern = proc patternOfType(typ: static typedesc; `bind`: static bool): Pattern =
when typ is ref: when typ is ref:
patternOfType(pointerBase(typ), `bind`) patternOfType(pointerBase(typ), `bind`)
elif typ.hasPreservesRecordPragma: elif typ.hasPreservesRecordPragma:
var rec = DCompoundRec(label: typ.recordLabel.tosymbol(Cap)) var rec = DCompoundRec(label: typ.recordLabel.toSymbol)
for _, f in fieldPairs(default typ): for _, f in fieldPairs(default typ):
add(rec.fields, patternOfType(typeof f, `bind`)) add(rec.fields, patternOfType(typeof f, `bind`))
result = rec.toPattern result = rec.toPattern
elif typ.hasPreservesDictionaryPragma: elif typ.hasPreservesDictionaryPragma:
var dict = DCompoundDict() var dict = DCompoundDict()
for key, val in fieldPairs(default typ): for key, val in fieldPairs(default typ):
dict.entries[toSymbol(key, Cap)] = patternOfType(typeof val, `bind`) dict.entries[key.toSymbol] = patternOfType(typeof val, `bind`)
dict.toPattern dict.toPattern
elif typ is tuple: elif typ is tuple:
var arr = DCompoundArr() var arr = DCompoundArr()
@ -182,7 +181,7 @@ proc grab*(typ: static typedesc; bindings: sink openArray[(int, Pattern)]): Patt
when typ is ptr | ref: when typ is ptr | ref:
grab(pointerBase(typ), bindings) grab(pointerBase(typ), bindings)
elif typ.hasPreservesRecordPragma: elif typ.hasPreservesRecordPragma:
var rec = DCompoundRec(label: typ.recordLabel.tosymbol(Cap)) var rec = DCompoundRec(label: typ.recordLabel.toSymbol)
rec.fields.setLen(fieldCount typ) rec.fields.setLen(fieldCount typ)
var i: int var i: int
for _, f in fieldPairs(default typ): for _, f in fieldPairs(default typ):
@ -205,14 +204,14 @@ proc grabLit*(): Pattern =
from std/unittest import check from std/unittest import check
check: check:
$grabLit() == """<rec lit [<bind <_>>]>""" $grabLit() == """<rec lit [<bind <_>>]>"""
grabType(dataspacePatterns.DLit[void]) grabType(dataspacePatterns.DLit)
proc grabDict*(): Pattern = proc grabDict*(): Pattern =
grabType(dataspacePatterns.DCompoundDict[void]) grabType(dataspacePatterns.DCompoundDict)
proc unpackLiterals*[E](pr: Preserve[E]): Preserve[E] = proc unpackLiterals*(pr: Value): Value =
result = pr result = pr
apply(result) do (pr: var Preserve[E]): apply(result) do (pr: var Value):
if pr.isRecord("lit", 1) or pr.isRecord("dict", 1) or pr.isRecord("arr", 1) or pr.isRecord("set", 1): if pr.isRecord("lit", 1) or pr.isRecord("dict", 1) or pr.isRecord("arr", 1) or pr.isRecord("set", 1):
pr = pr.record[0] pr = pr.record[0]
@ -258,7 +257,7 @@ proc inject*(pat: Pattern; bindings: openArray[(int, Pattern)]): Pattern =
var offset = 0 var offset = 0
inject(pat, bindings, offset) inject(pat, bindings, offset)
proc inject*(pat: Pattern; bindings: openArray[(Preserve[Cap], Pattern)]): Pattern = proc inject*(pat: Pattern; bindings: openArray[(Value, Pattern)]): Pattern =
## Inject `bindings` into a dictionary pattern. ## Inject `bindings` into a dictionary pattern.
assert pat.orKind == PatternKind.DCompound assert pat.orKind == PatternKind.DCompound
assert pat.dcompound.orKind == DCompoundKind.dict assert pat.dcompound.orKind == DCompoundKind.dict
@ -266,19 +265,19 @@ proc inject*(pat: Pattern; bindings: openArray[(Preserve[Cap], Pattern)]): Patte
for (key, val) in bindings: for (key, val) in bindings:
result.dcompound.dict.entries[key] = val result.dcompound.dict.entries[key] = val
proc grabRecord*(label: Preserve[Cap], fields: varargs[Pattern]): Pattern = proc grabRecord*(label: Value, fields: varargs[Pattern]): Pattern =
runnableExamples: runnableExamples:
from std/unittest import check from std/unittest import check
import syndicate/actors, preserves import syndicate/actors, preserves
check: check:
$grabRecord("Says".toSymbol(Cap), grab(), grab()) == $grabRecord("Says".toSymbol, grab(), grab()) ==
"""<rec Says [<bind <_>> <bind <_>>]>""" """<rec Says [<bind <_>> <bind <_>>]>"""
DCompoundRec(label: label, fields: fields.toSeq).toPattern DCompoundRec(label: label, fields: fields.toSeq).toPattern
proc grabRecord*(label: string, fields: varargs[Pattern]): Pattern = proc grabRecord*(label: string, fields: varargs[Pattern]): Pattern =
## Sugar for creating record patterns. ## Sugar for creating record patterns.
## `label` is converted to a symbol value. ## `label` is converted to a symbol value.
grabRecord(label.toSymbol(Cap), fields) grabRecord(label.toSymbol, fields)
proc grabDictionary*(bindings: sink openArray[(Value, Pattern)]): Pattern = proc grabDictionary*(bindings: sink openArray[(Value, Pattern)]): Pattern =
## Construct a pattern that grabs some dictionary pairs. ## Construct a pattern that grabs some dictionary pairs.
@ -289,7 +288,7 @@ proc grabDictionary*(bindings: sink openArray[(string, Pattern)]): Pattern =
## Keys are converted from strings to symbols. ## Keys are converted from strings to symbols.
result = DCompoundDict().toPattern result = DCompoundDict().toPattern
for (key, val) in bindings.items: for (key, val) in bindings.items:
result.dcompound.dict.entries[key.toSymbol(Cap)] = val result.dcompound.dict.entries[key.toSymbol] = val
proc depattern(comp: DCompound; values: var seq[Value]; index: var int): Value {.gcsafe.} proc depattern(comp: DCompound; values: var seq[Value]; index: var int): Value {.gcsafe.}
@ -302,7 +301,7 @@ proc depattern(pat: Pattern; values: var seq[Value]; index: var int): Value =
result = move values[index] result = move values[index]
inc index inc index
of PatternKind.DLit: of PatternKind.DLit:
result = pat.dlit.value.toPreserve(Cap) result = pat.dlit.value.toPreserves
of PatternKind.DCompound: of PatternKind.DCompound:
result = depattern(pat.dcompound, values, index) result = depattern(pat.dcompound, values, index)
@ -313,7 +312,7 @@ proc depattern(comp: DCompound; values: var seq[Value]; index: var int): Value {
for i, f in comp.rec.fields: for i, f in comp.rec.fields:
result[i] = depattern(f, values, index) result[i] = depattern(f, values, index)
of DCompoundKind.arr: of DCompoundKind.arr:
result = initSequence(comp.arr.items.len, Cap) result = initSequence(comp.arr.items.len)
for i, e in comp.arr.items: for i, e in comp.arr.items:
result[i] = depattern(e, values, index) result[i] = depattern(e, values, index)
of DCompoundKind.dict: of DCompoundKind.dict:
@ -330,12 +329,12 @@ type Literal*[T] = object
## A wrapper type to deserialize patterns to native values. ## A wrapper type to deserialize patterns to native values.
value*: T value*: T
proc fromPreserveHook*[T, E](lit: var Literal[T]; pr: Preserve[E]): bool = proc fromPreservesHook*[T](lit: var Literal[T]; pr: Value): bool =
var pat: Pattern var pat: Pattern
pat.fromPreserve(pr) and lit.value.fromPreserve(depattern(pat, @[])) pat.fromPreserves(pr) and lit.value.fromPreserves(depattern(pat, @[]))
proc toPreserveHook*[T](lit: Literal[T]; E: typedesc): Preserve[E] = proc toPreservesHook*[T](lit: Literal[T]): Value =
lit.value.grab.toPreserve(E) lit.value.grab.toPreserves
type type
Path* = seq[Value] Path* = seq[Value]
@ -349,7 +348,7 @@ type
func walk(result: var Analysis; path: var Path; p: Pattern) func walk(result: var Analysis; path: var Path; p: Pattern)
func walk(result: var Analysis; path: var Path; key: int|Value; pat: Pattern) = func walk(result: var Analysis; path: var Path; key: int|Value; pat: Pattern) =
path.add(key.toPreserve(Cap)) path.add(key.toPreserves)
walk(result, path, pat) walk(result, path, pat)
discard path.pop discard path.pop
@ -369,7 +368,7 @@ func walk(result: var Analysis; path: var Path; p: Pattern) =
of PatternKind.DDiscard: discard of PatternKind.DDiscard: discard
of PatternKind.DLit: of PatternKind.DLit:
result.constPaths.add(path) result.constPaths.add(path)
result.constValues.add(p.dlit.value.toPreserve(Cap)) result.constValues.add(p.dlit.value.toPreserves)
func analyse*(p: Pattern): Analysis = func analyse*(p: Pattern): Analysis =
var path: Path var path: Path

14
src/syndicate/protocols/dataspace.nim
View File

@ -3,12 +3,12 @@ import
preserves, dataspacePatterns preserves, dataspacePatterns
type type
Observe*[Cap] {.acyclic, preservesRecord: "Observe".} = ref object Observe* {.preservesRecord: "Observe".} = object
`pattern`*: dataspacePatterns.Pattern[Cap] `pattern`*: dataspacePatterns.Pattern
`observer`*: Cap `observer`*: Value
proc `$`*[Cap](x: Observe[Cap]): string = proc `$`*(x: Observe): string =
`$`(toPreserve(x, Cap)) `$`(toPreserves(x))
proc encode*[Cap](x: Observe[Cap]): seq[byte] = proc encode*(x: Observe): seq[byte] =
encode(toPreserve(x, Cap)) encode(toPreserves(x))

61
src/syndicate/protocols/dataspacePatterns.nim
View File

@ -12,8 +12,8 @@ type
AnyAtomString* = string AnyAtomString* = string
AnyAtomBytes* = seq[byte] AnyAtomBytes* = seq[byte]
AnyAtomSymbol* = Symbol AnyAtomSymbol* = Symbol
AnyAtomEmbedded*[Cap] = Cap AnyAtomEmbedded* = Value
`AnyAtom`*[Cap] {.preservesOr.} = object `AnyAtom`* {.preservesOr.} = object
case orKind*: AnyAtomKind case orKind*: AnyAtomKind
of AnyAtomKind.`bool`: of AnyAtomKind.`bool`:
`bool`*: AnyAtomBool `bool`*: AnyAtomBool
@ -37,68 +37,61 @@ type
`symbol`*: AnyAtomSymbol `symbol`*: AnyAtomSymbol
of AnyAtomKind.`embedded`: of AnyAtomKind.`embedded`:
`embedded`*: AnyAtomEmbedded[Cap] `embedded`*: AnyAtomEmbedded
DLit*[Cap] {.preservesRecord: "lit".} = object DLit* {.preservesRecord: "lit".} = object
`value`*: AnyAtom[Cap] `value`*: AnyAtom
DBind*[Cap] {.acyclic, preservesRecord: "bind".} = ref object DBind* {.preservesRecord: "bind".} = object
`pattern`*: Pattern[Cap] `pattern`*: Pattern
DDiscard* {.preservesRecord: "_".} = object DDiscard* {.preservesRecord: "_".} = object
DCompoundKind* {.pure.} = enum DCompoundKind* {.pure.} = enum
`rec`, `arr`, `dict` `rec`, `arr`, `dict`
DCompoundRec*[Cap] {.acyclic, preservesRecord: "rec".} = ref object DCompoundRec* {.preservesRecord: "rec".} = object
`label`*: Preserve[Cap] `label`*: Value
`fields`*: seq[Pattern[Cap]] `fields`*: seq[Pattern]
DCompoundArr*[Cap] {.acyclic, preservesRecord: "arr".} = ref object DCompoundArr* {.preservesRecord: "arr".} = object
`items`*: seq[Pattern[Cap]] `items`*: seq[Pattern]
DCompoundDict*[Cap] {.acyclic, preservesRecord: "dict".} = ref object DCompoundDict* {.preservesRecord: "dict".} = object
`entries`*: Table[Preserve[Cap], Pattern[Cap]] `entries`*: Table[Value, Pattern]
`DCompound`*[Cap] {.acyclic, preservesOr.} = ref object `DCompound`* {.preservesOr.} = object
case orKind*: DCompoundKind case orKind*: DCompoundKind
of DCompoundKind.`rec`: of DCompoundKind.`rec`:
`rec`*: DCompoundRec[Cap] `rec`*: DCompoundRec
of DCompoundKind.`arr`: of DCompoundKind.`arr`:
`arr`*: DCompoundArr[Cap] `arr`*: DCompoundArr
of DCompoundKind.`dict`: of DCompoundKind.`dict`:
`dict`*: DCompoundDict[Cap] `dict`*: DCompoundDict
PatternKind* {.pure.} = enum PatternKind* {.pure.} = enum
`DDiscard`, `DBind`, `DLit`, `DCompound` `DDiscard`, `DBind`, `DLit`, `DCompound`
`Pattern`*[Cap] {.acyclic, preservesOr.} = ref object `Pattern`* {.acyclic, preservesOr.} = ref object
case orKind*: PatternKind case orKind*: PatternKind
of PatternKind.`DDiscard`: of PatternKind.`DDiscard`:
`ddiscard`*: DDiscard `ddiscard`*: DDiscard
of PatternKind.`DBind`: of PatternKind.`DBind`:
`dbind`*: DBind[Cap] `dbind`*: DBind
of PatternKind.`DLit`: of PatternKind.`DLit`:
`dlit`*: DLit[Cap] `dlit`*: DLit
of PatternKind.`DCompound`: of PatternKind.`DCompound`:
`dcompound`*: DCompound[Cap] `dcompound`*: DCompound
proc `$`*[Cap](x: AnyAtom[Cap] | DLit[Cap] | DBind[Cap] | DCompound[Cap] | proc `$`*(x: AnyAtom | DLit | DBind | DDiscard | DCompound | Pattern): string =
Pattern[Cap]): string = `$`(toPreserves(x))
`$`(toPreserve(x, Cap))
proc encode*[Cap](x: AnyAtom[Cap] | DLit[Cap] | DBind[Cap] | DCompound[Cap] | proc encode*(x: AnyAtom | DLit | DBind | DDiscard | DCompound | Pattern): seq[
Pattern[Cap]): seq[byte] = byte] =
encode(toPreserve(x, Cap)) encode(toPreserves(x))
proc `$`*(x: DDiscard): string =
`$`(toPreserve(x))
proc encode*(x: DDiscard): seq[byte] =
encode(toPreserve(x))

126
src/syndicate/protocols/gatekeeper.nim
View File

@ -3,106 +3,102 @@ import
preserves preserves
type type
Bind*[Cap] {.preservesRecord: "bind".} = object Bind* {.preservesRecord: "bind".} = object
`description`*: Description[Cap] `description`*: Description
`target`*: Cap `target`*: Value
`observer`*: BindObserver[Cap] `observer`*: BindObserver
Route*[Cap] {.preservesRecord: "route".} = object Route* {.preservesRecord: "route".} = object
`transports`*: seq[Preserve[Cap]] `transports`*: seq[Value]
`pathSteps`* {.preservesTupleTail.}: seq[PathStep[Cap]] `pathSteps`* {.preservesTupleTail.}: seq[PathStep]
BindObserverKind* {.pure.} = enum BindObserverKind* {.pure.} = enum
`present`, `absent` `present`, `absent`
BindObserverPresent*[Cap] = Cap BindObserverPresent* = Bound
`BindObserver`*[Cap] {.preservesOr.} = object `BindObserver`* {.preservesOr.} = object
case orKind*: BindObserverKind case orKind*: BindObserverKind
of BindObserverKind.`present`: of BindObserverKind.`present`:
`present`*: BindObserverPresent[Cap] `present`*: BindObserverPresent
of BindObserverKind.`absent`: of BindObserverKind.`absent`:
`absent`* {.preservesLiteral: "#f".}: bool `absent`* {.preservesLiteral: "#f".}: bool
TransportConnection*[Cap] {.preservesRecord: "connect-transport".} = object TransportConnection* {.preservesRecord: "connect-transport".} = object
`addr`*: Preserve[Cap] `addr`*: Value
`control`*: Cap `control`*: TransportControl
`resolved`*: Resolved[Cap] `resolved`*: Resolved
Step*[Cap] = Preserve[Cap] Step* = Value
ResolvedPathStep*[Cap] {.preservesRecord: "path-step".} = object ResolvedPathStep* {.preservesRecord: "path-step".} = object
`origin`*: Cap `origin`*: Resolve
`pathStep`*: PathStep[Cap] `pathStep`*: PathStep
`resolved`*: Resolved[Cap] `resolved`*: Resolved
BoundKind* {.pure.} = enum BoundKind* {.pure.} = enum
`bound`, `Rejected` `bound`, `Rejected`
BoundBound*[Cap] {.preservesRecord: "bound".} = object BoundBound* {.preservesRecord: "bound".} = object
`pathStep`*: PathStep[Cap] `pathStep`*: PathStep
`Bound`*[Cap] {.preservesOr.} = object `Bound`* {.preservesOr.} = object
case orKind*: BoundKind case orKind*: BoundKind
of BoundKind.`bound`: of BoundKind.`bound`:
`bound`*: BoundBound[Cap] `bound`*: BoundBound
of BoundKind.`Rejected`: of BoundKind.`Rejected`:
`rejected`*: Rejected[Cap] `rejected`*: Rejected
ForceDisconnect* {.preservesRecord: "force-disconnect".} = object ForceDisconnect* {.preservesRecord: "force-disconnect".} = object
Description*[Cap] = Preserve[Cap] Description* = Value
Rejected*[Cap] {.preservesRecord: "rejected".} = object Rejected* {.preservesRecord: "rejected".} = object
`detail`*: Preserve[Cap] `detail`*: Value
Resolve*[Cap] {.preservesRecord: "resolve".} = object Resolve* {.preservesRecord: "resolve".} = object
`step`*: Step[Cap] `step`*: Step
`observer`*: Cap `observer`*: Resolved
ResolvedKind* {.pure.} = enum ResolvedKind* {.pure.} = enum
`accepted`, `Rejected` `accepted`, `Rejected`
ResolvedAccepted*[Cap] {.preservesRecord: "accepted".} = object ResolvedAccepted* {.preservesRecord: "accepted".} = object
`responderSession`*: Cap `responderSession`*: Value
`Resolved`*[Cap] {.preservesOr.} = object `Resolved`* {.preservesOr.} = object
case orKind*: ResolvedKind case orKind*: ResolvedKind
of ResolvedKind.`accepted`: of ResolvedKind.`accepted`:
`accepted`*: ResolvedAccepted[Cap] `accepted`*: ResolvedAccepted
of ResolvedKind.`Rejected`: of ResolvedKind.`Rejected`:
`rejected`*: Rejected[Cap] `rejected`*: Rejected
TransportControl* = ForceDisconnect TransportControl* = ForceDisconnect
ResolvePath*[Cap] {.preservesRecord: "resolve-path".} = object ResolvePath* {.preservesRecord: "resolve-path".} = object
`route`*: Route[Cap] `route`*: Route
`addr`*: Preserve[Cap] `addr`*: Value
`control`*: Cap `control`*: TransportControl
`resolved`*: Resolved[Cap] `resolved`*: Resolved
PathStep*[Cap] = Preserve[Cap] PathStep* = Value
proc `$`*[Cap](x: Bind[Cap] | Route[Cap] | BindObserver[Cap] | proc `$`*(x: Bind | Route | BindObserver | TransportConnection |
TransportConnection[Cap] | ResolvedPathStep |
ResolvedPathStep[Cap] | Bound |
Bound[Cap] | ForceDisconnect |
Rejected[Cap] | Rejected |
Resolve[Cap] | Resolve |
Resolved[Cap] | Resolved |
ResolvePath[Cap]): string = TransportControl |
`$`(toPreserve(x, Cap)) ResolvePath): string =
`$`(toPreserves(x))
proc encode*[Cap](x: Bind[Cap] | Route[Cap] | BindObserver[Cap] | proc encode*(x: Bind | Route | BindObserver | TransportConnection |
TransportConnection[Cap] | ResolvedPathStep |
ResolvedPathStep[Cap] | Bound |
Bound[Cap] | ForceDisconnect |
Rejected[Cap] | Rejected |
Resolve[Cap] | Resolve |
Resolved[Cap] | Resolved |
ResolvePath[Cap]): seq[byte] = TransportControl |
encode(toPreserve(x, Cap)) ResolvePath): seq[byte] =
encode(toPreserves(x))
proc `$`*(x: ForceDisconnect | TransportControl): string =
`$`(toPreserve(x))
proc encode*(x: ForceDisconnect | TransportControl): seq[byte] =
encode(toPreserve(x))

176
src/syndicate/protocols/http.nim Normal file
View File

@ -0,0 +1,176 @@
import
preserves, std/tables
type
HostPatternKind* {.pure.} = enum
`host`, `any`
HostPatternHost* = string
`HostPattern`* {.preservesOr.} = object
case orKind*: HostPatternKind
of HostPatternKind.`host`:
`host`*: HostPatternHost
of HostPatternKind.`any`:
`any`* {.preservesLiteral: "#f".}: bool
HttpListener* {.preservesRecord: "http-listener".} = object
`port`*: BiggestInt
MethodPatternKind* {.pure.} = enum
`any`, `specific`
MethodPatternSpecific* = Symbol
`MethodPattern`* {.preservesOr.} = object
case orKind*: MethodPatternKind
of MethodPatternKind.`any`:
`any`* {.preservesLiteral: "#f".}: bool
of MethodPatternKind.`specific`:
`specific`*: MethodPatternSpecific
MimeType* = Symbol
QueryValueKind* {.pure.} = enum
`string`, `file`
QueryValueString* = string
QueryValueFile* {.preservesRecord: "file".} = object
`filename`*: string
`headers`*: Headers
`body`*: seq[byte]
`QueryValue`* {.preservesOr.} = object
case orKind*: QueryValueKind
of QueryValueKind.`string`:
`string`*: QueryValueString
of QueryValueKind.`file`:
`file`*: QueryValueFile
HttpRequest* {.preservesRecord: "http-request".} = object
`sequenceNumber`*: BiggestInt
`host`*: string
`port`*: BiggestInt
`method`*: Symbol
`path`*: seq[string]
`headers`*: Headers
`query`*: Table[Symbol, seq[QueryValue]]
`body`*: RequestBody
RequestBodyKind* {.pure.} = enum
`present`, `absent`
RequestBodyPresent* = seq[byte]
`RequestBody`* {.preservesOr.} = object
case orKind*: RequestBodyKind
of RequestBodyKind.`present`:
`present`*: RequestBodyPresent
of RequestBodyKind.`absent`:
`absent`* {.preservesLiteral: "#f".}: bool
Headers* = Table[Symbol, string]
HttpResponseKind* {.pure.} = enum
`status`, `header`, `chunk`, `done`
HttpResponseStatus* {.preservesRecord: "status".} = object
`code`*: BiggestInt
`message`*: string
HttpResponseHeader* {.preservesRecord: "header".} = object
`name`*: Symbol
`value`*: string
HttpResponseChunk* {.preservesRecord: "chunk".} = object
`chunk`*: Chunk
HttpResponseDone* {.preservesRecord: "done".} = object
`chunk`*: Chunk
`HttpResponse`* {.preservesOr.} = object
case orKind*: HttpResponseKind
of HttpResponseKind.`status`:
`status`*: HttpResponseStatus
of HttpResponseKind.`header`:
`header`*: HttpResponseHeader
of HttpResponseKind.`chunk`:
`chunk`*: HttpResponseChunk
of HttpResponseKind.`done`:
`done`*: HttpResponseDone
HttpService* {.preservesRecord: "http-service".} = object
`host`*: HostPattern
`port`*: BiggestInt
`method`*: MethodPattern
`path`*: PathPattern
HttpBinding* {.preservesRecord: "http-bind".} = object
`host`*: HostPattern
`port`*: BiggestInt
`method`*: MethodPattern
`path`*: PathPattern
`handler`* {.preservesEmbedded.}: HttpRequest
HttpContext* {.preservesRecord: "request".} = object
`req`*: HttpRequest
`res`* {.preservesEmbedded.}: HttpResponse
PathPatternElementKind* {.pure.} = enum
`label`, `wildcard`, `rest`
PathPatternElementLabel* = string
`PathPatternElement`* {.preservesOr.} = object
case orKind*: PathPatternElementKind
of PathPatternElementKind.`label`:
`label`*: PathPatternElementLabel
of PathPatternElementKind.`wildcard`:
`wildcard`* {.preservesLiteral: "_".}: bool
of PathPatternElementKind.`rest`:
`rest`* {.preservesLiteral: "|...|".}: bool
ChunkKind* {.pure.} = enum
`string`, `bytes`
ChunkString* = string
ChunkBytes* = seq[byte]
`Chunk`* {.preservesOr.} = object
case orKind*: ChunkKind
of ChunkKind.`string`:
`string`*: ChunkString
of ChunkKind.`bytes`:
`bytes`*: ChunkBytes
PathPattern* = seq[PathPatternElement]
proc `$`*(x: HostPattern | HttpListener | MethodPattern | MimeType | QueryValue |
HttpRequest |
RequestBody |
Headers |
HttpResponse |
HttpService |
HttpBinding |
HttpContext |
PathPatternElement |
Chunk |
PathPattern): string =
`$`(toPreserves(x))
proc encode*(x: HostPattern | HttpListener | MethodPattern | MimeType |
QueryValue |
HttpRequest |
RequestBody |
Headers |
HttpResponse |
HttpService |
HttpBinding |
HttpContext |
PathPatternElement |
Chunk |
PathPattern): seq[byte] =
encode(toPreserves(x))

105
src/syndicate/protocols/noise.nim Normal file
View File

@ -0,0 +1,105 @@
import
preserves, std/tables
type
NoiseDescriptionDetail* = NoiseServiceSpec
NoisePreSharedKeysKind* {.pure.} = enum
`present`, `invalid`, `absent`
NoisePreSharedKeysPresent* {.preservesDictionary.} = object
`preSharedKeys`*: seq[seq[byte]]
NoisePreSharedKeysInvalid* {.preservesDictionary.} = object
`preSharedKeys`*: Value
NoisePreSharedKeysAbsent* {.preservesDictionary.} = object
`NoisePreSharedKeys`* {.preservesOr.} = object
case orKind*: NoisePreSharedKeysKind
of NoisePreSharedKeysKind.`present`:
`present`*: NoisePreSharedKeysPresent
of NoisePreSharedKeysKind.`invalid`:
`invalid`*: NoisePreSharedKeysInvalid
of NoisePreSharedKeysKind.`absent`:
`absent`*: NoisePreSharedKeysAbsent
SecretKeyFieldKind* {.pure.} = enum
`present`, `invalid`, `absent`
SecretKeyFieldPresent* {.preservesDictionary.} = object
`secretKey`*: seq[byte]
SecretKeyFieldInvalid* {.preservesDictionary.} = object
`secretKey`*: Value
SecretKeyFieldAbsent* {.preservesDictionary.} = object
`SecretKeyField`* {.preservesOr.} = object
case orKind*: SecretKeyFieldKind
of SecretKeyFieldKind.`present`:
`present`*: SecretKeyFieldPresent
of SecretKeyFieldKind.`invalid`:
`invalid`*: SecretKeyFieldInvalid
of SecretKeyFieldKind.`absent`:
`absent`*: SecretKeyFieldAbsent
NoiseProtocolKind* {.pure.} = enum
`present`, `invalid`, `absent`
NoiseProtocolPresent* {.preservesDictionary.} = object
`protocol`*: string
NoiseProtocolInvalid* {.preservesDictionary.} = object
`protocol`*: Value
NoiseProtocolAbsent* {.preservesDictionary.} = object
`NoiseProtocol`* {.preservesOr.} = object
case orKind*: NoiseProtocolKind
of NoiseProtocolKind.`present`:
`present`*: NoiseProtocolPresent
of NoiseProtocolKind.`invalid`:
`invalid`*: NoiseProtocolInvalid
of NoiseProtocolKind.`absent`:
`absent`*: NoiseProtocolAbsent
NoisePathStepDetail* = NoiseSpec
`NoiseServiceSpec`* = Table[Symbol, Value]
ServiceSelector* = Value
NoiseStepDetail* = ServiceSelector
`NoiseSpec`* = Table[Symbol, Value]
PacketKind* {.pure.} = enum
`complete`, `fragmented`
PacketComplete* = seq[byte]
PacketFragmented* = seq[seq[byte]]
`Packet`* {.preservesOr.} = object
case orKind*: PacketKind
of PacketKind.`complete`:
`complete`*: PacketComplete
of PacketKind.`fragmented`:
`fragmented`*: PacketFragmented
proc `$`*(x: NoiseDescriptionDetail | NoisePreSharedKeys | SecretKeyField |
NoiseProtocol |
NoisePathStepDetail |
NoiseServiceSpec |
NoiseSpec |
Packet): string =
`$`(toPreserves(x))
proc encode*(x: NoiseDescriptionDetail | NoisePreSharedKeys | SecretKeyField |
NoiseProtocol |
NoisePathStepDetail |
NoiseServiceSpec |
NoiseSpec |
Packet): seq[byte] =
encode(toPreserves(x))

10
src/syndicate/protocols/protocol.nim
View File

@ -5,7 +5,7 @@ import
type type
Error* {.preservesRecord: "error".} = object Error* {.preservesRecord: "error".} = object
`message`*: string `message`*: string
`detail`*: Preserve[void] `detail`*: Value
Turn* = seq[TurnEvent] Turn* = seq[TurnEvent]
Message* {.preservesRecord: "message".} = object Message* {.preservesRecord: "message".} = object
@ -18,7 +18,7 @@ type
`assertion`*: Assertion `assertion`*: Assertion
`handle`*: Handle `handle`*: Handle
Extension* = Preserve[void] Extension* = Value
Sync* {.preservesRecord: "sync".} = object Sync* {.preservesRecord: "sync".} = object
`peer`* {.preservesLiteral: "#!#t".}: tuple[] `peer`* {.preservesLiteral: "#!#t".}: tuple[]
@ -27,7 +27,7 @@ type
`event`*: Event `event`*: Event
Oid* = BiggestInt Oid* = BiggestInt
Assertion* = Preserve[void] Assertion* = Value
Handle* = BiggestInt Handle* = BiggestInt
PacketKind* {.pure.} = enum PacketKind* {.pure.} = enum
`Turn`, `Error`, `Extension` `Turn`, `Error`, `Extension`
@ -64,11 +64,11 @@ proc `$`*(x: Error | Turn | Message | Retract | Assert | Sync | TurnEvent | Oid
Handle | Handle |
Packet | Packet |
Event): string = Event): string =
`$`(toPreserve(x)) `$`(toPreserves(x))
proc encode*(x: Error | Turn | Message | Retract | Assert | Sync | TurnEvent | proc encode*(x: Error | Turn | Message | Retract | Assert | Sync | TurnEvent |
Oid | Oid |
Handle | Handle |
Packet | Packet |
Event): seq[byte] = Event): seq[byte] =
encode(toPreserve(x)) encode(toPreserves(x))

58
src/syndicate/protocols/service.nim
View File

@ -5,8 +5,8 @@ import
type type
StateKind* {.pure.} = enum StateKind* {.pure.} = enum
`started`, `ready`, `failed`, `complete`, `userDefined` `started`, `ready`, `failed`, `complete`, `userDefined`
StateUserDefined*[Cap] = Preserve[Cap] StateUserDefined* = Value
`State`*[Cap] {.preservesOr.} = object `State`* {.preservesOr.} = object
case orKind*: StateKind case orKind*: StateKind
of StateKind.`started`: of StateKind.`started`:
`started`* {.preservesLiteral: "started".}: bool `started`* {.preservesLiteral: "started".}: bool
@ -21,40 +21,38 @@ type
`complete`* {.preservesLiteral: "complete".}: bool `complete`* {.preservesLiteral: "complete".}: bool
of StateKind.`userDefined`: of StateKind.`userDefined`:
`userdefined`*: StateUserDefined[Cap] `userdefined`*: StateUserDefined
ServiceObject*[Cap] {.preservesRecord: "service-object".} = object ServiceObject* {.preservesRecord: "service-object".} = object
`serviceName`*: Preserve[Cap] `serviceName`*: Value
`object`*: Preserve[Cap] `object`*: Value
RequireService*[Cap] {.preservesRecord: "require-service".} = object RequireService* {.preservesRecord: "require-service".} = object
`serviceName`*: Preserve[Cap] `serviceName`*: Value
RestartService*[Cap] {.preservesRecord: "restart-service".} = object RestartService* {.preservesRecord: "restart-service".} = object
`serviceName`*: Preserve[Cap] `serviceName`*: Value
RunService*[Cap] {.preservesRecord: "run-service".} = object RunService* {.preservesRecord: "run-service".} = object
`serviceName`*: Preserve[Cap] `serviceName`*: Value
ServiceState*[Cap] {.preservesRecord: "service-state".} = object ServiceState* {.preservesRecord: "service-state".} = object
`serviceName`*: Preserve[Cap] `serviceName`*: Value
`state`*: State[Cap] `state`*: State
ServiceDependency*[Cap] {.preservesRecord: "depends-on".} = object ServiceDependency* {.preservesRecord: "depends-on".} = object
`depender`*: Preserve[Cap] `depender`*: Value
`dependee`*: ServiceState[Cap] `dependee`*: ServiceState
proc `$`*[Cap](x: State[Cap] | ServiceObject[Cap] | RequireService[Cap] | proc `$`*(x: State | ServiceObject | RequireService | RestartService |
RestartService[Cap] | RunService |
RunService[Cap] | ServiceState |
ServiceState[Cap] | ServiceDependency): string =
ServiceDependency[Cap]): string = `$`(toPreserves(x))
`$`(toPreserve(x, Cap))
proc encode*[Cap](x: State[Cap] | ServiceObject[Cap] | RequireService[Cap] | proc encode*(x: State | ServiceObject | RequireService | RestartService |
RestartService[Cap] | RunService |
RunService[Cap] | ServiceState |
ServiceState[Cap] | ServiceDependency): seq[byte] =
ServiceDependency[Cap]): seq[byte] = encode(toPreserves(x))
encode(toPreserve(x, Cap))

84
src/syndicate/protocols/stream.nim
View File

@ -18,76 +18,76 @@ type
StreamError* {.preservesRecord: "error".} = object StreamError* {.preservesRecord: "error".} = object
`message`*: string `message`*: string
StreamListenerError*[Cap] {.preservesRecord: "stream-listener-error".} = object StreamListenerError* {.preservesRecord: "stream-listener-error".} = object
`spec`*: Preserve[Cap] `spec`*: Value
`message`*: string `message`*: string
StreamConnection*[Cap] {.preservesRecord: "stream-connection".} = object StreamConnection* {.preservesRecord: "stream-connection".} = object
`source`*: Cap `source`*: Source
`sink`*: Cap `sink`*: Sink
`spec`*: Preserve[Cap] `spec`*: Value
`LineMode`* {.preservesOr, pure.} = enum `LineMode`* {.preservesOr, pure.} = enum
`lf`, `crlf` `lf`, `crlf`
SourceKind* {.pure.} = enum SourceKind* {.pure.} = enum
`sink`, `StreamError`, `credit` `sink`, `StreamError`, `credit`
SourceSink*[Cap] {.preservesRecord: "sink".} = object SourceSink* {.preservesRecord: "sink".} = object
`controller`*: Cap `controller`*: Sink
SourceCredit*[Cap] {.preservesRecord: "credit".} = object SourceCredit* {.preservesRecord: "credit".} = object
`amount`*: CreditAmount `amount`*: CreditAmount
`mode`*: Mode[Cap] `mode`*: Mode
`Source`*[Cap] {.preservesOr.} = object `Source`* {.acyclic, preservesOr.} = ref object
case orKind*: SourceKind case orKind*: SourceKind
of SourceKind.`sink`: of SourceKind.`sink`:
`sink`*: SourceSink[Cap] `sink`*: SourceSink
of SourceKind.`StreamError`: of SourceKind.`StreamError`:
`streamerror`*: StreamError `streamerror`*: StreamError
of SourceKind.`credit`: of SourceKind.`credit`:
`credit`*: SourceCredit[Cap] `credit`*: SourceCredit
SinkKind* {.pure.} = enum SinkKind* {.pure.} = enum
`source`, `StreamError`, `data`, `eof` `source`, `StreamError`, `data`, `eof`
SinkSource*[Cap] {.preservesRecord: "source".} = object SinkSource* {.preservesRecord: "source".} = object
`controller`*: Cap `controller`*: Source
SinkData*[Cap] {.preservesRecord: "data".} = object SinkData* {.preservesRecord: "data".} = object
`payload`*: Preserve[Cap] `payload`*: Value
`mode`*: Mode[Cap] `mode`*: Mode
SinkEof* {.preservesRecord: "eof".} = object SinkEof* {.preservesRecord: "eof".} = object
`Sink`*[Cap] {.preservesOr.} = object `Sink`* {.acyclic, preservesOr.} = ref object
case orKind*: SinkKind case orKind*: SinkKind
of SinkKind.`source`: of SinkKind.`source`:
`source`*: SinkSource[Cap] `source`*: SinkSource
of SinkKind.`StreamError`: of SinkKind.`StreamError`:
`streamerror`*: StreamError `streamerror`*: StreamError
of SinkKind.`data`: of SinkKind.`data`:
`data`*: SinkData[Cap] `data`*: SinkData
of SinkKind.`eof`: of SinkKind.`eof`:
`eof`*: SinkEof `eof`*: SinkEof
StreamListenerReady*[Cap] {.preservesRecord: "stream-listener-ready".} = object StreamListenerReady* {.preservesRecord: "stream-listener-ready".} = object
`spec`*: Preserve[Cap] `spec`*: Value
ModeKind* {.pure.} = enum ModeKind* {.pure.} = enum
`bytes`, `lines`, `packet`, `object` `bytes`, `lines`, `packet`, `object`
ModePacket* {.preservesRecord: "packet".} = object ModePacket* {.preservesRecord: "packet".} = object
`size`*: BiggestInt `size`*: BiggestInt
ModeObject*[Cap] {.preservesRecord: "object".} = object ModeObject* {.preservesRecord: "object".} = object
`description`*: Preserve[Cap] `description`*: Value
`Mode`*[Cap] {.preservesOr.} = object `Mode`* {.preservesOr.} = object
case orKind*: ModeKind case orKind*: ModeKind
of ModeKind.`bytes`: of ModeKind.`bytes`:
`bytes`* {.preservesLiteral: "bytes".}: bool `bytes`* {.preservesLiteral: "bytes".}: bool
@ -99,24 +99,20 @@ type
`packet`*: ModePacket `packet`*: ModePacket
of ModeKind.`object`: of ModeKind.`object`:
`object`*: ModeObject[Cap] `object`*: ModeObject
proc `$`*[Cap](x: StreamListenerError[Cap] | StreamConnection[Cap] | Source[Cap] | proc `$`*(x: CreditAmount | StreamError | StreamListenerError | StreamConnection |
Sink[Cap] | Source |
StreamListenerReady[Cap] | Sink |
Mode[Cap]): string = StreamListenerReady |
`$`(toPreserve(x, Cap)) Mode): string =
`$`(toPreserves(x))
proc encode*[Cap](x: StreamListenerError[Cap] | StreamConnection[Cap] | proc encode*(x: CreditAmount | StreamError | StreamListenerError |
Source[Cap] | StreamConnection |
Sink[Cap] | Source |
StreamListenerReady[Cap] | Sink |
Mode[Cap]): seq[byte] = StreamListenerReady |
encode(toPreserve(x, Cap)) Mode): seq[byte] =
encode(toPreserves(x))
proc `$`*(x: CreditAmount | StreamError): string =
`$`(toPreserve(x))
proc encode*(x: CreditAmount | StreamError): seq[byte] =
encode(toPreserve(x))

227
src/syndicate/protocols/sturdy.nim
View File

@ -5,100 +5,100 @@ import
type type
PCompoundKind* {.pure.} = enum PCompoundKind* {.pure.} = enum
`rec`, `arr`, `dict` `rec`, `arr`, `dict`
PCompoundRec*[Cap] {.acyclic, preservesRecord: "rec".} = ref object PCompoundRec* {.preservesRecord: "rec".} = object
`label`*: Preserve[Cap] `label`*: Value
`fields`*: seq[Pattern[Cap]] `fields`*: seq[Pattern]
PCompoundArr*[Cap] {.acyclic, preservesRecord: "arr".} = ref object PCompoundArr* {.preservesRecord: "arr".} = object
`items`*: seq[Pattern[Cap]] `items`*: seq[Pattern]
PCompoundDict*[Cap] {.acyclic, preservesRecord: "dict".} = ref object PCompoundDict* {.preservesRecord: "dict".} = object
`entries`*: Table[Preserve[Cap], Pattern[Cap]] `entries`*: Table[Value, Pattern]
`PCompound`*[Cap] {.acyclic, preservesOr.} = ref object `PCompound`* {.preservesOr.} = object
case orKind*: PCompoundKind case orKind*: PCompoundKind
of PCompoundKind.`rec`: of PCompoundKind.`rec`:
`rec`*: PCompoundRec[Cap] `rec`*: PCompoundRec
of PCompoundKind.`arr`: of PCompoundKind.`arr`:
`arr`*: PCompoundArr[Cap] `arr`*: PCompoundArr
of PCompoundKind.`dict`: of PCompoundKind.`dict`:
`dict`*: PCompoundDict[Cap] `dict`*: PCompoundDict
Reject*[Cap] {.acyclic, preservesRecord: "reject".} = ref object Reject* {.preservesRecord: "reject".} = object
`pattern`*: Pattern[Cap] `pattern`*: Pattern
CaveatsFieldKind* {.pure.} = enum CaveatsFieldKind* {.pure.} = enum
`present`, `invalid`, `absent` `present`, `invalid`, `absent`
CaveatsFieldPresent*[Cap] {.acyclic, preservesDictionary.} = ref object CaveatsFieldPresent* {.preservesDictionary.} = object
`caveats`*: seq[Caveat[Cap]] `caveats`*: seq[Caveat]
CaveatsFieldInvalid*[Cap] {.preservesDictionary.} = object CaveatsFieldInvalid* {.preservesDictionary.} = object
`caveats`*: Preserve[Cap] `caveats`*: Value
CaveatsFieldAbsent* {.preservesDictionary.} = object CaveatsFieldAbsent* {.preservesDictionary.} = object
`CaveatsField`*[Cap] {.acyclic, preservesOr.} = ref object `CaveatsField`* {.preservesOr.} = object
case orKind*: CaveatsFieldKind case orKind*: CaveatsFieldKind
of CaveatsFieldKind.`present`: of CaveatsFieldKind.`present`:
`present`*: CaveatsFieldPresent[Cap] `present`*: CaveatsFieldPresent
of CaveatsFieldKind.`invalid`: of CaveatsFieldKind.`invalid`:
`invalid`*: CaveatsFieldInvalid[Cap] `invalid`*: CaveatsFieldInvalid
of CaveatsFieldKind.`absent`: of CaveatsFieldKind.`absent`:
`absent`*: CaveatsFieldAbsent `absent`*: CaveatsFieldAbsent
SturdyDescriptionDetail*[Cap] {.preservesDictionary.} = object SturdyDescriptionDetail* {.preservesDictionary.} = object
`key`*: seq[byte] `key`*: seq[byte]
`oid`*: Preserve[Cap] `oid`*: Value
PAnd*[Cap] {.acyclic, preservesRecord: "and".} = ref object PAnd* {.preservesRecord: "and".} = object
`patterns`*: seq[Pattern[Cap]] `patterns`*: seq[Pattern]
SturdyStepDetail*[Cap] = Parameters[Cap] SturdyStepDetail* = Parameters
Rewrite*[Cap] {.acyclic, preservesRecord: "rewrite".} = ref object Rewrite* {.preservesRecord: "rewrite".} = object
`pattern`*: Pattern[Cap] `pattern`*: Pattern
`template`*: Template[Cap] `template`*: Template
Parameters*[Cap] = Preserve[Cap] `Parameters`* = Table[Symbol, Value]
TRef* {.preservesRecord: "ref".} = object TRef* {.preservesRecord: "ref".} = object
`binding`*: BiggestInt `binding`*: BiggestInt
PBind*[Cap] {.acyclic, preservesRecord: "bind".} = ref object PBind* {.preservesRecord: "bind".} = object
`pattern`*: Pattern[Cap] `pattern`*: Pattern
Lit*[Cap] {.preservesRecord: "lit".} = object Lit* {.preservesRecord: "lit".} = object
`value`*: Preserve[Cap] `value`*: Value
TCompoundKind* {.pure.} = enum TCompoundKind* {.pure.} = enum
`rec`, `arr`, `dict` `rec`, `arr`, `dict`
TCompoundRec*[Cap] {.acyclic, preservesRecord: "rec".} = ref object TCompoundRec* {.preservesRecord: "rec".} = object
`label`*: Preserve[Cap] `label`*: Value
`fields`*: seq[Template[Cap]] `fields`*: seq[Template]
TCompoundArr*[Cap] {.acyclic, preservesRecord: "arr".} = ref object TCompoundArr* {.preservesRecord: "arr".} = object
`items`*: seq[Template[Cap]] `items`*: seq[Template]
TCompoundDict*[Cap] {.acyclic, preservesRecord: "dict".} = ref object TCompoundDict* {.preservesRecord: "dict".} = object
`entries`*: Table[Preserve[Cap], Template[Cap]] `entries`*: Table[Value, Template]
`TCompound`*[Cap] {.acyclic, preservesOr.} = ref object `TCompound`* {.preservesOr.} = object
case orKind*: TCompoundKind case orKind*: TCompoundKind
of TCompoundKind.`rec`: of TCompoundKind.`rec`:
`rec`*: TCompoundRec[Cap] `rec`*: TCompoundRec
of TCompoundKind.`arr`: of TCompoundKind.`arr`:
`arr`*: TCompoundArr[Cap] `arr`*: TCompoundArr
of TCompoundKind.`dict`: of TCompoundKind.`dict`:
`dict`*: TCompoundDict[Cap] `dict`*: TCompoundDict
SturdyPathStepDetail*[Cap] = Parameters[Cap] SturdyPathStepDetail* = Parameters
`PAtom`* {.preservesOr, pure.} = enum `PAtom`* {.preservesOr, pure.} = enum
`Boolean`, `Float`, `Double`, `SignedInteger`, `String`, `ByteString`, `Boolean`, `Float`, `Double`, `SignedInteger`, `String`, `ByteString`,
`Symbol` `Symbol`
@ -106,44 +106,44 @@ type
TemplateKind* {.pure.} = enum TemplateKind* {.pure.} = enum
`TAttenuate`, `TRef`, `Lit`, `TCompound` `TAttenuate`, `TRef`, `Lit`, `TCompound`
`Template`*[Cap] {.acyclic, preservesOr.} = ref object `Template`* {.acyclic, preservesOr.} = ref object
case orKind*: TemplateKind case orKind*: TemplateKind
of TemplateKind.`TAttenuate`: of TemplateKind.`TAttenuate`:
`tattenuate`*: TAttenuate[Cap] `tattenuate`*: TAttenuate
of TemplateKind.`TRef`: of TemplateKind.`TRef`:
`tref`*: TRef `tref`*: TRef
of TemplateKind.`Lit`: of TemplateKind.`Lit`:
`lit`*: Lit[Cap] `lit`*: Lit
of TemplateKind.`TCompound`: of TemplateKind.`TCompound`:
`tcompound`*: TCompound[Cap] `tcompound`*: TCompound
CaveatKind* {.pure.} = enum CaveatKind* {.pure.} = enum
`Rewrite`, `Alts`, `Reject`, `unknown` `Rewrite`, `Alts`, `Reject`, `unknown`
CaveatUnknown*[Cap] = Preserve[Cap] CaveatUnknown* = Value
`Caveat`*[Cap] {.acyclic, preservesOr.} = ref object `Caveat`* {.preservesOr.} = object
case orKind*: CaveatKind case orKind*: CaveatKind
of CaveatKind.`Rewrite`: of CaveatKind.`Rewrite`:
`rewrite`*: Rewrite[Cap] `rewrite`*: Rewrite
of CaveatKind.`Alts`: of CaveatKind.`Alts`:
`alts`*: Alts[Cap] `alts`*: Alts
of CaveatKind.`Reject`: of CaveatKind.`Reject`:
`reject`*: Reject[Cap] `reject`*: Reject
of CaveatKind.`unknown`: of CaveatKind.`unknown`:
`unknown`*: CaveatUnknown[Cap] `unknown`*: CaveatUnknown
PNot*[Cap] {.acyclic, preservesRecord: "not".} = ref object PNot* {.preservesRecord: "not".} = object
`pattern`*: Pattern[Cap] `pattern`*: Pattern
SturdyRef*[Cap] {.acyclic, preservesRecord: "ref".} = ref object SturdyRef* {.preservesRecord: "ref".} = object
`parameters`*: Parameters[Cap] `parameters`*: Parameters
WireRefKind* {.pure.} = enum WireRefKind* {.pure.} = enum
`mine`, `yours` `mine`, `yours`
@ -151,32 +151,32 @@ type
`field0`* {.preservesLiteral: "0".}: tuple[] `field0`* {.preservesLiteral: "0".}: tuple[]
`oid`*: Oid `oid`*: Oid
WireRefYours*[Cap] {.acyclic, preservesTuple.} = ref object WireRefYours* {.preservesTuple.} = object
`field0`* {.preservesLiteral: "1".}: tuple[] `field0`* {.preservesLiteral: "1".}: tuple[]
`oid`*: Oid `oid`*: Oid
`attenuation`* {.preservesTupleTail.}: seq[Caveat[Cap]] `attenuation`* {.preservesTupleTail.}: seq[Caveat]
`WireRef`*[Cap] {.acyclic, preservesOr.} = ref object `WireRef`* {.preservesOr.} = object
case orKind*: WireRefKind case orKind*: WireRefKind
of WireRefKind.`mine`: of WireRefKind.`mine`:
`mine`*: WireRefMine `mine`*: WireRefMine
of WireRefKind.`yours`: of WireRefKind.`yours`:
`yours`*: WireRefYours[Cap] `yours`*: WireRefYours
TAttenuate*[Cap] {.acyclic, preservesRecord: "attenuate".} = ref object TAttenuate* {.preservesRecord: "attenuate".} = object
`template`*: Template[Cap] `template`*: Template
`attenuation`*: seq[Caveat[Cap]] `attenuation`*: seq[Caveat]
Oid* = BiggestInt Oid* = BiggestInt
Alts*[Cap] {.acyclic, preservesRecord: "or".} = ref object Alts* {.preservesRecord: "or".} = object
`alternatives`*: seq[Rewrite[Cap]] `alternatives`*: seq[Rewrite]
PatternKind* {.pure.} = enum PatternKind* {.pure.} = enum
`PDiscard`, `PAtom`, `PEmbedded`, `PBind`, `PAnd`, `PNot`, `Lit`, `PDiscard`, `PAtom`, `PEmbedded`, `PBind`, `PAnd`, `PNot`, `Lit`,
`PCompound` `PCompound`
`Pattern`*[Cap] {.acyclic, preservesOr.} = ref object `Pattern`* {.acyclic, preservesOr.} = ref object
case orKind*: PatternKind case orKind*: PatternKind
of PatternKind.`PDiscard`: of PatternKind.`PDiscard`:
`pdiscard`*: PDiscard `pdiscard`*: PDiscard
@ -188,57 +188,60 @@ type
`pembedded`* {.preservesLiteral: "Embedded".}: bool `pembedded`* {.preservesLiteral: "Embedded".}: bool
of PatternKind.`PBind`: of PatternKind.`PBind`:
`pbind`*: PBind[Cap] `pbind`*: PBind
of PatternKind.`PAnd`: of PatternKind.`PAnd`:
`pand`*: PAnd[Cap] `pand`*: PAnd
of PatternKind.`PNot`: of PatternKind.`PNot`:
`pnot`*: PNot[Cap] `pnot`*: PNot
of PatternKind.`Lit`: of PatternKind.`Lit`:
`lit`*: Lit[Cap] `lit`*: Lit
of PatternKind.`PCompound`: of PatternKind.`PCompound`:
`pcompound`*: PCompound[Cap] `pcompound`*: PCompound
proc `$`*[Cap](x: PCompound[Cap] | Reject[Cap] | CaveatsField[Cap] | proc `$`*(x: PCompound | Reject | CaveatsField | SturdyDescriptionDetail | PAnd |
SturdyDescriptionDetail[Cap] | SturdyStepDetail |
PAnd[Cap] | Rewrite |
Rewrite[Cap] | Parameters |
PBind[Cap] | TRef |
Lit[Cap] | PBind |
TCompound[Cap] | Lit |
Template[Cap] | TCompound |
Caveat[Cap] | SturdyPathStepDetail |
PNot[Cap] | PDiscard |
SturdyRef[Cap] | Template |
WireRef[Cap] | Caveat |
TAttenuate[Cap] | PNot |
Alts[Cap] | SturdyRef |
Pattern[Cap]): string = WireRef |
`$`(toPreserve(x, Cap)) TAttenuate |
Oid |
Alts |
Pattern): string =
`$`(toPreserves(x))
proc encode*[Cap](x: PCompound[Cap] | Reject[Cap] | CaveatsField[Cap] | proc encode*(x: PCompound | Reject | CaveatsField | SturdyDescriptionDetail |
SturdyDescriptionDetail[Cap] | PAnd |
PAnd[Cap] | SturdyStepDetail |
Rewrite[Cap] | Rewrite |
PBind[Cap] | Parameters |
Lit[Cap] | TRef |
TCompound[Cap] | PBind |
Template[Cap] | Lit |
Caveat[Cap] | TCompound |
PNot[Cap] | SturdyPathStepDetail |
SturdyRef[Cap] | PDiscard |
WireRef[Cap] | Template |
TAttenuate[Cap] | Caveat |
Alts[Cap] | PNot |
Pattern[Cap]): seq[byte] = SturdyRef |
encode(toPreserve(x, Cap)) WireRef |
TAttenuate |
proc `$`*(x: TRef | PDiscard | Oid): string = Oid |
`$`(toPreserve(x)) Alts |
Pattern): seq[byte] =
proc encode*(x: TRef | PDiscard | Oid): seq[byte] = encode(toPreserves(x))
encode(toPreserve(x))

18
src/syndicate/protocols/tcp.nim
View File

@ -7,8 +7,8 @@ type
`host`*: string `host`*: string
`port`*: BiggestInt `port`*: BiggestInt
TcpPeerInfo*[Cap] {.preservesRecord: "tcp-peer".} = object TcpPeerInfo* {.preservesRecord: "tcp-peer".} = object
`handle`*: Cap `handle`*: Value
`local`*: TcpLocal `local`*: TcpLocal
`remote`*: TcpRemote `remote`*: TcpRemote
@ -16,14 +16,8 @@ type
`host`*: string `host`*: string
`port`*: BiggestInt `port`*: BiggestInt
proc `$`*[Cap](x: TcpPeerInfo[Cap]): string = proc `$`*(x: TcpLocal | TcpPeerInfo | TcpRemote): string =
`$`(toPreserve(x, Cap)) `$`(toPreserves(x))
proc encode*[Cap](x: TcpPeerInfo[Cap]): seq[byte] = proc encode*(x: TcpLocal | TcpPeerInfo | TcpRemote): seq[byte] =
encode(toPreserve(x, Cap)) encode(toPreserves(x))
proc `$`*(x: TcpLocal | TcpRemote): string =
`$`(toPreserve(x))
proc encode*(x: TcpLocal | TcpRemote): seq[byte] =
encode(toPreserve(x))

8
src/syndicate/protocols/timer.nim
View File

@ -4,11 +4,11 @@ import
type type
TimerExpired* {.preservesRecord: "timer-expired".} = object TimerExpired* {.preservesRecord: "timer-expired".} = object
`label`*: Preserve[void] `label`*: Value
`seconds`*: float64 `seconds`*: float64
SetTimer* {.preservesRecord: "set-timer".} = object SetTimer* {.preservesRecord: "set-timer".} = object
`label`*: Preserve[void] `label`*: Value
`seconds`*: float64 `seconds`*: float64
`kind`*: TimerKind `kind`*: TimerKind
@ -18,7 +18,7 @@ type
`seconds`*: float64 `seconds`*: float64
proc `$`*(x: TimerExpired | SetTimer | LaterThan): string = proc `$`*(x: TimerExpired | SetTimer | LaterThan): string =
`$`(toPreserve(x)) `$`(toPreserves(x))
proc encode*(x: TimerExpired | SetTimer | LaterThan): seq[byte] = proc encode*(x: TimerExpired | SetTimer | LaterThan): seq[byte] =
encode(toPreserve(x)) encode(toPreserves(x))

226
src/syndicate/protocols/trace.nim
View File

@ -3,160 +3,160 @@ import
preserves, protocol preserves, protocol
type type
TargetedTurnEvent*[Cap] {.preservesRecord: "event".} = object TargetedTurnEvent* {.preservesRecord: "event".} = object
`target`*: Target[Cap] `target`*: Target
`detail`*: TurnEvent[Cap] `detail`*: TurnEvent
`LinkedTaskReleaseReason`* {.preservesOr, pure.} = enum `LinkedTaskReleaseReason`* {.preservesOr, pure.} = enum
`cancelled`, `normal` `cancelled`, `normal`
TurnId*[Cap] = Preserve[Cap] TurnId* = Value
AssertionDescriptionKind* {.pure.} = enum AssertionDescriptionKind* {.pure.} = enum
`value`, `opaque` `value`, `opaque`
AssertionDescriptionValue*[Cap] {.preservesRecord: "value".} = object AssertionDescriptionValue* {.preservesRecord: "value".} = object
`value`*: Preserve[Cap] `value`*: Value
AssertionDescriptionOpaque*[Cap] {.preservesRecord: "opaque".} = object AssertionDescriptionOpaque* {.preservesRecord: "opaque".} = object
`description`*: Preserve[Cap] `description`*: Value
`AssertionDescription`*[Cap] {.preservesOr.} = object `AssertionDescription`* {.preservesOr.} = object
case orKind*: AssertionDescriptionKind case orKind*: AssertionDescriptionKind
of AssertionDescriptionKind.`value`: of AssertionDescriptionKind.`value`:
`value`*: AssertionDescriptionValue[Cap] `value`*: AssertionDescriptionValue
of AssertionDescriptionKind.`opaque`: of AssertionDescriptionKind.`opaque`:
`opaque`*: AssertionDescriptionOpaque[Cap] `opaque`*: AssertionDescriptionOpaque
NameKind* {.pure.} = enum NameKind* {.pure.} = enum
`anonymous`, `named` `anonymous`, `named`
NameAnonymous* {.preservesRecord: "anonymous".} = object NameAnonymous* {.preservesRecord: "anonymous".} = object
NameNamed*[Cap] {.preservesRecord: "named".} = object NameNamed* {.preservesRecord: "named".} = object
`name`*: Preserve[Cap] `name`*: Value
`Name`*[Cap] {.preservesOr.} = object `Name`* {.preservesOr.} = object
case orKind*: NameKind case orKind*: NameKind
of NameKind.`anonymous`: of NameKind.`anonymous`:
`anonymous`*: NameAnonymous `anonymous`*: NameAnonymous
of NameKind.`named`: of NameKind.`named`:
`named`*: NameNamed[Cap] `named`*: NameNamed
ActorId*[Cap] = Preserve[Cap] ActorId* = Value
FacetId*[Cap] = Preserve[Cap] FacetId* = Value
`FacetStopReason`* {.preservesOr, pure.} = enum `FacetStopReason`* {.preservesOr, pure.} = enum
`explicitAction`, `inert`, `parentStopping`, `actorStopping` `explicitAction`, `inert`, `parentStopping`, `actorStopping`
TaskId*[Cap] = Preserve[Cap] TaskId* = Value
ActorActivationKind* {.pure.} = enum ActorActivationKind* {.pure.} = enum
`start`, `turn`, `stop` `start`, `turn`, `stop`
ActorActivationStart*[Cap] {.preservesRecord: "start".} = object ActorActivationStart* {.preservesRecord: "start".} = object
`actorName`*: Name[Cap] `actorName`*: Name
ActorActivationStop* {.preservesRecord: "stop".} = object ActorActivationStop* {.preservesRecord: "stop".} = object
`status`*: ExitStatus `status`*: ExitStatus
`ActorActivation`*[Cap] {.preservesOr.} = object `ActorActivation`* {.preservesOr.} = object
case orKind*: ActorActivationKind case orKind*: ActorActivationKind
of ActorActivationKind.`start`: of ActorActivationKind.`start`:
`start`*: ActorActivationStart[Cap] `start`*: ActorActivationStart
of ActorActivationKind.`turn`: of ActorActivationKind.`turn`:
`turn`*: TurnDescription[Cap] `turn`*: TurnDescription
of ActorActivationKind.`stop`: of ActorActivationKind.`stop`:
`stop`*: ActorActivationStop `stop`*: ActorActivationStop
Target*[Cap] {.preservesRecord: "entity".} = object Target* {.preservesRecord: "entity".} = object
`actor`*: ActorId[Cap] `actor`*: ActorId
`facet`*: FacetId[Cap] `facet`*: FacetId
`oid`*: Oid[Cap] `oid`*: Oid
TurnCauseKind* {.pure.} = enum TurnCauseKind* {.pure.} = enum
`turn`, `cleanup`, `linkedTaskRelease`, `periodicActivation`, `delay`, `turn`, `cleanup`, `linkedTaskRelease`, `periodicActivation`, `delay`,
`external` `external`
TurnCauseTurn*[Cap] {.preservesRecord: "caused-by".} = object TurnCauseTurn* {.preservesRecord: "caused-by".} = object
`id`*: TurnId[Cap] `id`*: TurnId
TurnCauseCleanup* {.preservesRecord: "cleanup".} = object TurnCauseCleanup* {.preservesRecord: "cleanup".} = object
TurnCauseLinkedTaskRelease*[Cap] {.preservesRecord: "linked-task-release".} = object TurnCauseLinkedTaskRelease* {.preservesRecord: "linked-task-release".} = object
`id`*: TaskId[Cap] `id`*: TaskId
`reason`*: LinkedTaskReleaseReason `reason`*: LinkedTaskReleaseReason
TurnCausePeriodicActivation* {.preservesRecord: "periodic-activation".} = object TurnCausePeriodicActivation* {.preservesRecord: "periodic-activation".} = object
`period`*: float64 `period`*: float64
TurnCauseDelay*[Cap] {.preservesRecord: "delay".} = object TurnCauseDelay* {.preservesRecord: "delay".} = object
`causingTurn`*: TurnId[Cap] `causingTurn`*: TurnId
`amount`*: float64 `amount`*: float64
TurnCauseExternal*[Cap] {.preservesRecord: "external".} = object TurnCauseExternal* {.preservesRecord: "external".} = object
`description`*: Preserve[Cap] `description`*: Value
`TurnCause`*[Cap] {.preservesOr.} = object `TurnCause`* {.preservesOr.} = object
case orKind*: TurnCauseKind case orKind*: TurnCauseKind
of TurnCauseKind.`turn`: of TurnCauseKind.`turn`:
`turn`*: TurnCauseTurn[Cap] `turn`*: TurnCauseTurn
of TurnCauseKind.`cleanup`: of TurnCauseKind.`cleanup`:
`cleanup`*: TurnCauseCleanup `cleanup`*: TurnCauseCleanup
of TurnCauseKind.`linkedTaskRelease`: of TurnCauseKind.`linkedTaskRelease`:
`linkedtaskrelease`*: TurnCauseLinkedTaskRelease[Cap] `linkedtaskrelease`*: TurnCauseLinkedTaskRelease
of TurnCauseKind.`periodicActivation`: of TurnCauseKind.`periodicActivation`:
`periodicactivation`*: TurnCausePeriodicActivation `periodicactivation`*: TurnCausePeriodicActivation
of TurnCauseKind.`delay`: of TurnCauseKind.`delay`:
`delay`*: TurnCauseDelay[Cap] `delay`*: TurnCauseDelay
of TurnCauseKind.`external`: of TurnCauseKind.`external`:
`external`*: TurnCauseExternal[Cap] `external`*: TurnCauseExternal
TurnEventKind* {.pure.} = enum TurnEventKind* {.pure.} = enum
`assert`, `retract`, `message`, `sync`, `breakLink` `assert`, `retract`, `message`, `sync`, `breakLink`
TurnEventAssert*[Cap] {.preservesRecord: "assert".} = object TurnEventAssert* {.preservesRecord: "assert".} = object
`assertion`*: AssertionDescription[Cap] `assertion`*: AssertionDescription
`handle`*: protocol.Handle `handle`*: protocol.Handle
TurnEventRetract* {.preservesRecord: "retract".} = object TurnEventRetract* {.preservesRecord: "retract".} = object
`handle`*: protocol.Handle `handle`*: protocol.Handle
TurnEventMessage*[Cap] {.preservesRecord: "message".} = object TurnEventMessage* {.preservesRecord: "message".} = object
`body`*: AssertionDescription[Cap] `body`*: AssertionDescription
TurnEventSync*[Cap] {.preservesRecord: "sync".} = object TurnEventSync* {.preservesRecord: "sync".} = object
`peer`*: Target[Cap] `peer`*: Target
TurnEventBreakLink*[Cap] {.preservesRecord: "break-link".} = object TurnEventBreakLink* {.preservesRecord: "break-link".} = object
`source`*: ActorId[Cap] `source`*: ActorId
`handle`*: protocol.Handle `handle`*: protocol.Handle
`TurnEvent`*[Cap] {.preservesOr.} = object `TurnEvent`* {.preservesOr.} = object
case orKind*: TurnEventKind case orKind*: TurnEventKind
of TurnEventKind.`assert`: of TurnEventKind.`assert`:
`assert`*: TurnEventAssert[Cap] `assert`*: TurnEventAssert
of TurnEventKind.`retract`: of TurnEventKind.`retract`:
`retract`*: TurnEventRetract `retract`*: TurnEventRetract
of TurnEventKind.`message`: of TurnEventKind.`message`:
`message`*: TurnEventMessage[Cap] `message`*: TurnEventMessage
of TurnEventKind.`sync`: of TurnEventKind.`sync`:
`sync`*: TurnEventSync[Cap] `sync`*: TurnEventSync
of TurnEventKind.`breakLink`: of TurnEventKind.`breakLink`:
`breaklink`*: TurnEventBreakLink[Cap] `breaklink`*: TurnEventBreakLink
TurnDescription*[Cap] {.preservesRecord: "turn".} = object TurnDescription* {.preservesRecord: "turn".} = object
`id`*: TurnId[Cap] `id`*: TurnId
`cause`*: TurnCause[Cap] `cause`*: TurnCause
`actions`*: seq[ActionDescription[Cap]] `actions`*: seq[ActionDescription]
ExitStatusKind* {.pure.} = enum ExitStatusKind* {.pure.} = enum
`ok`, `Error` `ok`, `Error`
@ -169,101 +169,95 @@ type
`error`*: protocol.Error `error`*: protocol.Error
TraceEntry*[Cap] {.preservesRecord: "trace".} = object TraceEntry* {.preservesRecord: "trace".} = object
`timestamp`*: float64 `timestamp`*: float64
`actor`*: ActorId[Cap] `actor`*: ActorId
`item`*: ActorActivation[Cap] `item`*: ActorActivation
Oid*[Cap] = Preserve[Cap] Oid* = Value
ActionDescriptionKind* {.pure.} = enum ActionDescriptionKind* {.pure.} = enum
`dequeue`, `enqueue`, `dequeueInternal`, `enqueueInternal`, `spawn`, `link`, `dequeue`, `enqueue`, `dequeueInternal`, `enqueueInternal`, `spawn`, `link`,
`facetStart`, `facetStop`, `linkedTaskStart` `facetStart`, `facetStop`, `linkedTaskStart`
ActionDescriptionDequeue*[Cap] {.preservesRecord: "dequeue".} = object ActionDescriptionDequeue* {.preservesRecord: "dequeue".} = object
`event`*: TargetedTurnEvent[Cap] `event`*: TargetedTurnEvent
ActionDescriptionEnqueue*[Cap] {.preservesRecord: "enqueue".} = object ActionDescriptionEnqueue* {.preservesRecord: "enqueue".} = object
`event`*: TargetedTurnEvent[Cap] `event`*: TargetedTurnEvent
ActionDescriptionDequeueInternal*[Cap] {.preservesRecord: "dequeue-internal".} = object ActionDescriptionDequeueInternal* {.preservesRecord: "dequeue-internal".} = object
`event`*: TargetedTurnEvent[Cap] `event`*: TargetedTurnEvent
ActionDescriptionEnqueueInternal*[Cap] {.preservesRecord: "enqueue-internal".} = object ActionDescriptionEnqueueInternal* {.preservesRecord: "enqueue-internal".} = object
`event`*: TargetedTurnEvent[Cap] `event`*: TargetedTurnEvent
ActionDescriptionSpawn*[Cap] {.preservesRecord: "spawn".} = object ActionDescriptionSpawn* {.preservesRecord: "spawn".} = object
`link`*: bool `link`*: bool
`id`*: ActorId[Cap] `id`*: ActorId
ActionDescriptionLink*[Cap] {.preservesRecord: "link".} = object ActionDescriptionLink* {.preservesRecord: "link".} = object
`parentActor`*: ActorId[Cap] `parentActor`*: ActorId
`childToParent`*: protocol.Handle `childToParent`*: protocol.Handle
`childActor`*: ActorId[Cap] `childActor`*: ActorId
`parentToChild`*: protocol.Handle `parentToChild`*: protocol.Handle
ActionDescriptionFacetStart*[Cap] {.preservesRecord: "facet-start".} = object ActionDescriptionFacetStart* {.preservesRecord: "facet-start".} = object
`path`*: seq[FacetId[Cap]] `path`*: seq[FacetId]
ActionDescriptionFacetStop*[Cap] {.preservesRecord: "facet-stop".} = object ActionDescriptionFacetStop* {.preservesRecord: "facet-stop".} = object
`path`*: seq[FacetId[Cap]] `path`*: seq[FacetId]
`reason`*: FacetStopReason `reason`*: FacetStopReason
ActionDescriptionLinkedTaskStart*[Cap] {.preservesRecord: "linked-task-start".} = object ActionDescriptionLinkedTaskStart* {.preservesRecord: "linked-task-start".} = object
`taskName`*: Name[Cap] `taskName`*: Name
`id`*: TaskId[Cap] `id`*: TaskId
`ActionDescription`*[Cap] {.preservesOr.} = object `ActionDescription`* {.preservesOr.} = object
case orKind*: ActionDescriptionKind case orKind*: ActionDescriptionKind
of ActionDescriptionKind.`dequeue`: of ActionDescriptionKind.`dequeue`:
`dequeue`*: ActionDescriptionDequeue[Cap] `dequeue`*: ActionDescriptionDequeue
of ActionDescriptionKind.`enqueue`: of ActionDescriptionKind.`enqueue`:
`enqueue`*: ActionDescriptionEnqueue[Cap] `enqueue`*: ActionDescriptionEnqueue
of ActionDescriptionKind.`dequeueInternal`: of ActionDescriptionKind.`dequeueInternal`:
`dequeueinternal`*: ActionDescriptionDequeueInternal[Cap] `dequeueinternal`*: ActionDescriptionDequeueInternal
of ActionDescriptionKind.`enqueueInternal`: of ActionDescriptionKind.`enqueueInternal`:
`enqueueinternal`*: ActionDescriptionEnqueueInternal[Cap] `enqueueinternal`*: ActionDescriptionEnqueueInternal
of ActionDescriptionKind.`spawn`: of ActionDescriptionKind.`spawn`:
`spawn`*: ActionDescriptionSpawn[Cap] `spawn`*: ActionDescriptionSpawn
of ActionDescriptionKind.`link`: of ActionDescriptionKind.`link`:
`link`*: ActionDescriptionLink[Cap] `link`*: ActionDescriptionLink
of ActionDescriptionKind.`facetStart`: of ActionDescriptionKind.`facetStart`:
`facetstart`*: ActionDescriptionFacetStart[Cap] `facetstart`*: ActionDescriptionFacetStart
of ActionDescriptionKind.`facetStop`: of ActionDescriptionKind.`facetStop`:
`facetstop`*: ActionDescriptionFacetStop[Cap] `facetstop`*: ActionDescriptionFacetStop
of ActionDescriptionKind.`linkedTaskStart`: of ActionDescriptionKind.`linkedTaskStart`:
`linkedtaskstart`*: ActionDescriptionLinkedTaskStart[Cap] `linkedtaskstart`*: ActionDescriptionLinkedTaskStart
proc `$`*[Cap](x: TargetedTurnEvent[Cap] | AssertionDescription[Cap] | Name[Cap] | proc `$`*(x: TargetedTurnEvent | AssertionDescription | Name | ActorActivation |
ActorActivation[Cap] | Target |
Target[Cap] | TurnCause |
TurnCause[Cap] | TurnEvent |
TurnEvent[Cap] | TurnDescription |
TurnDescription[Cap] | ExitStatus |
TraceEntry[Cap] | TraceEntry |
ActionDescription[Cap]): string = ActionDescription): string =
`$`(toPreserve(x, Cap)) `$`(toPreserves(x))
proc encode*[Cap](x: TargetedTurnEvent[Cap] | AssertionDescription[Cap] | proc encode*(x: TargetedTurnEvent | AssertionDescription | Name |
Name[Cap] | ActorActivation |
ActorActivation[Cap] | Target |
Target[Cap] | TurnCause |
TurnCause[Cap] | TurnEvent |
TurnEvent[Cap] | TurnDescription |
TurnDescription[Cap] | ExitStatus |
TraceEntry[Cap] | TraceEntry |
ActionDescription[Cap]): seq[byte] = ActionDescription): seq[byte] =
encode(toPreserve(x, Cap)) encode(toPreserves(x))
proc `$`*(x: ExitStatus): string =
`$`(toPreserve(x))
proc encode*(x: ExitStatus): seq[byte] =
encode(toPreserve(x))

4
src/syndicate/protocols/transportAddress.nim
View File

@ -16,7 +16,7 @@ type
`port`*: BiggestInt `port`*: BiggestInt
proc `$`*(x: WebSocket | Stdio | Unix | Tcp): string = proc `$`*(x: WebSocket | Stdio | Unix | Tcp): string =
`$`(toPreserve(x)) `$`(toPreserves(x))
proc encode*(x: WebSocket | Stdio | Unix | Tcp): seq[byte] = proc encode*(x: WebSocket | Stdio | Unix | Tcp): seq[byte] =
encode(toPreserve(x)) encode(toPreserves(x))

12
src/syndicate/protocols/worker.nim
View File

@ -3,12 +3,12 @@ import
preserves preserves
type type
Instance*[Cap] {.preservesRecord: "Instance".} = object Instance* {.preservesRecord: "Instance".} = object
`name`*: string `name`*: string
`argument`*: Preserve[Cap] `argument`*: Value
proc `$`*[Cap](x: Instance[Cap]): string = proc `$`*(x: Instance): string =
`$`(toPreserve(x, Cap)) `$`(toPreserves(x))
proc encode*[Cap](x: Instance[Cap]): seq[byte] = proc encode*(x: Instance): seq[byte] =
encode(toPreserve(x, Cap)) encode(toPreserves(x))

57
src/syndicate/relays.nim
View File

@ -22,9 +22,8 @@ type
export Stdio, Tcp, WebSocket, Unix export Stdio, Tcp, WebSocket, Unix
type type
Value = Preserve[void] Assertion = Value
Assertion = Preserve[Cap] WireRef = sturdy.WireRef
WireRef = sturdy.WireRef[void]
Turn = syndicate.Turn Turn = syndicate.Turn
type type
@ -78,7 +77,7 @@ proc newSyncPeerEntity(r: Relay; p: Cap): SyncPeerEntity =
proc rewriteCapOut(relay: Relay; cap: Cap; exported: var seq[WireSymbol]): WireRef = proc rewriteCapOut(relay: Relay; cap: Cap; exported: var seq[WireSymbol]): WireRef =
if cap.target of RelayEntity and cap.target.RelayEntity.relay == relay and cap.attenuation.len == 0: if cap.target of RelayEntity and cap.target.RelayEntity.relay == relay and cap.attenuation.len == 0:
WireRef(orKind: WireRefKind.yours, yours: WireRefYours[void](oid: cap.target.oid)) WireRef(orKind: WireRefKind.yours, yours: WireRefYours(oid: cap.target.oid))
else: else:
var ws = grab(relay.exported, cap) var ws = grab(relay.exported, cap)
if ws.isNil: if ws.isNil:
@ -93,7 +92,7 @@ proc rewriteOut(relay: Relay; v: Assertion):
tuple[rewritten: Value, exported: seq[WireSymbol]] {.gcsafe.} = tuple[rewritten: Value, exported: seq[WireSymbol]] {.gcsafe.} =
var exported: seq[WireSymbol] var exported: seq[WireSymbol]
result.rewritten = contract(v) do (r: Cap) -> Value: result.rewritten = contract(v) do (r: Cap) -> Value:
rewriteCapOut(relay, r, exported).toPreserve rewriteCapOut(relay, r, exported).toPreserves
result.exported = exported result.exported = exported
proc register(relay: Relay; v: Assertion; h: Handle): tuple[rewritten: Value, exported: seq[WireSymbol]] = proc register(relay: Relay; v: Assertion; h: Handle): tuple[rewritten: Value, exported: seq[WireSymbol]] =
@ -185,9 +184,9 @@ proc rewriteIn(relay; facet; v: Value):
var imported: seq[WireSymbol] var imported: seq[WireSymbol]
result.rewritten = expand(v) do (pr: Value) -> Assertion: result.rewritten = expand(v) do (pr: Value) -> Assertion:
var wr: WireRef var wr: WireRef
if not fromPreserve(wr, pr): if not wr.fromPreserves(pr):
raiseAssert "expansion of embedded value failed" raiseAssert "expansion of embedded value failed"
rewriteCapIn(relay, facet, wr, imported).toPreserve(Cap) rewriteCapIn(relay, facet, wr, imported).toPreserves
result.imported = imported result.imported = imported
proc close(r: Relay) = discard proc close(r: Relay) = discard
@ -224,7 +223,7 @@ proc dispatch*(relay: Relay; v: Value) {.gcsafe.} =
trace "S: ", v trace "S: ", v
run(relay.facet) do (t: var Turn): run(relay.facet) do (t: var Turn):
var pkt: Packet var pkt: Packet
if fromPreserve(pkt, v): if pkt.fromPreserves(v):
case pkt.orKind case pkt.orKind
of PacketKind.Turn: of PacketKind.Turn:
# https://synit.org/book/protocol.html#turn-packets # https://synit.org/book/protocol.html#turn-packets
@ -263,9 +262,9 @@ proc newRelay(turn: var Turn; opts: RelayOptions; setup: RelaySetup): Relay =
discard result.facet.preventInertCheck() discard result.facet.preventInertCheck()
setup(turn, result) setup(turn, result)
proc transportConnectionResolve(addrAss: Assertion; ds: Cap): gatekeeper.TransportConnection[Cap] = proc transportConnectionResolve(addrAss: Assertion; ds: Cap): gatekeeper.TransportConnection =
result.`addr` = addrAss result.`addr` = addrAss
result.resolved = Resolved[Cap](orKind: ResolvedKind.accepted) result.resolved = Resolved(orKind: ResolvedKind.accepted)
result.resolved.accepted.responderSession = ds result.resolved.accepted.responderSession = ds
proc spawnRelay*(name: string; turn: var Turn; ds: Cap; addrAss: Assertion; opts: RelayActorOptions; setup: RelaySetup) = proc spawnRelay*(name: string; turn: var Turn; ds: Cap; addrAss: Assertion; opts: RelayActorOptions; setup: RelaySetup) =
@ -305,7 +304,7 @@ export Tcp
when defined(posix): when defined(posix):
export Unix export Unix
proc connect*(turn: var Turn; ds: Cap; route: Route; addrAss: Assertion; socket: AsyncSocket; step: Preserve[Cap]) = proc connect*(turn: var Turn; ds: Cap; route: Route; addrAss: Assertion; socket: AsyncSocket; step: Value) =
## Relay a dataspace over an open `AsyncSocket`. ## Relay a dataspace over an open `AsyncSocket`.
proc socketWriter(packet: sink Packet): Future[void] = proc socketWriter(packet: sink Packet): Future[void] =
socket.send(cast[string](encode(packet))) socket.send(cast[string](encode(packet)))
@ -339,28 +338,28 @@ when defined(posix):
turn.facet.actor.atExit do (turn: var Turn): close(socket) turn.facet.actor.atExit do (turn: var Turn): close(socket)
discard publish(turn, connectionClosedCap, true) discard publish(turn, connectionClosedCap, true)
shutdownCap = newCap(turn, ShutdownEntity()) shutdownCap = newCap(turn, ShutdownEntity())
onPublish(turn, ds, TransportConnection[Cap] ?: {0: ?addrAss, 2: ?:Rejected[Cap]}) do (detail: Value): onPublish(turn, ds, TransportConnection ?: {0: ?addrAss, 2: ?:Rejected}) do (detail: Value):
raise newException(IOError, $detail) raise newException(IOError, $detail)
onPublish(turn, ds, TransportConnection[Cap] ?: {0: ?addrAss, 2: ?:ResolvedAccepted[Cap]}) do (gatekeeper: Cap): onPublish(turn, ds, TransportConnection ?: {0: ?addrAss, 2: ?:ResolvedAccepted}) do (gatekeeper: Cap):
run(gatekeeper.relay) do (turn: var Turn): run(gatekeeper.relay) do (turn: var Turn):
reenable() reenable()
discard publish(turn, shutdownCap, true) discard publish(turn, shutdownCap, true)
proc duringCallback(turn: var Turn; ass: Assertion; h: Handle): TurnAction = proc duringCallback(turn: var Turn; ass: Assertion; h: Handle): TurnAction =
let facet = inFacet(turn) do (turn: var Turn): let facet = inFacet(turn) do (turn: var Turn):
var resolvePath = ResolvePath[Cap](route: route, `addr`: addrAss) var resolvePath = ResolvePath(route: route, `addr`: addrAss)
if resolvePath.resolved.fromPreserve(ass): if resolvePath.resolved.fromPreserves(ass):
discard publish(turn, ds, resolvePath) discard publish(turn, ds, resolvePath)
else: else:
raise newException(CatchableError, "unhandled gatekeeper response " & $ass) raise newException(CatchableError, "unhandled gatekeeper response " & $ass)
proc action(turn: var Turn) = proc action(turn: var Turn) =
stop(turn, facet) stop(turn, facet)
result = action result = action
discard publish(turn, gatekeeper, Resolve[Cap]( discard publish(turn, gatekeeper, Resolve(
step: step, step: step,
observer: newCap(turn, during(duringCallback)), observer: newCap(turn, during(duringCallback)),
)) ))
proc connect*(turn: var Turn; ds: Cap; route: Route; transport: Tcp; step: Preserve[Cap]) = proc connect*(turn: var Turn; ds: Cap; route: Route; transport: Tcp; step: Value) =
## Relay a dataspace over TCP. ## Relay a dataspace over TCP.
let socket = newAsyncSocket( let socket = newAsyncSocket(
domain = AF_INET, domain = AF_INET,
@ -369,9 +368,9 @@ when defined(posix):
buffered = false) buffered = false)
let fut = connect(socket, transport.host, Port transport.port) let fut = connect(socket, transport.host, Port transport.port)
addCallback(fut, turn) do (turn: var Turn): addCallback(fut, turn) do (turn: var Turn):
connect(turn, ds, route, transport.toPreserve(Cap), socket, step) connect(turn, ds, route, transport.toPreserves, socket, step)
proc connect*(turn: var Turn; ds: Cap; route: Route; transport: Unix; step: Preserve[Cap]) = proc connect*(turn: var Turn; ds: Cap; route: Route; transport: Unix; step: Value) =
## Relay a dataspace over a UNIX socket. ## Relay a dataspace over a UNIX socket.
let socket = newAsyncSocket( let socket = newAsyncSocket(
domain = AF_UNIX, domain = AF_UNIX,
@ -380,7 +379,7 @@ when defined(posix):
buffered = false) buffered = false)
let fut = connectUnix(socket, transport.path) let fut = connectUnix(socket, transport.path)
addCallback(fut, turn) do (turn: var Turn): addCallback(fut, turn) do (turn: var Turn):
connect(turn, ds, route, transport.toPreserve(Cap), socket, step) connect(turn, ds, route, transport.toPreserves, socket, step)
import std/asyncfile import std/asyncfile
@ -398,7 +397,7 @@ when defined(posix):
packetWriter: stdoutWriter, packetWriter: stdoutWriter,
initialCap: ds, initialCap: ds,
initialOid: 0.Oid.some) initialOid: 0.Oid.some)
spawnRelay("stdio", turn, ds, Stdio().toPreserve(Cap), opts) do (turn: var Turn; relay: Relay): spawnRelay("stdio", turn, ds, Stdio().toPreserves, opts) do (turn: var Turn; relay: Relay):
let let
facet = turn.facet facet = turn.facet
asyncStdin = openAsync("/dev/stdin") # this is universal now? asyncStdin = openAsync("/dev/stdin") # this is universal now?
@ -421,15 +420,15 @@ when defined(posix):
type BootProc* = proc (turn: var Turn; ds: Cap) {.gcsafe.} type BootProc* = proc (turn: var Turn; ds: Cap) {.gcsafe.}
proc envRoute*: Route[Cap] = proc envRoute*: Route =
var text = getEnv("SYNDICATE_ROUTE") var text = getEnv("SYNDICATE_ROUTE")
if text == "": if text == "":
var tx = (getEnv("XDG_RUNTIME_DIR", "/run/user/1000") / "dataspace").toPreserve(Cap) var tx = (getEnv("XDG_RUNTIME_DIR", "/run/user/1000") / "dataspace").toPreserves
result.transports = @[initRecord("unix", tx)] result.transports = @[initRecord("unix", tx)]
result.pathSteps = @[capabilities.mint().toPreserve(Cap)] result.pathSteps = @[capabilities.mint().toPreserves]
else: else:
var pr = parsePreserves(text, Cap) var pr = parsePreserves(text, Cap)
if not result.fromPreserve(pr): if not result.fromPreserves(pr):
raise newException(ValueError, "failed to parse $SYNDICATE_ROUTE " & $pr) raise newException(ValueError, "failed to parse $SYNDICATE_ROUTE " & $pr)
proc resolve*(turn: var Turn; ds: Cap; route: Route; bootProc: BootProc) = proc resolve*(turn: var Turn; ds: Cap; route: Route; bootProc: BootProc) =
@ -439,15 +438,15 @@ proc resolve*(turn: var Turn; ds: Cap; route: Route; bootProc: BootProc) =
stdio: Stdio stdio: Stdio
doAssert(route.transports.len == 1, "only a single transport supported for routes") doAssert(route.transports.len == 1, "only a single transport supported for routes")
doAssert(route.pathSteps.len < 2, "multiple path steps not supported for routes") doAssert(route.pathSteps.len < 2, "multiple path steps not supported for routes")
if unix.fromPreserve route.transports[0]: if unix.fromPreserves route.transports[0]:
connect(turn, ds, route, unix, route.pathSteps[0]) connect(turn, ds, route, unix, route.pathSteps[0])
elif tcp.fromPreserve route.transports[0]: elif tcp.fromPreserves route.transports[0]:
connect(turn, ds, route, tcp, route.pathSteps[0]) connect(turn, ds, route, tcp, route.pathSteps[0])
elif stdio.fromPreserve route.transports[0]: elif stdio.fromPreserves route.transports[0]:
connectStdio(turn, ds) connectStdio(turn, ds)
bootProc(turn, ds) bootProc(turn, ds)
else: else:
raise newException(ValueError, "unsupported route") raise newException(ValueError, "unsupported route")
during(turn, ds, ResolvePath[Cap] ?: { 0: ?route, 3: ?:ResolvedAccepted[Cap]}) do (dest: Cap): during(turn, ds, ResolvePath ?: { 0: ?route, 3: ?:ResolvedAccepted}) do (dest: Cap):
bootProc(turn, dest) bootProc(turn, dest)

15
src/syndicate/skeletons.nim
View File

@ -9,9 +9,8 @@ import ./actors, ./bags, ./patterns
import ./protocols/dataspacePatterns import ./protocols/dataspacePatterns
type type
DCompound = dataspacePatterns.DCompound[Cap] DCompound = dataspacePatterns.DCompound
Pattern = dataspacePatterns.Pattern[Cap] Pattern = dataspacePatterns.Pattern
Value = Preserve[Cap]
Path = seq[Value] Path = seq[Value]
ClassKind = enum classNone, classRecord, classSequence, classDictionary ClassKind = enum classNone, classRecord, classSequence, classDictionary
Class = object Class = object
@ -178,7 +177,7 @@ proc modify(node: Node; turn: var Turn; outerValue: Value; event: EventKind;
if event == removedEvent and nextNode.isEmpty: if event == removedEvent and nextNode.isEmpty:
table.del(nextClass) table.del(nextClass)
walk(node, turn, @[@[outerValue].toPreserve(Cap)]) walk(node, turn, @[@[outerValue].toPreserves])
proc getOrNew[A, B, C](t: var Table[A, TableRef[B, C]], k: A): TableRef[B, C] = proc getOrNew[A, B, C](t: var Table[A, TableRef[B, C]], k: A): TableRef[B, C] =
result = t.getOrDefault(k) result = t.getOrDefault(k)
@ -190,10 +189,10 @@ iterator pairs(dc: DCompound): (Value, Pattern) =
case dc.orKind case dc.orKind
of DCompoundKind.rec: of DCompoundKind.rec:
for i, p in dc.rec.fields: for i, p in dc.rec.fields:
yield (toPreserve(i, Cap), p,) yield (i.toPreserves, p,)
of DCompoundKind.arr: of DCompoundKind.arr:
for i, p in dc.arr.items: for i, p in dc.arr.items:
yield (toPreserve(i, Cap), p,) yield (i.toPreserves, p,)
of DCompoundKind.dict: of DCompoundKind.dict:
for pair in dc.dict.entries.pairs: for pair in dc.dict.entries.pairs:
yield pair yield pair
@ -227,7 +226,7 @@ proc extendWalk(node: Node; popCount: Natural; stepIndex: Value; pat: Pattern; p
proc extend(node: var Node; pat: Pattern): Continuation = proc extend(node: var Node; pat: Pattern): Continuation =
var path: Path var path: Path
extendWalk(node, 0, toPreserve(0, Cap), pat, path).nextNode.continuation extendWalk(node, 0, 0.toPreserves, pat, path).nextNode.continuation
type type
Index* = object Index* = object
@ -293,7 +292,7 @@ proc adjustAssertion(index: var Index; turn: var Turn; outerValue: Value; delta:
let change = group.cachedCaptures.change(vs, +1) let change = group.cachedCaptures.change(vs, +1)
if change == cdAbsentToPresent: if change == cdAbsentToPresent:
for (observer, captureMap) in group.observers.pairs: for (observer, captureMap) in group.observers.pairs:
captureMap[vs] = publish(turn, observer, vs.toPreserve(Cap)) captureMap[vs] = publish(turn, observer, vs.toPreserves)
# TODO: this handle is coming from the facet? # TODO: this handle is coming from the facet?
modify(index.root, turn, outerValue, addedEvent, modContinuation, modLeaf, modObserver) modify(index.root, turn, outerValue, addedEvent, modContinuation, modLeaf, modObserver)
of cdPresentToAbsent: of cdPresentToAbsent:

2
syndicate.nimble
View File

@ -1,6 +1,6 @@
# Package # Package
version = "20231229" version = "20231231"
author = "Emery Hemingway" author = "Emery Hemingway"
description = "Syndicated actors for conversational concurrency" description = "Syndicated actors for conversational concurrency"
license = "Unlicense" license = "Unlicense"

20
tests/test_patterns.nim
View File

@ -15,9 +15,9 @@ test "patterns":
let let
worte = @["alles", "in", "ordnung"] worte = @["alles", "in", "ordnung"]
observer = Observe(pattern: inject(?:Foo, { 0: ?worte })).toPreserve(Cap) observer = Observe(pattern: inject(?:Foo, { 0: ?worte })).toPreserves
have = capture(observerPat, observer).toPreserve(Cap).unpackLiterals have = capture(observerPat, observer).toPreserves.unpackLiterals
want = [worte.toPreserve].toPreserve(Cap) want = [worte.toPreserves].toPreserves
check(have == want) check(have == want)
type Obj {.preservesDictionary.} = object type Obj {.preservesDictionary.} = object
@ -26,15 +26,15 @@ type Obj {.preservesDictionary.} = object
test "dictionaries": test "dictionaries":
let pat = ?:Obj let pat = ?:Obj
var source = initDictionary(Cap) var source = initDictionary(Cap)
source["b".toSymbol(Cap)] = 2.toPreserve(Cap) source["b".toSymbol] = 2.toPreserves
source["c".toSymbol(Cap)] = 3.toPreserve(Cap) source["c".toSymbol] = 3.toPreserves
source["a".toSymbol(Cap)] = 1.toPreserve(Cap) source["a".toSymbol] = 1.toPreserves
let values = capture(pat, source) let values = capture(pat, source)
check values.len == 3 check values.len == 3
check values[0] == 1.toPreserve(Cap) check values[0] == 1.toPreserves
check values[1] == 2.toPreserve(Cap) check values[1] == 2.toPreserves
check values[2] == 3.toPreserve(Cap) check values[2] == 3.toPreserves
type type
File {.preservesDictionary.} = object File {.preservesDictionary.} = object
@ -55,4 +55,4 @@ test "literals":
var pr = parsePreserves(txt, Cap) var pr = parsePreserves(txt, Cap)
var capture: Literal[Request] var capture: Literal[Request]
check capture.fromPreserve(pr) check capture.fromPreserves(pr)

2
tests/test_protocols.nim
View File

@ -4,7 +4,7 @@ import preserves
import syndicate/relays import syndicate/relays
import syndicate/protocols/sturdy import syndicate/protocols/sturdy
type WireRef = sturdy.WireRef[void] type WireRef = sturdy.WireRef
suite "protocols": suite "protocols":
test "PDiscard": test "PDiscard":

4
tests/test_schema.nim
View File

@ -9,7 +9,7 @@ type
`z`*: BiggestInt `z`*: BiggestInt
proc `$`*(x: Foo): string = proc `$`*(x: Foo): string =
`$`(toPreserve(x)) `$`(toPreserves(x))
proc encode*(x: Foo): seq[byte] = proc encode*(x: Foo): seq[byte] =
encode(toPreserve(x)) encode(toPreserves(x))