Regenerate protocol modules
This commit is contained in:
parent
17c7328be8
commit
c4dace1eb7
|
|
@ -28,7 +28,7 @@ proc genId(T: type): T =
|
|||
type
|
||||
Attenuation = sturdy.Attenuation[Ref]
|
||||
Oid = sturdy.Oid
|
||||
Assertion* = protocol.Assertion[Ref]
|
||||
Assertion* = Preserve[Ref]
|
||||
Caveat = sturdy.Caveat[Ref]
|
||||
Rewrite = sturdy.Rewrite[Ref]
|
||||
|
||||
|
|
|
|||
|
|
@ -4,44 +4,22 @@
|
|||
import preserves
|
||||
import ./protocols/sturdy, ./private/hmacs
|
||||
|
||||
from ./actors import Ref
|
||||
proc mint*[T](key: openarray[byte]; oid: Preserve[T]): SturdyRef[T] =
|
||||
SturdyRef[T](oid: oid, sig: hmacSha256(key, encode(oid), key.len))
|
||||
|
||||
type SturdyRef* = sturdy.SturdyRef[Ref]
|
||||
proc mint*[T](key: openarray[byte]; oid: T; E = void): SturdyRef[E] =
|
||||
var oidPr = toPreserve(oid, E)
|
||||
SturdyRef[E](oid: oidPr, sig: hmacSha256(key, encode(oidPr), key.len))
|
||||
|
||||
proc mint*(key: openarray[byte]; oid: Preserve[Ref]): SturdyRef =
|
||||
SturdyRef(oid: oid, sig: hmacSha256(key, encode(oid), key.len))
|
||||
|
||||
proc mint*[T](key: openarray[byte]; oid: T): SturdyRef =
|
||||
let oidPr = toPreserve(oid, Ref)
|
||||
SturdyRef(oid: oidPr, sig: hmacSha256(key, encode(oidPr), key.len))
|
||||
|
||||
proc mint*(): SturdyRef {.deprecated.} =
|
||||
## Mint a test capability for the use with the Syndicate server.
|
||||
var key: array[16, byte]
|
||||
mint(key, "syndicate")
|
||||
|
||||
proc attenuate*(r: SturdyRef; caveats: Attenuation): SturdyRef =
|
||||
result = SturdyRef(
|
||||
proc attenuate*[T](r: SturdyRef[T]; caveats: Attenuation): SturdyRef[T] =
|
||||
result = SturdyRef[T](
|
||||
oid: r.oid,
|
||||
caveatChain: r.caveatChain,
|
||||
sig: hmacSha256(r.sig, caveats.encode))
|
||||
result.caveatChain.add caveats
|
||||
|
||||
proc validate*(key: openarray[byte]; r: SturdyRef): bool =
|
||||
proc validate*[T](key: openarray[byte]; r: SturdyRef[T]): bool =
|
||||
var sig = hmacSha256(key, r.oid.encode, key.len)
|
||||
for a in r.caveatChain:
|
||||
sig = hmacSha256(sig, a.encode)
|
||||
r.sig == sig
|
||||
|
||||
when isMainModule:
|
||||
import unittest
|
||||
import preserves/parse
|
||||
test "sturdy":
|
||||
var
|
||||
key: array[16, byte]
|
||||
oid = "syndicate".toPreserve
|
||||
sRef = mint(key, oid)
|
||||
control = parsePreserves"""<ref "syndicate" [] #[pkgN9TBmEd3Q04grVG4Zdw]>"""
|
||||
check(sRef.toPreserve == control)
|
||||
let aRef = attenuate(sRef, newSeq[Caveat]())
|
||||
check validate(key, aRef)
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ import ./actors, ./protocols/dataspace, ./skeletons
|
|||
from ./protocols/protocol import Handle
|
||||
|
||||
type
|
||||
Assertion = Preserve[Ref]
|
||||
Observe = dataspace.Observe[Ref]
|
||||
Turn = actors.Turn
|
||||
|
||||
|
|
@ -19,7 +20,7 @@ method publish(ds: Dataspace; turn: var Turn; v: Assertion; h: Handle) =
|
|||
if add(ds.index, turn, v):
|
||||
var obs: Observe
|
||||
if obs.fromPreserve v:
|
||||
ds.index.add(turn, obs.pattern, unembed obs.observer)
|
||||
ds.index.add(turn, obs.pattern, obs.observer)
|
||||
ds.handleMap[h] = v
|
||||
|
||||
method retract(ds: Dataspace; turn: var Turn; h: Handle) =
|
||||
|
|
@ -29,7 +30,7 @@ method retract(ds: Dataspace; turn: var Turn; h: Handle) =
|
|||
ds.handleMap.del h
|
||||
var obs: Observe
|
||||
if obs.fromPreserve v:
|
||||
ds.index.remove(turn, obs.pattern, unembed obs.observer)
|
||||
ds.index.remove(turn, obs.pattern, obs.observer)
|
||||
except KeyError: discard
|
||||
|
||||
method message(ds: Dataspace; turn: var Turn; v: Assertion) =
|
||||
|
|
|
|||
|
|
@ -51,4 +51,4 @@ method retract(de: DuringEntity; turn: var Turn; h: Handle) =
|
|||
proc during*(cb: DuringProc): DuringEntity = DuringEntity(cb: cb)
|
||||
|
||||
proc observe*(turn: var Turn; ds: Ref; pat: Pattern; e: Entity): Handle =
|
||||
publish(turn, ds, Observe(pattern: pat, observer: embed newRef(turn, e)))
|
||||
publish(turn, ds, Observe(pattern: pat, observer: newRef(turn, e)))
|
||||
|
|
|
|||
|
|
@ -1,19 +1,22 @@
|
|||
include_rules
|
||||
outputs = \
|
||||
dataspace.nim \
|
||||
dataspacePatterns.nim \
|
||||
gatekeeper.nim \
|
||||
protocol.nim \
|
||||
racketEvent.nim \
|
||||
secureChatProtocol.nim \
|
||||
service.nim \
|
||||
simpleChatProtocol.nim \
|
||||
stream.nim \
|
||||
sturdy.nim \
|
||||
tcp.nim \
|
||||
timer.nim \
|
||||
trace.nim \
|
||||
transportAddress.nim \
|
||||
worker.nim \
|
||||
modules += dataspace.nim
|
||||
modules += dataspacePatterns.nim
|
||||
modules += gatekeeper.nim
|
||||
modules += protocol.nim
|
||||
modules += racketEvent.nim
|
||||
modules += secureChatProtocol.nim
|
||||
modules += service.nim
|
||||
modules += simpleChatProtocol.nim
|
||||
modules += stream.nim
|
||||
modules += sturdy.nim
|
||||
modules += tcp.nim
|
||||
modules += timer.nim
|
||||
modules += trace.nim
|
||||
modules += transportAddress.nim
|
||||
modules += worker.nim
|
||||
|
||||
: foreach ../../../../syndicate-protocols/schema-bundle.bin |> !preserves_schema_nim |> $(outputs)
|
||||
: ../../../../syndicate-protocols/schema-bundle.bin \
|
||||
|> !preserves_schema_nim \
|
||||
|> $(modules) | ../../../<protocols> {generated}
|
||||
|
||||
: foreach {generated} | {generated} |> !nim_run |>
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -3,12 +3,12 @@ import
|
|||
std/typetraits, preserves, dataspacePatterns
|
||||
|
||||
type
|
||||
Observe*[E] {.preservesRecord: "Observe".} = ref object
|
||||
`pattern`*: dataspacePatterns.Pattern[E]
|
||||
`observer`*: Preserve[E]
|
||||
Observe*[Cap] {.preservesRecord: "Observe".} = ref object
|
||||
`pattern`*: dataspacePatterns.Pattern[Cap]
|
||||
`observer`*: Cap
|
||||
|
||||
proc `$`*[E](x: Observe[E]): string =
|
||||
`$`(toPreserve(x, E))
|
||||
proc `$`*[Cap](x: Observe[Cap]): string =
|
||||
`$`(toPreserve(x, Cap))
|
||||
|
||||
proc encode*[E](x: Observe[E]): seq[byte] =
|
||||
encode(toPreserve(x, E))
|
||||
proc encode*[Cap](x: Observe[Cap]): seq[byte] =
|
||||
encode(toPreserve(x, Cap))
|
||||
|
|
|
|||
|
|
@ -12,8 +12,8 @@ type
|
|||
AnyAtomString* = string
|
||||
AnyAtomBytes* = seq[byte]
|
||||
AnyAtomSymbol* = Symbol
|
||||
AnyAtomEmbedded*[E] = Preserve[E]
|
||||
`AnyAtom`*[E] {.preservesOr.} = ref object
|
||||
AnyAtomEmbedded*[Cap] = Cap
|
||||
`AnyAtom`*[Cap] {.preservesOr.} = object
|
||||
case orKind*: AnyAtomKind
|
||||
of AnyAtomKind.`bool`:
|
||||
`bool`*: AnyAtomBool
|
||||
|
|
@ -37,64 +37,65 @@ type
|
|||
`symbol`*: AnyAtomSymbol
|
||||
|
||||
of AnyAtomKind.`embedded`:
|
||||
`embedded`*: AnyAtomEmbedded[E]
|
||||
`embedded`*: AnyAtomEmbedded[Cap]
|
||||
|
||||
|
||||
DLit*[E] {.preservesRecord: "lit".} = ref object
|
||||
`value`*: AnyAtom[E]
|
||||
DLit*[Cap] {.preservesRecord: "lit".} = object
|
||||
`value`*: AnyAtom[Cap]
|
||||
|
||||
DBind*[E] {.preservesRecord: "bind".} = ref object
|
||||
`pattern`*: Pattern[E]
|
||||
DBind*[Cap] {.preservesRecord: "bind".} = ref object
|
||||
`pattern`*: Pattern[Cap]
|
||||
|
||||
DDiscard* {.preservesRecord: "_".} = object
|
||||
|
||||
DCompoundKind* {.pure.} = enum
|
||||
`rec`, `arr`, `dict`
|
||||
DCompoundRec*[E] {.preservesRecord: "rec".} = ref object
|
||||
`label`*: Preserve[E]
|
||||
`fields`*: seq[Pattern[E]]
|
||||
DCompoundRec*[Cap] {.preservesRecord: "rec".} = ref object
|
||||
`label`*: Preserve[Cap]
|
||||
`fields`*: seq[Pattern[Cap]]
|
||||
|
||||
DCompoundArr*[E] {.preservesRecord: "arr".} = ref object
|
||||
`items`*: seq[Pattern[E]]
|
||||
DCompoundArr*[Cap] {.preservesRecord: "arr".} = ref object
|
||||
`items`*: seq[Pattern[Cap]]
|
||||
|
||||
DCompoundDict*[E] {.preservesRecord: "dict".} = ref object
|
||||
`entries`*: Table[Preserve[E], Pattern[E]]
|
||||
DCompoundDict*[Cap] {.preservesRecord: "dict".} = ref object
|
||||
`entries`*: Table[Preserve[Cap], Pattern[Cap]]
|
||||
|
||||
`DCompound`*[E] {.preservesOr.} = ref object
|
||||
`DCompound`*[Cap] {.preservesOr.} = ref object
|
||||
case orKind*: DCompoundKind
|
||||
of DCompoundKind.`rec`:
|
||||
`rec`*: DCompoundRec[E]
|
||||
`rec`*: DCompoundRec[Cap]
|
||||
|
||||
of DCompoundKind.`arr`:
|
||||
`arr`*: DCompoundArr[E]
|
||||
`arr`*: DCompoundArr[Cap]
|
||||
|
||||
of DCompoundKind.`dict`:
|
||||
`dict`*: DCompoundDict[E]
|
||||
`dict`*: DCompoundDict[Cap]
|
||||
|
||||
|
||||
PatternKind* {.pure.} = enum
|
||||
`DDiscard`, `DBind`, `DLit`, `DCompound`
|
||||
`Pattern`*[E] {.preservesOr.} = ref object
|
||||
`Pattern`*[Cap] {.preservesOr.} = ref object
|
||||
case orKind*: PatternKind
|
||||
of PatternKind.`DDiscard`:
|
||||
`ddiscard`*: DDiscard
|
||||
|
||||
of PatternKind.`DBind`:
|
||||
`dbind`*: DBind[E]
|
||||
`dbind`*: DBind[Cap]
|
||||
|
||||
of PatternKind.`DLit`:
|
||||
`dlit`*: DLit[E]
|
||||
`dlit`*: DLit[Cap]
|
||||
|
||||
of PatternKind.`DCompound`:
|
||||
`dcompound`*: DCompound[E]
|
||||
`dcompound`*: DCompound[Cap]
|
||||
|
||||
|
||||
proc `$`*[E](x: AnyAtom[E] | DLit[E] | DBind[E] | DCompound[E] | Pattern[E]): string =
|
||||
`$`(toPreserve(x, E))
|
||||
proc `$`*[Cap](x: AnyAtom[Cap] | DLit[Cap] | DBind[Cap] | DCompound[Cap] |
|
||||
Pattern[Cap]): string =
|
||||
`$`(toPreserve(x, Cap))
|
||||
|
||||
proc encode*[E](x: AnyAtom[E] | DLit[E] | DBind[E] | DCompound[E] | Pattern[E]): seq[
|
||||
byte] =
|
||||
encode(toPreserve(x, E))
|
||||
proc encode*[Cap](x: AnyAtom[Cap] | DLit[Cap] | DBind[Cap] | DCompound[Cap] |
|
||||
Pattern[Cap]): seq[byte] =
|
||||
encode(toPreserve(x, Cap))
|
||||
|
||||
proc `$`*(x: DDiscard): string =
|
||||
`$`(toPreserve(x))
|
||||
|
|
|
|||
|
|
@ -3,17 +3,17 @@ import
|
|||
std/typetraits, preserves, sturdy
|
||||
|
||||
type
|
||||
Bind*[E] {.preservesRecord: "bind".} = ref object
|
||||
`oid`*: Preserve[E]
|
||||
Bind*[Cap] {.preservesRecord: "bind".} = object
|
||||
`oid`*: Preserve[Cap]
|
||||
`key`*: seq[byte]
|
||||
`target`*: Preserve[E]
|
||||
`target`*: Cap
|
||||
|
||||
Resolve*[E] {.preservesRecord: "resolve".} = ref object
|
||||
`sturdyref`*: sturdy.SturdyRef[E]
|
||||
`observer`*: Preserve[E]
|
||||
Resolve*[Cap] {.preservesRecord: "resolve".} = ref object
|
||||
`sturdyref`*: sturdy.SturdyRef[Cap]
|
||||
`observer`*: Cap
|
||||
|
||||
proc `$`*[E](x: Bind[E] | Resolve[E]): string =
|
||||
`$`(toPreserve(x, E))
|
||||
proc `$`*[Cap](x: Bind[Cap] | Resolve[Cap]): string =
|
||||
`$`(toPreserve(x, Cap))
|
||||
|
||||
proc encode*[E](x: Bind[E] | Resolve[E]): seq[byte] =
|
||||
encode(toPreserve(x, E))
|
||||
proc encode*[Cap](x: Bind[Cap] | Resolve[Cap]): seq[byte] =
|
||||
encode(toPreserve(x, Cap))
|
||||
|
|
|
|||
Binary file not shown.
Binary file not shown.
|
|
@ -3,81 +3,77 @@ import
|
|||
std/typetraits, preserves
|
||||
|
||||
type
|
||||
Error*[E] {.preservesRecord: "error".} = ref object
|
||||
Error* {.preservesRecord: "error".} = object
|
||||
`message`*: string
|
||||
`detail`*: Preserve[E]
|
||||
`detail`*: Preserve[void]
|
||||
|
||||
Turn*[E] = seq[TurnEvent[E]]
|
||||
Message*[E] {.preservesRecord: "message".} = ref object
|
||||
`body`*: Assertion[E]
|
||||
Turn* = seq[TurnEvent]
|
||||
Message* {.preservesRecord: "message".} = object
|
||||
`body`*: Assertion
|
||||
|
||||
Retract* {.preservesRecord: "retract".} = object
|
||||
`handle`*: Handle
|
||||
|
||||
Assert*[E] {.preservesRecord: "assert".} = ref object
|
||||
`assertion`*: Assertion[E]
|
||||
Assert* {.preservesRecord: "assert".} = object
|
||||
`assertion`*: Assertion
|
||||
`handle`*: Handle
|
||||
|
||||
Extension*[E] {.preservesRecord: "label".} = ref object
|
||||
`data`*: seq[Preserve[E]]
|
||||
Extension* {.preservesRecord: "label".} = object
|
||||
`data`*: seq[Preserve[void]]
|
||||
|
||||
Sync*[E] {.preservesRecord: "sync".} = ref object
|
||||
`peer`*: Preserve[E]
|
||||
Sync* {.preservesRecord: "sync".} = object
|
||||
`peer`* {.preservesLiteral: "#!<lit #t>".}: bool
|
||||
|
||||
TurnEvent*[E] {.preservesTuple.} = ref object
|
||||
TurnEvent* {.preservesTuple.} = object
|
||||
`oid`*: Oid
|
||||
`event`*: Event[E]
|
||||
`event`*: Event
|
||||
|
||||
Oid* = BiggestInt
|
||||
Assertion*[E] = Preserve[E]
|
||||
Assertion* = Preserve[void]
|
||||
Handle* = BiggestInt
|
||||
PacketKind* {.pure.} = enum
|
||||
`Turn`, `Error`, `Extension`
|
||||
`Packet`*[E] {.preservesOr.} = ref object
|
||||
`Packet`* {.preservesOr.} = object
|
||||
case orKind*: PacketKind
|
||||
of PacketKind.`Turn`:
|
||||
`turn`*: Turn[E]
|
||||
`turn`*: Turn
|
||||
|
||||
of PacketKind.`Error`:
|
||||
`error`*: Error[E]
|
||||
`error`*: Error
|
||||
|
||||
of PacketKind.`Extension`:
|
||||
`extension`*: Extension[E]
|
||||
`extension`*: Extension
|
||||
|
||||
|
||||
EventKind* {.pure.} = enum
|
||||
`Assert`, `Retract`, `Message`, `Sync`
|
||||
`Event`*[E] {.preservesOr.} = ref object
|
||||
`Event`* {.preservesOr.} = object
|
||||
case orKind*: EventKind
|
||||
of EventKind.`Assert`:
|
||||
`assert`*: Assert[E]
|
||||
`assert`*: Assert
|
||||
|
||||
of EventKind.`Retract`:
|
||||
`retract`*: Retract
|
||||
|
||||
of EventKind.`Message`:
|
||||
`message`*: Message[E]
|
||||
`message`*: Message
|
||||
|
||||
of EventKind.`Sync`:
|
||||
`sync`*: Sync[E]
|
||||
`sync`*: Sync
|
||||
|
||||
|
||||
proc `$`*[E](x: Error[E] | Turn[E] | Message[E] | Assert[E] | Extension[E] |
|
||||
Sync[E] |
|
||||
TurnEvent[E] |
|
||||
Packet[E] |
|
||||
Event[E]): string =
|
||||
`$`(toPreserve(x, E))
|
||||
|
||||
proc encode*[E](x: Error[E] | Turn[E] | Message[E] | Assert[E] | Extension[E] |
|
||||
Sync[E] |
|
||||
TurnEvent[E] |
|
||||
Packet[E] |
|
||||
Event[E]): seq[byte] =
|
||||
encode(toPreserve(x, E))
|
||||
|
||||
proc `$`*(x: Retract | Oid | Handle): string =
|
||||
proc `$`*(x: Error | Turn | Message | Retract | Assert | Extension | Sync |
|
||||
TurnEvent |
|
||||
Oid |
|
||||
Handle |
|
||||
Packet |
|
||||
Event): string =
|
||||
`$`(toPreserve(x))
|
||||
|
||||
proc encode*(x: Retract | Oid | Handle): seq[byte] =
|
||||
proc encode*(x: Error | Turn | Message | Retract | Assert | Extension | Sync |
|
||||
TurnEvent |
|
||||
Oid |
|
||||
Handle |
|
||||
Packet |
|
||||
Event): seq[byte] =
|
||||
encode(toPreserve(x))
|
||||
|
|
|
|||
|
|
@ -3,12 +3,12 @@ import
|
|||
std/typetraits, preserves
|
||||
|
||||
type
|
||||
RacketEvent*[E] {.preservesRecord: "racket-event".} = ref object
|
||||
`source`*: Preserve[E]
|
||||
`event`*: Preserve[E]
|
||||
RacketEvent* {.preservesRecord: "racket-event".} = object
|
||||
`source`* {.preservesEmbedded.}: Preserve[void]
|
||||
`event`* {.preservesEmbedded.}: Preserve[void]
|
||||
|
||||
proc `$`*[E](x: RacketEvent[E]): string =
|
||||
`$`(toPreserve(x, E))
|
||||
proc `$`*(x: RacketEvent): string =
|
||||
`$`(toPreserve(x))
|
||||
|
||||
proc encode*[E](x: RacketEvent[E]): seq[byte] =
|
||||
encode(toPreserve(x, E))
|
||||
proc encode*(x: RacketEvent): seq[byte] =
|
||||
encode(toPreserve(x))
|
||||
|
|
|
|||
|
|
@ -17,30 +17,30 @@ type
|
|||
`nickconflict`*: NickConflict
|
||||
|
||||
|
||||
Join*[E] {.preservesRecord: "joinedUser".} = ref object
|
||||
Join*[Cap] {.preservesRecord: "joinedUser".} = object
|
||||
`uid`*: UserId
|
||||
`handle`*: Preserve[E]
|
||||
`handle`*: Cap
|
||||
|
||||
SessionKind* {.pure.} = enum
|
||||
`observeUsers`, `observeSpeech`, `NickClaim`, `Says`
|
||||
SessionObserveUsers*[E] {.preservesRecord: "Observe".} = ref object
|
||||
SessionObserveUsers*[Cap] {.preservesRecord: "Observe".} = object
|
||||
`data`* {.preservesLiteral: "user".}: bool
|
||||
`observer`*: Preserve[E]
|
||||
`observer`*: Cap
|
||||
|
||||
SessionObserveSpeech*[E] {.preservesRecord: "Observe".} = ref object
|
||||
SessionObserveSpeech*[Cap] {.preservesRecord: "Observe".} = object
|
||||
`data`* {.preservesLiteral: "says".}: bool
|
||||
`observer`*: Preserve[E]
|
||||
`observer`*: Cap
|
||||
|
||||
`Session`*[E] {.preservesOr.} = ref object
|
||||
`Session`*[Cap] {.preservesOr.} = object
|
||||
case orKind*: SessionKind
|
||||
of SessionKind.`observeUsers`:
|
||||
`observeusers`*: SessionObserveUsers[E]
|
||||
`observeusers`*: SessionObserveUsers[Cap]
|
||||
|
||||
of SessionKind.`observeSpeech`:
|
||||
`observespeech`*: SessionObserveSpeech[E]
|
||||
`observespeech`*: SessionObserveSpeech[Cap]
|
||||
|
||||
of SessionKind.`NickClaim`:
|
||||
`nickclaim`*: NickClaim[E]
|
||||
`nickclaim`*: NickClaim[Cap]
|
||||
|
||||
of SessionKind.`Says`:
|
||||
`says`*: Says
|
||||
|
|
@ -50,20 +50,20 @@ type
|
|||
`uid`*: UserId
|
||||
`name`*: string
|
||||
|
||||
NickClaim*[E] {.preservesRecord: "claimNick".} = ref object
|
||||
NickClaim*[Cap] {.preservesRecord: "claimNick".} = object
|
||||
`uid`*: UserId
|
||||
`name`*: string
|
||||
`k`*: Preserve[E]
|
||||
`k`*: Cap
|
||||
|
||||
Says* {.preservesRecord: "says".} = object
|
||||
`who`*: UserId
|
||||
`what`*: string
|
||||
|
||||
proc `$`*[E](x: Join[E] | Session[E] | NickClaim[E]): string =
|
||||
`$`(toPreserve(x, E))
|
||||
proc `$`*[Cap](x: Join[Cap] | Session[Cap] | NickClaim[Cap]): string =
|
||||
`$`(toPreserve(x, Cap))
|
||||
|
||||
proc encode*[E](x: Join[E] | Session[E] | NickClaim[E]): seq[byte] =
|
||||
encode(toPreserve(x, E))
|
||||
proc encode*[Cap](x: Join[Cap] | Session[Cap] | NickClaim[Cap]): seq[byte] =
|
||||
encode(toPreserve(x, Cap))
|
||||
|
||||
proc `$`*(x: UserId | NickConflict | NickClaimResponse | UserInfo | Says): string =
|
||||
`$`(toPreserve(x))
|
||||
|
|
|
|||
|
|
@ -5,8 +5,8 @@ import
|
|||
type
|
||||
StateKind* {.pure.} = enum
|
||||
`started`, `ready`, `failed`, `complete`, `userDefined`
|
||||
StateUserDefined*[E] = Preserve[E]
|
||||
`State`*[E] {.preservesOr.} = ref object
|
||||
StateUserDefined*[Cap] = Preserve[Cap]
|
||||
`State`*[Cap] {.preservesOr.} = object
|
||||
case orKind*: StateKind
|
||||
of StateKind.`started`:
|
||||
`started`* {.preservesLiteral: "started".}: bool
|
||||
|
|
@ -21,40 +21,40 @@ type
|
|||
`complete`* {.preservesLiteral: "complete".}: bool
|
||||
|
||||
of StateKind.`userDefined`:
|
||||
`userdefined`*: StateUserDefined[E]
|
||||
`userdefined`*: StateUserDefined[Cap]
|
||||
|
||||
|
||||
ServiceObject*[E] {.preservesRecord: "service-object".} = ref object
|
||||
`serviceName`*: Preserve[E]
|
||||
`object`*: Preserve[E]
|
||||
ServiceObject*[Cap] {.preservesRecord: "service-object".} = object
|
||||
`serviceName`*: Preserve[Cap]
|
||||
`object`*: Preserve[Cap]
|
||||
|
||||
RequireService*[E] {.preservesRecord: "require-service".} = ref object
|
||||
`serviceName`*: Preserve[E]
|
||||
RequireService*[Cap] {.preservesRecord: "require-service".} = object
|
||||
`serviceName`*: Preserve[Cap]
|
||||
|
||||
RestartService*[E] {.preservesRecord: "restart-service".} = ref object
|
||||
`serviceName`*: Preserve[E]
|
||||
RestartService*[Cap] {.preservesRecord: "restart-service".} = object
|
||||
`serviceName`*: Preserve[Cap]
|
||||
|
||||
RunService*[E] {.preservesRecord: "run-service".} = ref object
|
||||
`serviceName`*: Preserve[E]
|
||||
RunService*[Cap] {.preservesRecord: "run-service".} = object
|
||||
`serviceName`*: Preserve[Cap]
|
||||
|
||||
ServiceState*[E] {.preservesRecord: "service-state".} = ref object
|
||||
`serviceName`*: Preserve[E]
|
||||
`state`*: State[E]
|
||||
ServiceState*[Cap] {.preservesRecord: "service-state".} = object
|
||||
`serviceName`*: Preserve[Cap]
|
||||
`state`*: State[Cap]
|
||||
|
||||
ServiceDependency*[E] {.preservesRecord: "depends-on".} = ref object
|
||||
`depender`*: Preserve[E]
|
||||
`dependee`*: ServiceState[E]
|
||||
ServiceDependency*[Cap] {.preservesRecord: "depends-on".} = object
|
||||
`depender`*: Preserve[Cap]
|
||||
`dependee`*: ServiceState[Cap]
|
||||
|
||||
proc `$`*[E](x: State[E] | ServiceObject[E] | RequireService[E] |
|
||||
RestartService[E] |
|
||||
RunService[E] |
|
||||
ServiceState[E] |
|
||||
ServiceDependency[E]): string =
|
||||
`$`(toPreserve(x, E))
|
||||
proc `$`*[Cap](x: State[Cap] | ServiceObject[Cap] | RequireService[Cap] |
|
||||
RestartService[Cap] |
|
||||
RunService[Cap] |
|
||||
ServiceState[Cap] |
|
||||
ServiceDependency[Cap]): string =
|
||||
`$`(toPreserve(x, Cap))
|
||||
|
||||
proc encode*[E](x: State[E] | ServiceObject[E] | RequireService[E] |
|
||||
RestartService[E] |
|
||||
RunService[E] |
|
||||
ServiceState[E] |
|
||||
ServiceDependency[E]): seq[byte] =
|
||||
encode(toPreserve(x, E))
|
||||
proc encode*[Cap](x: State[Cap] | ServiceObject[Cap] | RequireService[Cap] |
|
||||
RestartService[Cap] |
|
||||
RunService[Cap] |
|
||||
ServiceState[Cap] |
|
||||
ServiceDependency[Cap]): seq[byte] =
|
||||
encode(toPreserve(x, Cap))
|
||||
|
|
|
|||
|
|
@ -18,76 +18,76 @@ type
|
|||
StreamError* {.preservesRecord: "error".} = object
|
||||
`message`*: string
|
||||
|
||||
StreamListenerError*[E] {.preservesRecord: "stream-listener-error".} = ref object
|
||||
`spec`*: Preserve[E]
|
||||
StreamListenerError*[Cap] {.preservesRecord: "stream-listener-error".} = object
|
||||
`spec`*: Preserve[Cap]
|
||||
`message`*: string
|
||||
|
||||
StreamConnection*[E] {.preservesRecord: "stream-connection".} = ref object
|
||||
`source`*: Preserve[E]
|
||||
`sink`*: Preserve[E]
|
||||
`spec`*: Preserve[E]
|
||||
StreamConnection*[Cap] {.preservesRecord: "stream-connection".} = object
|
||||
`source`*: Cap
|
||||
`sink`*: Cap
|
||||
`spec`*: Preserve[Cap]
|
||||
|
||||
`LineMode`* {.preservesOr, pure.} = enum
|
||||
`lf`, `crlf`
|
||||
SourceKind* {.pure.} = enum
|
||||
`sink`, `StreamError`, `credit`
|
||||
SourceSink*[E] {.preservesRecord: "sink".} = ref object
|
||||
`controller`*: Preserve[E]
|
||||
SourceSink*[Cap] {.preservesRecord: "sink".} = object
|
||||
`controller`*: Cap
|
||||
|
||||
SourceCredit*[E] {.preservesRecord: "credit".} = ref object
|
||||
SourceCredit*[Cap] {.preservesRecord: "credit".} = object
|
||||
`amount`*: CreditAmount
|
||||
`mode`*: Mode[E]
|
||||
`mode`*: Mode[Cap]
|
||||
|
||||
`Source`*[E] {.preservesOr.} = ref object
|
||||
`Source`*[Cap] {.preservesOr.} = object
|
||||
case orKind*: SourceKind
|
||||
of SourceKind.`sink`:
|
||||
`sink`*: SourceSink[E]
|
||||
`sink`*: SourceSink[Cap]
|
||||
|
||||
of SourceKind.`StreamError`:
|
||||
`streamerror`*: StreamError
|
||||
|
||||
of SourceKind.`credit`:
|
||||
`credit`*: SourceCredit[E]
|
||||
`credit`*: SourceCredit[Cap]
|
||||
|
||||
|
||||
SinkKind* {.pure.} = enum
|
||||
`source`, `StreamError`, `data`, `eof`
|
||||
SinkSource*[E] {.preservesRecord: "source".} = ref object
|
||||
`controller`*: Preserve[E]
|
||||
SinkSource*[Cap] {.preservesRecord: "source".} = object
|
||||
`controller`*: Cap
|
||||
|
||||
SinkData*[E] {.preservesRecord: "data".} = ref object
|
||||
`payload`*: Preserve[E]
|
||||
`mode`*: Mode[E]
|
||||
SinkData*[Cap] {.preservesRecord: "data".} = object
|
||||
`payload`*: Preserve[Cap]
|
||||
`mode`*: Mode[Cap]
|
||||
|
||||
SinkEof* {.preservesRecord: "eof".} = object
|
||||
|
||||
`Sink`*[E] {.preservesOr.} = ref object
|
||||
`Sink`*[Cap] {.preservesOr.} = object
|
||||
case orKind*: SinkKind
|
||||
of SinkKind.`source`:
|
||||
`source`*: SinkSource[E]
|
||||
`source`*: SinkSource[Cap]
|
||||
|
||||
of SinkKind.`StreamError`:
|
||||
`streamerror`*: StreamError
|
||||
|
||||
of SinkKind.`data`:
|
||||
`data`*: SinkData[E]
|
||||
`data`*: SinkData[Cap]
|
||||
|
||||
of SinkKind.`eof`:
|
||||
`eof`*: SinkEof
|
||||
|
||||
|
||||
StreamListenerReady*[E] {.preservesRecord: "stream-listener-ready".} = ref object
|
||||
`spec`*: Preserve[E]
|
||||
StreamListenerReady*[Cap] {.preservesRecord: "stream-listener-ready".} = object
|
||||
`spec`*: Preserve[Cap]
|
||||
|
||||
ModeKind* {.pure.} = enum
|
||||
`bytes`, `lines`, `packet`, `object`
|
||||
ModePacket* {.preservesRecord: "packet".} = object
|
||||
`size`*: BiggestInt
|
||||
|
||||
ModeObject*[E] {.preservesRecord: "object".} = ref object
|
||||
`description`*: Preserve[E]
|
||||
ModeObject*[Cap] {.preservesRecord: "object".} = object
|
||||
`description`*: Preserve[Cap]
|
||||
|
||||
`Mode`*[E] {.preservesOr.} = ref object
|
||||
`Mode`*[Cap] {.preservesOr.} = object
|
||||
case orKind*: ModeKind
|
||||
of ModeKind.`bytes`:
|
||||
`bytes`* {.preservesLiteral: "bytes".}: bool
|
||||
|
|
@ -99,20 +99,21 @@ type
|
|||
`packet`*: ModePacket
|
||||
|
||||
of ModeKind.`object`:
|
||||
`object`*: ModeObject[E]
|
||||
`object`*: ModeObject[Cap]
|
||||
|
||||
|
||||
proc `$`*[E](x: StreamListenerError[E] | StreamConnection[E] | Source[E] |
|
||||
Sink[E] |
|
||||
StreamListenerReady[E] |
|
||||
Mode[E]): string =
|
||||
`$`(toPreserve(x, E))
|
||||
proc `$`*[Cap](x: StreamListenerError[Cap] | StreamConnection[Cap] | Source[Cap] |
|
||||
Sink[Cap] |
|
||||
StreamListenerReady[Cap] |
|
||||
Mode[Cap]): string =
|
||||
`$`(toPreserve(x, Cap))
|
||||
|
||||
proc encode*[E](x: StreamListenerError[E] | StreamConnection[E] | Source[E] |
|
||||
Sink[E] |
|
||||
StreamListenerReady[E] |
|
||||
Mode[E]): seq[byte] =
|
||||
encode(toPreserve(x, E))
|
||||
proc encode*[Cap](x: StreamListenerError[Cap] | StreamConnection[Cap] |
|
||||
Source[Cap] |
|
||||
Sink[Cap] |
|
||||
StreamListenerReady[Cap] |
|
||||
Mode[Cap]): seq[byte] =
|
||||
encode(toPreserve(x, Cap))
|
||||
|
||||
proc `$`*(x: CreditAmount | StreamError): string =
|
||||
`$`(toPreserve(x))
|
||||
|
|
|
|||
|
|
@ -1,112 +1,112 @@
|
|||
|
||||
import
|
||||
std/typetraits, preserves, std/tables
|
||||
std/typetraits, preserves, std/tables, std/tables
|
||||
|
||||
type
|
||||
PCompoundKind* {.pure.} = enum
|
||||
`rec`, `arr`, `dict`
|
||||
PCompoundRec*[E] {.preservesRecord: "rec".} = ref object
|
||||
`label`*: Preserve[E]
|
||||
`fields`*: seq[Pattern[E]]
|
||||
PCompoundRec*[Cap] {.preservesRecord: "rec".} = ref object
|
||||
`label`*: Preserve[Cap]
|
||||
`fields`*: seq[Pattern[Cap]]
|
||||
|
||||
PCompoundArr*[E] {.preservesRecord: "arr".} = ref object
|
||||
`items`*: seq[Pattern[E]]
|
||||
PCompoundArr*[Cap] {.preservesRecord: "arr".} = ref object
|
||||
`items`*: seq[Pattern[Cap]]
|
||||
|
||||
PCompoundDict*[E] {.preservesRecord: "dict".} = ref object
|
||||
`entries`*: Table[Preserve[E], Pattern[E]]
|
||||
PCompoundDict*[Cap] {.preservesRecord: "dict".} = ref object
|
||||
`entries`*: Table[Preserve[Cap], Pattern[Cap]]
|
||||
|
||||
`PCompound`*[E] {.preservesOr.} = ref object
|
||||
`PCompound`*[Cap] {.preservesOr.} = ref object
|
||||
case orKind*: PCompoundKind
|
||||
of PCompoundKind.`rec`:
|
||||
`rec`*: PCompoundRec[E]
|
||||
`rec`*: PCompoundRec[Cap]
|
||||
|
||||
of PCompoundKind.`arr`:
|
||||
`arr`*: PCompoundArr[E]
|
||||
`arr`*: PCompoundArr[Cap]
|
||||
|
||||
of PCompoundKind.`dict`:
|
||||
`dict`*: PCompoundDict[E]
|
||||
`dict`*: PCompoundDict[Cap]
|
||||
|
||||
|
||||
PAnd*[Cap] {.preservesRecord: "and".} = ref object
|
||||
`patterns`*: seq[Pattern[Cap]]
|
||||
|
||||
PAnd*[E] {.preservesRecord: "and".} = ref object
|
||||
`patterns`*: seq[Pattern[E]]
|
||||
|
||||
Rewrite*[E] {.preservesRecord: "rewrite".} = ref object
|
||||
`pattern`*: Pattern[E]
|
||||
`template`*: Template[E]
|
||||
Rewrite*[Cap] {.preservesRecord: "rewrite".} = ref object
|
||||
`pattern`*: Pattern[Cap]
|
||||
`template`*: Template[Cap]
|
||||
|
||||
TRef* {.preservesRecord: "ref".} = object
|
||||
`binding`*: BiggestInt
|
||||
|
||||
PBind*[E] {.preservesRecord: "bind".} = ref object
|
||||
`pattern`*: Pattern[E]
|
||||
PBind*[Cap] {.preservesRecord: "bind".} = ref object
|
||||
`pattern`*: Pattern[Cap]
|
||||
|
||||
Lit*[E] {.preservesRecord: "lit".} = ref object
|
||||
`value`*: Preserve[E]
|
||||
Lit*[Cap] {.preservesRecord: "lit".} = object
|
||||
`value`*: Preserve[Cap]
|
||||
|
||||
TCompoundKind* {.pure.} = enum
|
||||
`rec`, `arr`, `dict`
|
||||
TCompoundRec*[E] {.preservesRecord: "rec".} = ref object
|
||||
`label`*: Preserve[E]
|
||||
`fields`*: seq[Template[E]]
|
||||
TCompoundRec*[Cap] {.preservesRecord: "rec".} = ref object
|
||||
`label`*: Preserve[Cap]
|
||||
`fields`*: seq[Template[Cap]]
|
||||
|
||||
TCompoundArr*[E] {.preservesRecord: "arr".} = ref object
|
||||
`items`*: seq[Template[E]]
|
||||
TCompoundArr*[Cap] {.preservesRecord: "arr".} = ref object
|
||||
`items`*: seq[Template[Cap]]
|
||||
|
||||
TCompoundDict*[E] {.preservesRecord: "dict".} = ref object
|
||||
`entries`*: Table[Preserve[E], Template[E]]
|
||||
TCompoundDict*[Cap] {.preservesRecord: "dict".} = ref object
|
||||
`entries`*: Table[Preserve[Cap], Template[Cap]]
|
||||
|
||||
`TCompound`*[E] {.preservesOr.} = ref object
|
||||
`TCompound`*[Cap] {.preservesOr.} = ref object
|
||||
case orKind*: TCompoundKind
|
||||
of TCompoundKind.`rec`:
|
||||
`rec`*: TCompoundRec[E]
|
||||
`rec`*: TCompoundRec[Cap]
|
||||
|
||||
of TCompoundKind.`arr`:
|
||||
`arr`*: TCompoundArr[E]
|
||||
`arr`*: TCompoundArr[Cap]
|
||||
|
||||
of TCompoundKind.`dict`:
|
||||
`dict`*: TCompoundDict[E]
|
||||
|
||||
`dict`*: TCompoundDict[Cap]
|
||||
|
||||
|
||||
`PAtom`* {.preservesOr, pure.} = enum
|
||||
`Boolean`, `Float`, `Double`, `SignedInteger`, `String`, `ByteString`,
|
||||
`Symbol`
|
||||
Attenuation*[E] = seq[Caveat[E]]
|
||||
Attenuation*[Cap] = seq[Caveat[Cap]]
|
||||
PDiscard* {.preservesRecord: "_".} = object
|
||||
|
||||
|
||||
TemplateKind* {.pure.} = enum
|
||||
`TAttenuate`, `TRef`, `Lit`, `TCompound`
|
||||
`Template`*[E] {.preservesOr.} = ref object
|
||||
`Template`*[Cap] {.preservesOr.} = ref object
|
||||
case orKind*: TemplateKind
|
||||
of TemplateKind.`TAttenuate`:
|
||||
`tattenuate`*: TAttenuate[E]
|
||||
`tattenuate`*: TAttenuate[Cap]
|
||||
|
||||
of TemplateKind.`TRef`:
|
||||
`tref`*: TRef
|
||||
|
||||
of TemplateKind.`Lit`:
|
||||
`lit`*: Lit[E]
|
||||
`lit`*: Lit[Cap]
|
||||
|
||||
of TemplateKind.`TCompound`:
|
||||
`tcompound`*: TCompound[E]
|
||||
|
||||
`tcompound`*: TCompound[Cap]
|
||||
|
||||
|
||||
CaveatKind* {.pure.} = enum
|
||||
`Rewrite`, `Alts`
|
||||
`Caveat`*[E] {.preservesOr.} = ref object
|
||||
`Caveat`*[Cap] {.preservesOr.} = ref object
|
||||
case orKind*: CaveatKind
|
||||
of CaveatKind.`Rewrite`:
|
||||
`rewrite`*: Rewrite[E]
|
||||
`rewrite`*: Rewrite[Cap]
|
||||
|
||||
of CaveatKind.`Alts`:
|
||||
`alts`*: Alts[E]
|
||||
`alts`*: Alts[Cap]
|
||||
|
||||
|
||||
PNot*[Cap] {.preservesRecord: "not".} = ref object
|
||||
`pattern`*: Pattern[Cap]
|
||||
|
||||
PNot*[E] {.preservesRecord: "not".} = ref object
|
||||
`pattern`*: Pattern[E]
|
||||
|
||||
SturdyRef*[E] {.preservesRecord: "ref".} = ref object
|
||||
`oid`*: Preserve[E]
|
||||
`caveatChain`*: seq[Attenuation[E]]
|
||||
SturdyRef*[Cap] {.preservesRecord: "ref".} = ref object
|
||||
`oid`*: Preserve[Cap]
|
||||
`caveatChain`*: seq[Attenuation[Cap]]
|
||||
`sig`*: seq[byte]
|
||||
|
||||
WireRefKind* {.pure.} = enum
|
||||
|
|
@ -115,32 +115,32 @@ type
|
|||
`data`* {.preservesLiteral: "0".}: bool
|
||||
`oid`*: Oid
|
||||
|
||||
WireRefYours*[E] {.preservesTuple.} = ref object
|
||||
WireRefYours*[Cap] {.preservesTuple.} = ref object
|
||||
`data`* {.preservesLiteral: "1".}: bool
|
||||
`oid`*: Oid
|
||||
`attenuation`* {.preservesTupleTail.}: seq[Caveat[E]]
|
||||
`attenuation`* {.preservesTupleTail.}: seq[Caveat[Cap]]
|
||||
|
||||
`WireRef`*[E] {.preservesOr.} = ref object
|
||||
`WireRef`*[Cap] {.preservesOr.} = ref object
|
||||
case orKind*: WireRefKind
|
||||
of WireRefKind.`mine`:
|
||||
`mine`*: WireRefMine
|
||||
|
||||
of WireRefKind.`yours`:
|
||||
`yours`*: WireRefYours[E]
|
||||
`yours`*: WireRefYours[Cap]
|
||||
|
||||
|
||||
TAttenuate*[E] {.preservesRecord: "attenuate".} = ref object
|
||||
`template`*: Template[E]
|
||||
`attenuation`*: Attenuation[E]
|
||||
TAttenuate*[Cap] {.preservesRecord: "attenuate".} = ref object
|
||||
`template`*: Template[Cap]
|
||||
`attenuation`*: Attenuation[Cap]
|
||||
|
||||
Oid* = BiggestInt
|
||||
Alts*[E] {.preservesRecord: "or".} = ref object
|
||||
`alternatives`*: seq[Rewrite[E]]
|
||||
Alts*[Cap] {.preservesRecord: "or".} = ref object
|
||||
`alternatives`*: seq[Rewrite[Cap]]
|
||||
|
||||
PatternKind* {.pure.} = enum
|
||||
`PDiscard`, `PAtom`, `PEmbedded`, `PBind`, `PAnd`, `PNot`, `Lit`,
|
||||
`PCompound`
|
||||
`Pattern`*[E] {.preservesOr.} = ref object
|
||||
`Pattern`*[Cap] {.preservesOr.} = ref object
|
||||
case orKind*: PatternKind
|
||||
of PatternKind.`PDiscard`:
|
||||
`pdiscard`*: PDiscard
|
||||
|
|
@ -152,46 +152,48 @@ type
|
|||
`pembedded`* {.preservesLiteral: "Embedded".}: bool
|
||||
|
||||
of PatternKind.`PBind`:
|
||||
`pbind`*: PBind[E]
|
||||
`pbind`*: PBind[Cap]
|
||||
|
||||
of PatternKind.`PAnd`:
|
||||
`pand`*: PAnd[E]
|
||||
`pand`*: PAnd[Cap]
|
||||
|
||||
of PatternKind.`PNot`:
|
||||
`pnot`*: PNot[E]
|
||||
`pnot`*: PNot[Cap]
|
||||
|
||||
of PatternKind.`Lit`:
|
||||
`lit`*: Lit[E]
|
||||
`lit`*: Lit[Cap]
|
||||
|
||||
of PatternKind.`PCompound`:
|
||||
`pcompound`*: PCompound[E]
|
||||
`pcompound`*: PCompound[Cap]
|
||||
|
||||
|
||||
proc `$`*[Cap](x: PCompound[Cap] | PAnd[Cap] | Rewrite[Cap] | PBind[Cap] |
|
||||
Lit[Cap] |
|
||||
TCompound[Cap] |
|
||||
Attenuation[Cap] |
|
||||
Template[Cap] |
|
||||
Caveat[Cap] |
|
||||
PNot[Cap] |
|
||||
SturdyRef[Cap] |
|
||||
WireRef[Cap] |
|
||||
TAttenuate[Cap] |
|
||||
Alts[Cap] |
|
||||
Pattern[Cap]): string =
|
||||
`$`(toPreserve(x, Cap))
|
||||
|
||||
proc `$`*[E](x: PCompound[E] | PAnd[E] | Rewrite[E] | PBind[E] | Lit[E] |
|
||||
TCompound[E] |
|
||||
Attenuation[E] |
|
||||
Template[E] |
|
||||
Caveat[E] |
|
||||
PNot[E] |
|
||||
SturdyRef[E] |
|
||||
WireRef[E] |
|
||||
TAttenuate[E] |
|
||||
Alts[E] |
|
||||
Pattern[E]): string =
|
||||
`$`(toPreserve(x, E))
|
||||
|
||||
proc encode*[E](x: PCompound[E] | PAnd[E] | Rewrite[E] | PBind[E] | Lit[E] |
|
||||
TCompound[E] |
|
||||
Attenuation[E] |
|
||||
Template[E] |
|
||||
Caveat[E] |
|
||||
PNot[E] |
|
||||
SturdyRef[E] |
|
||||
WireRef[E] |
|
||||
TAttenuate[E] |
|
||||
Alts[E] |
|
||||
Pattern[E]): seq[byte] =
|
||||
encode(toPreserve(x, E))
|
||||
proc encode*[Cap](x: PCompound[Cap] | PAnd[Cap] | Rewrite[Cap] | PBind[Cap] |
|
||||
Lit[Cap] |
|
||||
TCompound[Cap] |
|
||||
Attenuation[Cap] |
|
||||
Template[Cap] |
|
||||
Caveat[Cap] |
|
||||
PNot[Cap] |
|
||||
SturdyRef[Cap] |
|
||||
WireRef[Cap] |
|
||||
TAttenuate[Cap] |
|
||||
Alts[Cap] |
|
||||
Pattern[Cap]): seq[byte] =
|
||||
encode(toPreserve(x, Cap))
|
||||
|
||||
proc `$`*(x: TRef | PDiscard | Oid): string =
|
||||
`$`(toPreserve(x))
|
||||
|
|
|
|||
|
|
@ -7,8 +7,8 @@ type
|
|||
`host`*: string
|
||||
`port`*: BiggestInt
|
||||
|
||||
TcpPeerInfo*[E] {.preservesRecord: "tcp-peer".} = ref object
|
||||
`handle`*: Preserve[E]
|
||||
TcpPeerInfo*[Cap] {.preservesRecord: "tcp-peer".} = object
|
||||
`handle`*: Cap
|
||||
`local`*: TcpLocal
|
||||
`remote`*: TcpRemote
|
||||
|
||||
|
|
@ -16,11 +16,11 @@ type
|
|||
`host`*: string
|
||||
`port`*: BiggestInt
|
||||
|
||||
proc `$`*[E](x: TcpPeerInfo[E]): string =
|
||||
`$`(toPreserve(x, E))
|
||||
proc `$`*[Cap](x: TcpPeerInfo[Cap]): string =
|
||||
`$`(toPreserve(x, Cap))
|
||||
|
||||
proc encode*[E](x: TcpPeerInfo[E]): seq[byte] =
|
||||
encode(toPreserve(x, E))
|
||||
proc encode*[Cap](x: TcpPeerInfo[Cap]): seq[byte] =
|
||||
encode(toPreserve(x, Cap))
|
||||
|
||||
proc `$`*(x: TcpLocal | TcpRemote): string =
|
||||
`$`(toPreserve(x))
|
||||
|
|
|
|||
|
|
@ -3,12 +3,12 @@ import
|
|||
std/typetraits, preserves
|
||||
|
||||
type
|
||||
TimerExpired*[E] {.preservesRecord: "timer-expired".} = ref object
|
||||
`label`*: Preserve[E]
|
||||
TimerExpired* {.preservesRecord: "timer-expired".} = object
|
||||
`label`*: Preserve[void]
|
||||
`msecs`*: float64
|
||||
|
||||
SetTimer*[E] {.preservesRecord: "set-timer".} = ref object
|
||||
`label`*: Preserve[E]
|
||||
SetTimer* {.preservesRecord: "set-timer".} = object
|
||||
`label`*: Preserve[void]
|
||||
`msecs`*: float64
|
||||
`kind`*: TimerKind
|
||||
|
||||
|
|
@ -17,14 +17,8 @@ type
|
|||
LaterThan* {.preservesRecord: "later-than".} = object
|
||||
`msecs`*: float64
|
||||
|
||||
proc `$`*[E](x: TimerExpired[E] | SetTimer[E]): string =
|
||||
`$`(toPreserve(x, E))
|
||||
|
||||
proc encode*[E](x: TimerExpired[E] | SetTimer[E]): seq[byte] =
|
||||
encode(toPreserve(x, E))
|
||||
|
||||
proc `$`*(x: LaterThan): string =
|
||||
proc `$`*(x: TimerExpired | SetTimer | LaterThan): string =
|
||||
`$`(toPreserve(x))
|
||||
|
||||
proc encode*(x: LaterThan): seq[byte] =
|
||||
proc encode*(x: TimerExpired | SetTimer | LaterThan): seq[byte] =
|
||||
encode(toPreserve(x))
|
||||
|
|
|
|||
|
|
@ -0,0 +1,270 @@
|
|||
|
||||
import
|
||||
std/typetraits, preserves, protocol, protocol, protocol, protocol, protocol,
|
||||
protocol
|
||||
|
||||
type
|
||||
TargetedTurnEvent*[Cap] {.preservesRecord: "event".} = object
|
||||
`target`*: Target[Cap]
|
||||
`detail`*: TurnEvent[Cap]
|
||||
|
||||
`LinkedTaskReleaseReason`* {.preservesOr, pure.} = enum
|
||||
`cancelled`, `normal`
|
||||
TurnId*[Cap] = Preserve[Cap]
|
||||
AssertionDescriptionKind* {.pure.} = enum
|
||||
`value`, `opaque`
|
||||
AssertionDescriptionValue*[Cap] {.preservesRecord: "value".} = object
|
||||
`value`*: Preserve[Cap]
|
||||
|
||||
AssertionDescriptionOpaque*[Cap] {.preservesRecord: "opaque".} = object
|
||||
`description`*: Preserve[Cap]
|
||||
|
||||
`AssertionDescription`*[Cap] {.preservesOr.} = object
|
||||
case orKind*: AssertionDescriptionKind
|
||||
of AssertionDescriptionKind.`value`:
|
||||
`value`*: AssertionDescriptionValue[Cap]
|
||||
|
||||
of AssertionDescriptionKind.`opaque`:
|
||||
`opaque`*: AssertionDescriptionOpaque[Cap]
|
||||
|
||||
|
||||
NameKind* {.pure.} = enum
|
||||
`anonymous`, `named`
|
||||
NameAnonymous* {.preservesRecord: "anonymous".} = object
|
||||
|
||||
NameNamed*[Cap] {.preservesRecord: "named".} = object
|
||||
`name`*: Preserve[Cap]
|
||||
|
||||
`Name`*[Cap] {.preservesOr.} = object
|
||||
case orKind*: NameKind
|
||||
of NameKind.`anonymous`:
|
||||
`anonymous`*: NameAnonymous
|
||||
|
||||
of NameKind.`named`:
|
||||
`named`*: NameNamed[Cap]
|
||||
|
||||
|
||||
ActorId*[Cap] = Preserve[Cap]
|
||||
FacetId*[Cap] = Preserve[Cap]
|
||||
`FacetStopReason`* {.preservesOr, pure.} = enum
|
||||
`explicitAction`, `inert`, `parentStopping`, `actorStopping`
|
||||
TaskId*[Cap] = Preserve[Cap]
|
||||
ActorActivationKind* {.pure.} = enum
|
||||
`start`, `turn`, `stop`
|
||||
ActorActivationStart*[Cap] {.preservesRecord: "start".} = object
|
||||
`actorName`*: Name[Cap]
|
||||
|
||||
ActorActivationStop* {.preservesRecord: "stop".} = object
|
||||
`status`*: ExitStatus
|
||||
|
||||
`ActorActivation`*[Cap] {.preservesOr.} = object
|
||||
case orKind*: ActorActivationKind
|
||||
of ActorActivationKind.`start`:
|
||||
`start`*: ActorActivationStart[Cap]
|
||||
|
||||
of ActorActivationKind.`turn`:
|
||||
`turn`*: TurnDescription[Cap]
|
||||
|
||||
of ActorActivationKind.`stop`:
|
||||
`stop`*: ActorActivationStop
|
||||
|
||||
|
||||
Target*[Cap] {.preservesRecord: "entity".} = object
|
||||
`actor`*: ActorId[Cap]
|
||||
`facet`*: FacetId[Cap]
|
||||
`oid`*: Oid[Cap]
|
||||
|
||||
TurnCauseKind* {.pure.} = enum
|
||||
`turn`, `cleanup`, `linkedTaskRelease`, `periodicActivation`, `delay`,
|
||||
`external`
|
||||
TurnCauseTurn*[Cap] {.preservesRecord: "caused-by".} = object
|
||||
`id`*: TurnId[Cap]
|
||||
|
||||
TurnCauseCleanup* {.preservesRecord: "cleanup".} = object
|
||||
|
||||
TurnCauseLinkedTaskRelease*[Cap] {.preservesRecord: "linked-task-release".} = object
|
||||
`id`*: TaskId[Cap]
|
||||
`reason`*: LinkedTaskReleaseReason
|
||||
|
||||
TurnCausePeriodicActivation* {.preservesRecord: "periodic-activation".} = object
|
||||
`period`*: float64
|
||||
|
||||
TurnCauseDelay*[Cap] {.preservesRecord: "delay".} = object
|
||||
`causingTurn`*: TurnId[Cap]
|
||||
`amount`*: float64
|
||||
|
||||
TurnCauseExternal*[Cap] {.preservesRecord: "external".} = object
|
||||
`description`*: Preserve[Cap]
|
||||
|
||||
`TurnCause`*[Cap] {.preservesOr.} = object
|
||||
case orKind*: TurnCauseKind
|
||||
of TurnCauseKind.`turn`:
|
||||
`turn`*: TurnCauseTurn[Cap]
|
||||
|
||||
of TurnCauseKind.`cleanup`:
|
||||
`cleanup`*: TurnCauseCleanup
|
||||
|
||||
of TurnCauseKind.`linkedTaskRelease`:
|
||||
`linkedtaskrelease`*: TurnCauseLinkedTaskRelease[Cap]
|
||||
|
||||
of TurnCauseKind.`periodicActivation`:
|
||||
`periodicactivation`*: TurnCausePeriodicActivation
|
||||
|
||||
of TurnCauseKind.`delay`:
|
||||
`delay`*: TurnCauseDelay[Cap]
|
||||
|
||||
of TurnCauseKind.`external`:
|
||||
`external`*: TurnCauseExternal[Cap]
|
||||
|
||||
|
||||
TurnEventKind* {.pure.} = enum
|
||||
`assert`, `retract`, `message`, `sync`, `breakLink`
|
||||
TurnEventAssert*[Cap] {.preservesRecord: "assert".} = object
|
||||
`assertion`*: AssertionDescription[Cap]
|
||||
`handle`*: protocol.Handle
|
||||
|
||||
TurnEventRetract* {.preservesRecord: "retract".} = object
|
||||
`handle`*: protocol.Handle
|
||||
|
||||
TurnEventMessage*[Cap] {.preservesRecord: "message".} = object
|
||||
`body`*: AssertionDescription[Cap]
|
||||
|
||||
TurnEventSync*[Cap] {.preservesRecord: "sync".} = object
|
||||
`peer`*: Target[Cap]
|
||||
|
||||
TurnEventBreakLink*[Cap] {.preservesRecord: "break-link".} = object
|
||||
`source`*: ActorId[Cap]
|
||||
`handle`*: protocol.Handle
|
||||
|
||||
`TurnEvent`*[Cap] {.preservesOr.} = object
|
||||
case orKind*: TurnEventKind
|
||||
of TurnEventKind.`assert`:
|
||||
`assert`*: TurnEventAssert[Cap]
|
||||
|
||||
of TurnEventKind.`retract`:
|
||||
`retract`*: TurnEventRetract
|
||||
|
||||
of TurnEventKind.`message`:
|
||||
`message`*: TurnEventMessage[Cap]
|
||||
|
||||
of TurnEventKind.`sync`:
|
||||
`sync`*: TurnEventSync[Cap]
|
||||
|
||||
of TurnEventKind.`breakLink`:
|
||||
`breaklink`*: TurnEventBreakLink[Cap]
|
||||
|
||||
|
||||
TurnDescription*[Cap] {.preservesRecord: "turn".} = object
|
||||
`id`*: TurnId[Cap]
|
||||
`cause`*: TurnCause[Cap]
|
||||
`actions`*: seq[ActionDescription[Cap]]
|
||||
|
||||
ExitStatusKind* {.pure.} = enum
|
||||
`ok`, `Error`
|
||||
`ExitStatus`* {.preservesOr.} = object
|
||||
case orKind*: ExitStatusKind
|
||||
of ExitStatusKind.`ok`:
|
||||
`ok`* {.preservesLiteral: "ok".}: bool
|
||||
|
||||
of ExitStatusKind.`Error`:
|
||||
`error`*: protocol.Error
|
||||
|
||||
|
||||
TraceEntry*[Cap] {.preservesRecord: "trace".} = object
|
||||
`timestamp`*: float64
|
||||
`actor`*: ActorId[Cap]
|
||||
`item`*: ActorActivation[Cap]
|
||||
|
||||
Oid*[Cap] = Preserve[Cap]
|
||||
ActionDescriptionKind* {.pure.} = enum
|
||||
`dequeue`, `enqueue`, `dequeueInternal`, `enqueueInternal`, `spawn`, `link`,
|
||||
`facetStart`, `facetStop`, `linkedTaskStart`
|
||||
ActionDescriptionDequeue*[Cap] {.preservesRecord: "dequeue".} = object
|
||||
`event`*: TargetedTurnEvent[Cap]
|
||||
|
||||
ActionDescriptionEnqueue*[Cap] {.preservesRecord: "enqueue".} = object
|
||||
`event`*: TargetedTurnEvent[Cap]
|
||||
|
||||
ActionDescriptionDequeueInternal*[Cap] {.preservesRecord: "dequeue-internal".} = object
|
||||
`event`*: TargetedTurnEvent[Cap]
|
||||
|
||||
ActionDescriptionEnqueueInternal*[Cap] {.preservesRecord: "enqueue-internal".} = object
|
||||
`event`*: TargetedTurnEvent[Cap]
|
||||
|
||||
ActionDescriptionSpawn*[Cap] {.preservesRecord: "spawn".} = object
|
||||
`link`*: bool
|
||||
`id`*: ActorId[Cap]
|
||||
|
||||
ActionDescriptionLink*[Cap] {.preservesRecord: "link".} = object
|
||||
`parentActor`*: ActorId[Cap]
|
||||
`childToParent`*: protocol.Handle
|
||||
`childActor`*: ActorId[Cap]
|
||||
`parentToChild`*: protocol.Handle
|
||||
|
||||
ActionDescriptionFacetStart*[Cap] {.preservesRecord: "facet-start".} = object
|
||||
`path`*: seq[FacetId[Cap]]
|
||||
|
||||
ActionDescriptionFacetStop*[Cap] {.preservesRecord: "facet-stop".} = object
|
||||
`path`*: seq[FacetId[Cap]]
|
||||
`reason`*: FacetStopReason
|
||||
|
||||
ActionDescriptionLinkedTaskStart*[Cap] {.preservesRecord: "linked-task-start".} = object
|
||||
`taskName`*: Name[Cap]
|
||||
`id`*: TaskId[Cap]
|
||||
|
||||
`ActionDescription`*[Cap] {.preservesOr.} = object
|
||||
case orKind*: ActionDescriptionKind
|
||||
of ActionDescriptionKind.`dequeue`:
|
||||
`dequeue`*: ActionDescriptionDequeue[Cap]
|
||||
|
||||
of ActionDescriptionKind.`enqueue`:
|
||||
`enqueue`*: ActionDescriptionEnqueue[Cap]
|
||||
|
||||
of ActionDescriptionKind.`dequeueInternal`:
|
||||
`dequeueinternal`*: ActionDescriptionDequeueInternal[Cap]
|
||||
|
||||
of ActionDescriptionKind.`enqueueInternal`:
|
||||
`enqueueinternal`*: ActionDescriptionEnqueueInternal[Cap]
|
||||
|
||||
of ActionDescriptionKind.`spawn`:
|
||||
`spawn`*: ActionDescriptionSpawn[Cap]
|
||||
|
||||
of ActionDescriptionKind.`link`:
|
||||
`link`*: ActionDescriptionLink[Cap]
|
||||
|
||||
of ActionDescriptionKind.`facetStart`:
|
||||
`facetstart`*: ActionDescriptionFacetStart[Cap]
|
||||
|
||||
of ActionDescriptionKind.`facetStop`:
|
||||
`facetstop`*: ActionDescriptionFacetStop[Cap]
|
||||
|
||||
of ActionDescriptionKind.`linkedTaskStart`:
|
||||
`linkedtaskstart`*: ActionDescriptionLinkedTaskStart[Cap]
|
||||
|
||||
|
||||
proc `$`*[Cap](x: TargetedTurnEvent[Cap] | AssertionDescription[Cap] | Name[Cap] |
|
||||
ActorActivation[Cap] |
|
||||
Target[Cap] |
|
||||
TurnCause[Cap] |
|
||||
TurnEvent[Cap] |
|
||||
TurnDescription[Cap] |
|
||||
TraceEntry[Cap] |
|
||||
ActionDescription[Cap]): string =
|
||||
`$`(toPreserve(x, Cap))
|
||||
|
||||
proc encode*[Cap](x: TargetedTurnEvent[Cap] | AssertionDescription[Cap] |
|
||||
Name[Cap] |
|
||||
ActorActivation[Cap] |
|
||||
Target[Cap] |
|
||||
TurnCause[Cap] |
|
||||
TurnEvent[Cap] |
|
||||
TurnDescription[Cap] |
|
||||
TraceEntry[Cap] |
|
||||
ActionDescription[Cap]): seq[byte] =
|
||||
encode(toPreserve(x, Cap))
|
||||
|
||||
proc `$`*(x: ExitStatus): string =
|
||||
`$`(toPreserve(x))
|
||||
|
||||
proc encode*(x: ExitStatus): seq[byte] =
|
||||
encode(toPreserve(x))
|
||||
|
|
@ -3,12 +3,12 @@ import
|
|||
std/typetraits, preserves
|
||||
|
||||
type
|
||||
Instance*[E] {.preservesRecord: "Instance".} = ref object
|
||||
Instance*[Cap] {.preservesRecord: "Instance".} = object
|
||||
`name`*: string
|
||||
`argument`*: Preserve[E]
|
||||
`argument`*: Preserve[Cap]
|
||||
|
||||
proc `$`*[E](x: Instance[E]): string =
|
||||
`$`(toPreserve(x, E))
|
||||
proc `$`*[Cap](x: Instance[Cap]): string =
|
||||
`$`(toPreserve(x, Cap))
|
||||
|
||||
proc encode*[E](x: Instance[E]): seq[byte] =
|
||||
encode(toPreserve(x, E))
|
||||
proc encode*[Cap](x: Instance[Cap]): seq[byte] =
|
||||
encode(toPreserve(x, Cap))
|
||||
|
|
|
|||
|
|
@ -13,12 +13,9 @@ else:
|
|||
type Oid = sturdy.Oid
|
||||
|
||||
type
|
||||
Value = Preserve[void]
|
||||
Assertion = Preserve[Ref]
|
||||
WireRef = sturdy.WireRef[void]
|
||||
WireAssertion = Preserve[WireRef]
|
||||
Event = protocol.Event[WireRef]
|
||||
TurnEvent = protocol.TurnEvent[WireRef]
|
||||
Packet = protocol.Packet[WireRef]
|
||||
|
||||
Turn = actors.Turn
|
||||
|
||||
|
|
@ -34,7 +31,7 @@ type
|
|||
exported: Membrane
|
||||
imported: Membrane
|
||||
nextLocalOid: Oid
|
||||
pendingTurn: protocol.Turn[WireRef]
|
||||
pendingTurn: protocol.Turn
|
||||
packetWriter: PacketWriter
|
||||
untrusted: bool
|
||||
|
||||
|
|
@ -85,16 +82,16 @@ proc rewriteRefOut(relay: Relay; `ref`: Ref; transient: bool; exported: var seq[
|
|||
mine: WireRefMine(oid: ws.oid))
|
||||
|
||||
proc rewriteOut(relay: Relay; v: Assertion; transient: bool):
|
||||
tuple[rewritten: WireAssertion, exported: seq[WireSymbol]] =
|
||||
tuple[rewritten: Value, exported: seq[WireSymbol]] =
|
||||
var exported: seq[WireSymbol]
|
||||
result.rewritten = mapEmbeds[Ref, WireRef](v) do (r: Ref) -> WireRef:
|
||||
rewriteRefOut(relay, r, transient, exported)
|
||||
result.rewritten = contract(v) do (r: Ref) -> Value:
|
||||
rewriteRefOut(relay, r, transient, exported).toPreserve
|
||||
result.exported = exported
|
||||
|
||||
proc register(relay: Relay; v: Assertion): WireAssertion =
|
||||
proc register(relay: Relay; v: Assertion): Value =
|
||||
rewriteOut(relay, v, false).rewritten
|
||||
|
||||
proc register(relay: Relay; v: Assertion; h: Handle): WireAssertion =
|
||||
proc register(relay: Relay; v: Assertion; h: Handle): Value =
|
||||
var (rewritten, exported) = rewriteOut(relay, v, false)
|
||||
relay.outboundAssertions[h] = exported
|
||||
rewritten
|
||||
|
|
@ -125,7 +122,7 @@ proc send(re: RelayEntity; ev: Event) =
|
|||
method publish(re: RelayEntity; t: var Turn; v: Assertion; h: Handle) =
|
||||
re.send Event(
|
||||
orKind: EventKind.Assert,
|
||||
`assert`: protocol.Assert[WireRef](
|
||||
`assert`: protocol.Assert(
|
||||
assertion: re.relay.register(v, h),
|
||||
handle: h))
|
||||
|
||||
|
|
@ -137,7 +134,7 @@ method retract(re: RelayEntity; t: var Turn; h: Handle) =
|
|||
|
||||
method message(re: RelayEntity; turn: var Turn; msg: Assertion) =
|
||||
re.send Event(orKind: EventKind.Message,
|
||||
message: Message[WireRef](body: register(re.relay, msg)))
|
||||
message: Message(body: register(re.relay, msg)))
|
||||
|
||||
method sync(re: RelayEntity; turn: var Turn; peer: Ref) =
|
||||
var
|
||||
|
|
@ -146,9 +143,7 @@ method sync(re: RelayEntity; turn: var Turn; peer: Ref) =
|
|||
discard rewriteRefOut(re.relay, turn.newRef(peerEntity), false, exported)
|
||||
# TODO: discard?
|
||||
peerEntity.e = exported[0]
|
||||
re.send Event(
|
||||
orKind: EventKind.Sync,
|
||||
sync: Sync[WireRef](peer: embed toPreserve(false, WireRef))) # TODO: send the WireRef?
|
||||
re.send Event(orKind: EventKind.Sync)
|
||||
|
||||
proc newRelayEntity(label: string; r: Relay; o: Oid): RelayEntity =
|
||||
RelayEntity(label: label, relay: r, oid: o)
|
||||
|
|
@ -180,11 +175,14 @@ proc rewriteRefIn(relay; facet; n: WireRef, imported: var seq[WireSymbol]): Ref
|
|||
if n.yours.attenuation.len == 0 or r.isInert: result = r
|
||||
else: raiseAssert "attenuation not implemented"
|
||||
|
||||
proc rewriteIn(relay; facet; a: Preserve[WireRef]):
|
||||
proc rewriteIn(relay; facet; v: Value):
|
||||
tuple[rewritten: Assertion; imported: seq[WireSymbol]] =
|
||||
var imported: seq[WireSymbol]
|
||||
result.rewritten = mapEmbeds(a) do (wr: WireRef) -> Ref:
|
||||
rewriteRefIn(relay, facet, wr, imported)
|
||||
result.rewritten = expand(v) do (pr: Value) -> Assertion:
|
||||
var wr: WireRef
|
||||
if not fromPreserve(wr, pr):
|
||||
raiseAssert "expansion of embedded value failed"
|
||||
rewriteRefIn(relay, facet, wr, imported).toPreserve(Ref)
|
||||
result.imported = imported
|
||||
|
||||
proc close(r: Relay) = discard
|
||||
|
|
@ -217,7 +215,7 @@ proc dispatch(relay: Relay; turn: var Turn; `ref`: Ref; event: Event) =
|
|||
for e in imported: relay.imported.del e
|
||||
]#
|
||||
|
||||
proc dispatch(relay: Relay; v: Preserve[WireRef]) =
|
||||
proc dispatch(relay: Relay; v: Value) =
|
||||
trace "S: ", v
|
||||
run(relay.facet) do (t: var Turn):
|
||||
var pkt: Packet
|
||||
|
|
@ -227,12 +225,14 @@ proc dispatch(relay: Relay; v: Preserve[WireRef]) =
|
|||
for te in pkt.turn:
|
||||
dispatch(relay, t, lookupLocal(relay, te.oid.Oid), te.event)
|
||||
of PacketKind.Error:
|
||||
stderr.writeLine ("Error from server: ", pkt.error.message, " (detail: ", pkt.error.detail, ")")
|
||||
when defined(posix):
|
||||
stderr.writeLine("Error from server: ", pkt.error.message, " (detail: ", pkt.error.detail, ")")
|
||||
close relay
|
||||
of PacketKind.Extension:
|
||||
discard
|
||||
else:
|
||||
stderr.writeLine "discarding undecoded packet ", v
|
||||
when defined(posix):
|
||||
stderr.writeLine("discarding undecoded packet ", v)
|
||||
|
||||
type
|
||||
RelayOptions = object of RootObj
|
||||
|
|
@ -318,7 +318,7 @@ proc connectUnix*(turn: var Turn; path: string; cap: SturdyRef; bootProc: Connec
|
|||
run(facet) do (turn: var Turn): stopActor(turn)
|
||||
else:
|
||||
feed(wireBuf, buf)
|
||||
var (success, pr) = decode(wireBuf, WireRef)
|
||||
var (success, pr) = decode(wireBuf)
|
||||
if success:
|
||||
dispatch(relay, pr)
|
||||
callSoon:
|
||||
|
|
@ -340,7 +340,7 @@ proc connectUnix*(turn: var Turn; path: string; cap: SturdyRef; bootProc: Connec
|
|||
result = action
|
||||
var res = Resolve(
|
||||
sturdyref: cap,
|
||||
observer: embed newRef(turn, during(duringCallback)))
|
||||
observer: newRef(turn, during(duringCallback)))
|
||||
discard publish(turn, gatekeeper, res)
|
||||
fut.complete()
|
||||
asyncCheck(turn, fut)
|
||||
|
|
@ -373,7 +373,7 @@ proc connectStdio*(ds: Ref; turn: var Turn) =
|
|||
run(facet) do (turn: var Turn): stopActor(turn)
|
||||
else:
|
||||
feed(wireBuf, buf)
|
||||
var (success, pr) = decode(wireBuf, WireRef)
|
||||
var (success, pr) = decode(wireBuf)
|
||||
if success:
|
||||
dispatch(relay, pr)
|
||||
callSoon: asyncStdin.read(stdinReadSize).addCallback(recvCb)
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# Package
|
||||
|
||||
version = "20221102"
|
||||
version = "20221208"
|
||||
author = "Emery Hemingway"
|
||||
description = "Syndicated actors for conversational concurrency"
|
||||
license = "Unlicense"
|
||||
|
|
@ -10,4 +10,4 @@ bin = @["syndicate/unix/swaybar_status_actor"]
|
|||
|
||||
# Dependencies
|
||||
|
||||
requires "nim >= 1.4.8", "nimSHA2 >= 0.1.1", "preserves >= 202210230"
|
||||
requires "nim >= 1.4.8", "nimSHA2 >= 0.1.1", "preserves >= 20221208", "taps >= 20221119"
|
||||
|
|
|
|||
|
|
@ -0,0 +1,2 @@
|
|||
include_rules
|
||||
: test_simpleChatProtocol.nim | ../<protocols> |> !nim_run |>
|
||||
Loading…
Reference in New Issue