relays: generalize gatekeeper resolution

src/syndicate/relays.nim

@@ -462,6 +462,29 @@ proc connectRoute(turn: var Turn; ds: Cap; route: Route; transOff: int) =
   onPublish(turn, ds, acceptPat) do (origin: Cap):
     walk(turn, ds, origin, route, transOff, 0)
 
+type StepCallback = proc (turn: var Turn; step: Value; origin, next: Cap) {.gcsafe.}
+
+proc spawnStepResolver(turn: var Turn; ds: Cap; stepType: Value; cb: StepCallback) =
+  spawn($stepType & "-step", turn) do (turn: var Turn):
+    let stepPat = grabRecord(stepType, grab())
+    let pat = ?Observe(pattern: ResolvedPathStep?:{1: stepPat}) ?? {0: grabLit(), 1: grab()}
+    during(turn, ds, pat) do (origin: Cap; stepDetail: Literal[Value]):
+      let step = toRecord(stepType, stepDetail.value)
+      proc duringCallback(turn: var Turn; ass: Value; h: Handle): TurnAction =
+        var res = ass.preservesTo Resolved
+        if res.isSome:
+          if res.get.orKind == ResolvedKind.accepted and
+              res.get.accepted.responderSession of Cap:
+            cb(turn, step, origin, res.get.accepted.responderSession.Cap)
+        else:
+          publish(turn, ds, ResolvedPathStep(
+              origin: origin, pathStep: step, resolved: res.get))
+        proc action(turn: var Turn) =
+          stop(turn)
+        result = action
+      publish(turn, origin, Resolve(
+          step: step, observer: newCap(turn, during(duringCallback))))
+
 proc spawnRelays*(turn: var Turn; ds: Cap) =
   ## Spawn actors that manage routes and appeasing gatekeepers.
   spawn("transport-connector", turn) do (turn: var Turn):
@@ -487,26 +510,10 @@ proc spawnRelays*(turn: var Turn; ds: Cap) =
       for i, transAddr in route.value.transports:
         connectRoute(turn, ds, route.value, i)
 
-  spawn("sturdyref-step", turn) do (turn: var Turn):
-    let pat = ?Observe(pattern: ResolvedPathStep?:{1: !SturdyRef}) ?? {0: grab(), 1: grab()}
-    during(turn, ds, pat) do (origin: Literal[Cap]; detail: Literal[sturdy.Parameters]):
-      let step = SturdyRef(parameters: detail.value).toPreserves
-      proc duringCallback(turn: var Turn; ass: Assertion; h: Handle): TurnAction =
-        let facet = inFacet(turn) do (turn: var Turn):
-          var res = ass.preservesTo Resolved
-          if res.isSome:
-            publish(turn, ds, ResolvedPathStep(
-                origin: origin.value,
-                pathStep: step,
-                resolved: res.get,
-              ))
-        proc action(turn: var Turn) =
-          stop(turn, facet)
-        result = action
-      publish(turn, origin.value, Resolve(
-          step: step,
-          observer: newCap(turn, during(duringCallback)),
-        ))
+  spawnStepResolver(turn, ds, "ref".toSymbol) do (
+      turn: var Turn, step: Value, origin: Cap, next: Cap):
+    publish(turn, ds, ResolvedPathStep(
+        origin: origin, pathStep: step, resolved: next.accepted))
 
 type BootProc* = proc (turn: var Turn; ds: Cap) {.gcsafe.}