2020-11-26 01:46:33 +03:00
|
|
|
!: :: %gall, agent execution
|
2019-08-29 21:44:37 +03:00
|
|
|
!? 163
|
2020-05-22 09:05:42 +03:00
|
|
|
::
|
2019-08-29 21:44:37 +03:00
|
|
|
::::
|
|
|
|
|= pit=vase
|
2019-11-19 07:36:21 +03:00
|
|
|
=, gall
|
2020-04-22 08:37:12 +03:00
|
|
|
=>
|
2019-08-29 21:44:37 +03:00
|
|
|
|%
|
2020-05-14 14:24:44 +03:00
|
|
|
+| %main
|
|
|
|
::
|
|
|
|
:: $move: Arvo-level move
|
2020-04-22 08:37:12 +03:00
|
|
|
::
|
|
|
|
+$ move [=duct move=(wind note-arvo gift-arvo)]
|
2020-08-26 18:15:48 +03:00
|
|
|
:: $state-7: overall gall state, versioned
|
2020-04-22 08:37:12 +03:00
|
|
|
::
|
2020-08-26 18:15:48 +03:00
|
|
|
+$ state-7 [%7 state]
|
2020-05-14 14:24:44 +03:00
|
|
|
:: $state: overall gall state
|
2020-04-22 08:37:12 +03:00
|
|
|
::
|
|
|
|
:: system-duct: TODO document
|
|
|
|
:: outstanding: outstanding request queue
|
|
|
|
:: contacts: other ships we're in communication with
|
|
|
|
:: yokes: running agents
|
|
|
|
:: blocked: moves to agents that haven't been started yet
|
|
|
|
::
|
|
|
|
+$ state
|
|
|
|
$: system-duct=duct
|
|
|
|
outstanding=(map [wire duct] (qeu remote-request))
|
|
|
|
contacts=(set ship)
|
|
|
|
yokes=(map term yoke)
|
|
|
|
blocked=(map term (qeu blocked-move))
|
|
|
|
==
|
2020-05-14 14:24:44 +03:00
|
|
|
:: $watches: subscribers and publications
|
2020-04-22 08:37:12 +03:00
|
|
|
::
|
|
|
|
:: TODO: rename this, to $ties?
|
|
|
|
:: TODO: rename $boat and $bitt and document
|
|
|
|
::
|
|
|
|
+$ watches [inbound=bitt outbound=boat]
|
2020-05-14 14:24:44 +03:00
|
|
|
:: $routes: new cuff; TODO: document
|
2020-04-22 08:37:12 +03:00
|
|
|
::
|
|
|
|
+$ routes
|
|
|
|
$: disclosing=(unit (set ship))
|
|
|
|
attributing=ship
|
|
|
|
==
|
2020-05-14 14:24:44 +03:00
|
|
|
:: $yoke: agent runner state
|
2020-04-22 08:37:12 +03:00
|
|
|
::
|
|
|
|
:: control-duct: TODO document
|
|
|
|
:: live: is this agent running? TODO document better
|
|
|
|
:: stats: TODO document
|
|
|
|
:: watches: incoming and outgoing subscription state
|
|
|
|
:: agent: agent core
|
|
|
|
:: beak: compilation source
|
2020-04-30 09:00:57 +03:00
|
|
|
:: marks: mark conversion requests
|
2020-04-22 08:37:12 +03:00
|
|
|
::
|
|
|
|
+$ yoke
|
|
|
|
$: control-duct=duct
|
2020-11-19 07:12:29 +03:00
|
|
|
nonce=@t
|
2020-04-22 08:37:12 +03:00
|
|
|
live=?
|
|
|
|
=stats
|
|
|
|
=watches
|
2020-11-17 23:53:05 +03:00
|
|
|
agent=(each agent vase)
|
2020-04-22 08:37:12 +03:00
|
|
|
=beak
|
|
|
|
marks=(map duct mark)
|
|
|
|
==
|
2020-05-14 14:24:44 +03:00
|
|
|
:: $blocked-move: enqueued move to an agent
|
2020-04-22 08:37:12 +03:00
|
|
|
::
|
2020-11-17 23:53:05 +03:00
|
|
|
+$ blocked-move [=duct =routes move=(each deal sign:agent)]
|
2020-05-14 14:24:44 +03:00
|
|
|
:: $stats: statistics
|
2020-04-22 08:37:12 +03:00
|
|
|
::
|
2020-05-14 14:24:44 +03:00
|
|
|
:: change: how many moves this agent has processed
|
|
|
|
:: eny: entropy
|
|
|
|
:: time: date of current event processing
|
2020-04-22 08:37:12 +03:00
|
|
|
::
|
|
|
|
+$ stats [change=@ud eny=@uvJ time=@da]
|
2020-05-14 14:24:44 +03:00
|
|
|
:: $ames-response: network response message (%boon)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-20 00:03:07 +03:00
|
|
|
:: %d: fact
|
2019-10-30 23:12:57 +03:00
|
|
|
:: %x: quit
|
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
+$ ames-response
|
2019-10-30 23:12:57 +03:00
|
|
|
$% [%d =mark noun=*]
|
2019-08-29 21:44:37 +03:00
|
|
|
[%x ~]
|
|
|
|
==
|
2020-05-14 14:24:44 +03:00
|
|
|
:: $ames-request: network request (%plea)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-10-30 23:12:57 +03:00
|
|
|
:: %m: poke
|
2019-11-20 00:03:07 +03:00
|
|
|
:: %l: watch-as
|
|
|
|
:: %s: watch
|
|
|
|
:: %u: leave
|
2019-10-30 23:12:57 +03:00
|
|
|
::
|
2020-12-01 07:12:43 +03:00
|
|
|
+$ ames-request-all
|
|
|
|
$% [%0 ames-request]
|
|
|
|
==
|
2020-04-22 08:37:12 +03:00
|
|
|
+$ ames-request
|
2019-10-30 23:12:57 +03:00
|
|
|
$% [%m =mark noun=*]
|
2019-08-29 21:44:37 +03:00
|
|
|
[%l =mark =path]
|
|
|
|
[%s =path]
|
|
|
|
[%u ~]
|
|
|
|
==
|
2020-05-14 14:24:44 +03:00
|
|
|
:: $remote-request: kinds of agent actions that can cross the network
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-10-30 23:12:57 +03:00
|
|
|
:: Used in wires to identify the kind of remote request we made.
|
|
|
|
:: Bijective with the tags of $ames-request.
|
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
+$ remote-request
|
2019-11-07 09:19:32 +03:00
|
|
|
$? %watch
|
2019-11-09 04:26:47 +03:00
|
|
|
%watch-as
|
2019-08-29 21:44:37 +03:00
|
|
|
%poke
|
2019-11-07 09:19:32 +03:00
|
|
|
%leave
|
2020-02-14 04:48:33 +03:00
|
|
|
%missing
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
2020-05-14 14:24:44 +03:00
|
|
|
:: |migrate: data structures for upgrades
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-05-14 14:24:44 +03:00
|
|
|
+| %migrate
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-05-14 14:24:44 +03:00
|
|
|
:: $spore: structures for update, produced by +stay
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-05-14 14:24:44 +03:00
|
|
|
+$ spore
|
2020-08-26 18:15:48 +03:00
|
|
|
$: %7
|
|
|
|
wipe-eyre-subs=_| ::NOTE band-aid for #3196, remove on next upgrade
|
2019-08-29 21:44:37 +03:00
|
|
|
system-duct=duct
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
outstanding=(map [wire duct] (qeu remote-request))
|
2019-10-30 23:12:57 +03:00
|
|
|
contacts=(set ship)
|
2020-05-14 14:24:44 +03:00
|
|
|
eggs=(map term egg)
|
|
|
|
blocked=(map term (qeu blocked-move))
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
2020-05-14 14:24:44 +03:00
|
|
|
:: $egg: migratory agent state; $yoke with .old-state instead of .agent
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-05-14 14:24:44 +03:00
|
|
|
+$ egg
|
|
|
|
$: control-duct=duct
|
2020-11-19 07:12:29 +03:00
|
|
|
nonce=@t
|
2019-08-29 21:44:37 +03:00
|
|
|
live=?
|
|
|
|
=stats
|
2020-05-14 14:24:44 +03:00
|
|
|
=watches
|
2020-11-17 23:53:05 +03:00
|
|
|
old-state=(each vase vase)
|
2019-08-29 21:44:37 +03:00
|
|
|
=beak
|
2019-09-12 05:55:31 +03:00
|
|
|
marks=(map duct mark)
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
|
|
|
--
|
2020-05-14 14:24:44 +03:00
|
|
|
:: pupal gall core, on upgrade
|
|
|
|
::
|
|
|
|
=< =* adult-gate .
|
2020-05-20 10:30:29 +03:00
|
|
|
=| =spore
|
2020-11-24 00:06:50 +03:00
|
|
|
|= [our=ship now=@da eny=@uvJ rof=roof]
|
2020-05-14 14:24:44 +03:00
|
|
|
=* pupal-gate .
|
|
|
|
=* adult-core (adult-gate +<)
|
2020-11-24 00:06:50 +03:00
|
|
|
=* ski (en-sley rof)
|
2020-05-20 10:30:29 +03:00
|
|
|
=< |%
|
|
|
|
++ call ^call
|
|
|
|
++ load ^load
|
|
|
|
++ scry ^scry
|
|
|
|
++ stay ^stay
|
|
|
|
++ take ^take
|
|
|
|
--
|
2020-05-14 14:24:44 +03:00
|
|
|
|%
|
2020-05-20 10:30:29 +03:00
|
|
|
++ molt
|
|
|
|
|= [=duct fec=(unit move)]
|
|
|
|
^- [(list move) _adult-gate]
|
|
|
|
~> %slog.[0 leaf+"gall: molting"]
|
|
|
|
~< %slog.[0 leaf+"gall: molted"]
|
2020-06-18 06:31:37 +03:00
|
|
|
:: +molt should never notify its client about agent changes
|
|
|
|
::
|
|
|
|
=- [(skip -< |=(move ?=([* %give %onto *] +<))) ->]
|
2020-05-20 10:30:29 +03:00
|
|
|
=/ adult adult-core
|
|
|
|
=. state.adult
|
2020-08-26 18:15:48 +03:00
|
|
|
[%7 system-duct outstanding contacts yokes=~ blocked]:spore
|
2020-05-20 10:30:29 +03:00
|
|
|
=/ mo-core (mo-abed:mo:adult duct)
|
|
|
|
=. mo-core
|
|
|
|
=/ apps=(list [dap=term =egg]) ~(tap by eggs.spore)
|
2020-08-26 18:15:48 +03:00
|
|
|
~? wipe-eyre-subs.spore
|
|
|
|
[%g %wiping-eyre-subs]
|
2020-05-20 10:30:29 +03:00
|
|
|
|- ^+ mo-core
|
|
|
|
?~ apps mo-core
|
|
|
|
~> %slog.[0 leaf+"gall: upgrading {<dap.i.apps>}"]
|
|
|
|
=/ ap-core (ap-abut:ap:mo-core i.apps)
|
2020-11-17 23:53:05 +03:00
|
|
|
=? ap-core ?=(%& -.old-state.egg.i.apps)
|
|
|
|
=^ tan ap-core (ap-install:ap-core `p.old-state.egg.i.apps)
|
|
|
|
?^ tan
|
|
|
|
(mean u.tan)
|
|
|
|
ap-core
|
2020-08-26 18:15:48 +03:00
|
|
|
=? ap-core wipe-eyre-subs.spore
|
|
|
|
=/ ducts=(list ^duct)
|
|
|
|
%+ skim ~(tap in ~(key by inbound.watches.egg.i.apps))
|
|
|
|
|= =^duct
|
|
|
|
%+ lien duct
|
|
|
|
|= =path
|
|
|
|
?=(^ (find /e/channel/subscription path))
|
|
|
|
|-
|
|
|
|
?~ ducts ap-core
|
|
|
|
=. ap-core
|
|
|
|
ap-load-delete:ap-core(agent-duct i.ducts)
|
|
|
|
$(ducts t.ducts)
|
2020-05-20 10:30:29 +03:00
|
|
|
$(apps t.apps, mo-core ap-abet:ap-core)
|
|
|
|
=. mo-core (mo-subscribe-to-agent-builds:mo-core now)
|
|
|
|
=^ moves adult-gate mo-abet:mo-core
|
|
|
|
=? moves ?=(^ fec) (weld moves [u.fec]~)
|
|
|
|
[moves adult-gate]
|
|
|
|
::
|
2020-05-14 14:24:44 +03:00
|
|
|
++ call
|
|
|
|
|= [=duct dud=(unit goof) typ=type wrapped-task=(hobo task:able)]
|
|
|
|
=* call-args +<
|
2020-05-20 10:30:29 +03:00
|
|
|
?: =(~ eggs.spore)
|
2020-05-14 14:24:44 +03:00
|
|
|
~> %slog.[0 leaf+"gall: direct morphogenesis"]
|
2020-08-26 18:15:48 +03:00
|
|
|
=. state.adult-gate [- +>]:spore(eggs *(map term yoke))
|
2020-05-14 14:24:44 +03:00
|
|
|
(call:adult-core call-args)
|
|
|
|
?^ dud
|
2020-05-20 10:30:29 +03:00
|
|
|
~> %slog.[0 leaf+"gall: pupa call dud"]
|
2020-05-14 14:24:44 +03:00
|
|
|
(mean >mote.u.dud< tang.u.dud)
|
|
|
|
=/ task ((harden task:able:gall) wrapped-task)
|
2020-05-20 10:30:29 +03:00
|
|
|
(molt duct `[duct %slip %g task])
|
|
|
|
::
|
2020-05-14 14:24:44 +03:00
|
|
|
++ scry scry:adult-core
|
|
|
|
++ stay ~|(%gall-subinvolution !!)
|
|
|
|
++ take
|
|
|
|
|= [=wire =duct dud=(unit goof) typ=type sign=sign-arvo]
|
|
|
|
=* take-args +<
|
2020-05-20 10:30:29 +03:00
|
|
|
?: =(~ eggs.spore)
|
2020-05-14 14:24:44 +03:00
|
|
|
~> %slog.[0 leaf+"gall: direct morphogenesis"]
|
2020-08-26 18:15:48 +03:00
|
|
|
=. state.adult-gate [- +>]:spore(eggs *(map term yoke))
|
2020-05-14 14:24:44 +03:00
|
|
|
(take:adult-core take-args)
|
|
|
|
?^ dud
|
|
|
|
~> %slog.[0 leaf+"gall: pupa take dud"]
|
|
|
|
(mean >mote.u.dud< tang.u.dud)
|
2020-05-20 10:30:29 +03:00
|
|
|
?: =(/sys/lyv wire)
|
|
|
|
(molt duct ~)
|
2020-07-08 09:08:27 +03:00
|
|
|
(molt duct `[duct %pass wire %b %huck sign])
|
2020-05-14 14:24:44 +03:00
|
|
|
::
|
|
|
|
++ load
|
2020-11-25 18:22:20 +03:00
|
|
|
|= old=^spore
|
|
|
|
=. spore old
|
2020-05-20 10:30:29 +03:00
|
|
|
?. =(~ eggs.spore)
|
2020-05-14 14:24:44 +03:00
|
|
|
pupal-gate
|
|
|
|
~> %slog.[0 leaf+"gall: direct morphogenesis"]
|
2020-08-26 18:15:48 +03:00
|
|
|
%_ adult-gate
|
|
|
|
state [- +>]:spore(eggs *(map term yoke))
|
|
|
|
==
|
2020-05-14 14:24:44 +03:00
|
|
|
--
|
|
|
|
:: adult gall vane interface, for type compatibility with pupa
|
|
|
|
::
|
2020-08-26 18:15:48 +03:00
|
|
|
=| state=state-7
|
2020-11-24 00:06:50 +03:00
|
|
|
|= [our=ship now=@da eny=@uvJ rof=roof]
|
2020-05-14 14:24:44 +03:00
|
|
|
=* gall-payload .
|
2020-11-24 00:06:50 +03:00
|
|
|
=* ski (en-sley rof)
|
2020-05-14 14:24:44 +03:00
|
|
|
=< ~% %gall-wrap ..mo ~
|
|
|
|
|%
|
|
|
|
++ call ^call
|
|
|
|
++ load ^load
|
|
|
|
++ scry ^scry
|
|
|
|
++ stay ^stay
|
|
|
|
++ take ^take
|
|
|
|
--
|
2019-11-19 07:36:21 +03:00
|
|
|
~% %gall-top ..is ~
|
2019-08-29 21:44:37 +03:00
|
|
|
|%
|
|
|
|
:: +mo: Arvo-level move handling
|
|
|
|
::
|
|
|
|
:: An outer core responsible for routing moves to and from Arvo; it calls
|
|
|
|
:: an inner core, +ap, to route internal moves to and from agents.
|
|
|
|
::
|
|
|
|
++ mo
|
2019-11-19 07:36:21 +03:00
|
|
|
~% %gall-mo +> ~
|
2020-04-22 08:37:12 +03:00
|
|
|
|_ [hen=duct moves=(list move)]
|
|
|
|
:: +mo-abed: initialise state with the provided duct
|
|
|
|
:: +mo-abet: finalize, reversing moves
|
|
|
|
:: +mo-pass: prepend a standard %pass to the current list of moves
|
|
|
|
:: +mo-give: prepend a standard %give to the current list of moves
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
++ mo-core .
|
|
|
|
++ mo-abed |=(hun=duct mo-core(hen hun))
|
|
|
|
++ mo-abet [(flop moves) gall-payload]
|
|
|
|
++ mo-pass |=(p=[wire note-arvo] mo-core(moves [[hen pass+p] moves]))
|
|
|
|
++ mo-give |=(g=gift:able mo-core(moves [[hen give+g] moves]))
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +mo-boot: ask %ford to build us a core for the specified agent.
|
|
|
|
::
|
|
|
|
++ mo-boot
|
2020-04-22 08:37:12 +03:00
|
|
|
|= [dap=term =ship =desk]
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ mo-core
|
|
|
|
=/ =case [%da now]
|
2020-04-22 08:37:12 +03:00
|
|
|
=/ =wire /sys/cor/[dap]/(scot %p ship)/[desk]/(scot case)
|
2020-04-22 12:27:36 +03:00
|
|
|
(mo-pass wire %c %warp ship desk ~ %sing %a case /app/[dap]/hoon)
|
2019-11-10 03:47:41 +03:00
|
|
|
:: +mo-reboot: ask %ford to rebuild the specified agent
|
|
|
|
::
|
|
|
|
++ mo-reboot
|
2020-04-22 08:37:12 +03:00
|
|
|
|= [dap=term =ship]
|
2019-11-10 03:47:41 +03:00
|
|
|
^+ mo-core
|
2020-04-22 08:37:12 +03:00
|
|
|
=/ gent (~(got by yokes.state) dap)
|
2019-11-10 03:47:41 +03:00
|
|
|
=* desk q.beak.gent
|
2020-04-22 08:37:12 +03:00
|
|
|
(mo-boot:(mo-abed control-duct.gent) dap ship desk)
|
2019-11-10 03:47:41 +03:00
|
|
|
:: +mo-goad: rebuild agent(s)
|
|
|
|
::
|
|
|
|
++ mo-goad
|
2020-04-22 08:37:12 +03:00
|
|
|
|= agent=(unit dude)
|
2019-11-10 03:47:41 +03:00
|
|
|
^+ mo-core
|
|
|
|
?^ agent
|
|
|
|
~| goad-gone+u.agent
|
2020-04-22 08:37:12 +03:00
|
|
|
(mo-reboot u.agent our)
|
|
|
|
=/ agents=(list term) ~(tap in ~(key by yokes.state))
|
2019-11-10 03:47:41 +03:00
|
|
|
|- ^+ mo-core
|
2020-04-22 08:37:12 +03:00
|
|
|
?~ agents mo-core
|
|
|
|
$(agents t.agents, mo-core (mo-reboot i.agents our))
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +mo-receive-core: receives an app core built by %ford.
|
|
|
|
::
|
|
|
|
:: Presuming we receive a good core, we first check to see if the agent
|
2019-11-19 07:36:21 +03:00
|
|
|
:: is already running. If so, we update its beak in %gall's state,
|
2019-08-29 21:44:37 +03:00
|
|
|
:: initialise an +ap core for the agent, install the core we got from
|
|
|
|
:: %ford, and then resolve any moves associated with it.
|
|
|
|
::
|
|
|
|
:: If we're dealing with a new agent, we create one using the result we
|
2019-11-19 07:36:21 +03:00
|
|
|
:: got from %ford, add it to the collection of agents %gall is keeping
|
2019-08-29 21:44:37 +03:00
|
|
|
:: track of, and then do more or less the same procedure as we did for the
|
|
|
|
:: running agent case.
|
|
|
|
::
|
|
|
|
++ mo-receive-core
|
|
|
|
~/ %mo-receive-core
|
2020-05-14 14:24:44 +03:00
|
|
|
|= [dap=term bek=beak =agent]
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ mo-core
|
|
|
|
::
|
2020-05-09 15:09:26 +03:00
|
|
|
=/ existing (~(get by yokes.state) dap)
|
|
|
|
=/ re ?~(existing "" "re")
|
|
|
|
~> %slog.[0 leaf+"gall: {re}loading {<dap>}"]
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-05-09 15:09:26 +03:00
|
|
|
?^ existing
|
2020-04-22 08:37:12 +03:00
|
|
|
=. yokes.state
|
|
|
|
(~(put by yokes.state) dap u.existing(beak bek))
|
2019-08-29 21:44:37 +03:00
|
|
|
=/ =routes [disclosing=~ attributing=our]
|
2020-04-22 01:50:47 +03:00
|
|
|
=/ ap-core (ap-abed:ap dap routes)
|
2020-04-22 08:37:12 +03:00
|
|
|
=. ap-core (ap-reinstall:ap-core agent)
|
2020-11-17 23:53:05 +03:00
|
|
|
=. mo-core ap-abet:ap-core
|
|
|
|
(mo-clear-queue dap)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
=. yokes.state
|
|
|
|
%+ ~(put by yokes.state) dap
|
2020-11-19 07:12:29 +03:00
|
|
|
%* . *yoke
|
|
|
|
control-duct hen
|
|
|
|
beak bek
|
|
|
|
agent &+agent
|
|
|
|
nonce (scot %uw (end 5 1 (shas %yoke-nonce eny)))
|
|
|
|
==
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
|
|
|
=/ old mo-core
|
|
|
|
=/ wag
|
|
|
|
=/ =routes [disclosing=~ attributing=our]
|
2020-04-22 01:50:47 +03:00
|
|
|
=/ ap-core (ap-abed:ap dap routes)
|
|
|
|
(ap-upgrade-state:ap-core ~)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
|
|
|
=/ maybe-tang -.wag
|
2020-04-22 01:50:47 +03:00
|
|
|
=/ ap-core +.wag
|
2019-08-29 21:44:37 +03:00
|
|
|
?^ maybe-tang
|
|
|
|
=. mo-core old
|
|
|
|
(mo-give %onto %.n u.maybe-tang)
|
|
|
|
::
|
2020-04-22 01:50:47 +03:00
|
|
|
=. mo-core ap-abet:ap-core
|
|
|
|
=. mo-core (mo-clear-queue dap)
|
|
|
|
=/ =suss [dap %boot now]
|
2019-08-29 21:44:37 +03:00
|
|
|
(mo-give %onto [%.y suss])
|
2020-04-24 07:13:19 +03:00
|
|
|
:: +mo-subscribe-to-agent-builds: request agent update notices
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-05-14 14:24:44 +03:00
|
|
|
:: Also subscribe to our own source path, in case we get reloaded
|
|
|
|
:: but none of the agents do. This way, Clay will still notify us,
|
|
|
|
:: and we'll be able to exit the chrysalis.
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-24 07:13:19 +03:00
|
|
|
++ mo-subscribe-to-agent-builds
|
|
|
|
|= date=@da
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ mo-core
|
2020-04-24 07:13:19 +03:00
|
|
|
=. mo-core (mo-abed system-duct.state)
|
2020-05-14 14:24:44 +03:00
|
|
|
=/ =wire /sys/lyv
|
2020-04-24 07:13:19 +03:00
|
|
|
=. mo-core (mo-pass /sys/lyv %c %warp our %home ~)
|
|
|
|
=/ =mool:clay
|
|
|
|
:- da+date
|
|
|
|
%- ~(gas in *(set [care:clay path]))
|
2020-05-17 10:22:51 +03:00
|
|
|
:* [%z /sys/hoon/hoon]
|
|
|
|
[%z /sys/arvo/hoon]
|
|
|
|
[%z /sys/zuse/hoon]
|
|
|
|
[%z /sys/vane/gall/hoon]
|
2020-11-17 23:53:05 +03:00
|
|
|
%+ murn ~(tap by yokes.state)
|
|
|
|
|= [dap=term =yoke]
|
|
|
|
^- (unit [care:clay path])
|
|
|
|
?: ?=(%| -.agent.yoke)
|
|
|
|
~
|
|
|
|
`[%a /app/[dap]/hoon]
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
2020-04-24 07:13:19 +03:00
|
|
|
(mo-pass wire %c %warp our %home ~ %mult mool)
|
2020-05-14 14:24:44 +03:00
|
|
|
:: +mo-scry-agent-cage: read $agent core from clay
|
|
|
|
::
|
|
|
|
++ mo-scry-agent-cage
|
|
|
|
|= [dap=term =case:clay]
|
|
|
|
^- (each agent tang)
|
|
|
|
=/ bek=beak [our %home case]
|
2020-11-22 00:04:18 +03:00
|
|
|
=/ sky (ski [%141 %noun] ~ %ca bek /app/[dap]/hoon)
|
2020-05-14 14:24:44 +03:00
|
|
|
?~ sky |+[leaf+"gall: {<dap>} scry blocked"]~
|
|
|
|
?~ u.sky |+[leaf+"gall: {<dap>} scry failed"]~
|
|
|
|
=/ =cage u.u.sky
|
|
|
|
?. =(%vase p.cage)
|
|
|
|
|+[leaf+"gall: bad mark {<p.cage>} for agent {<dap>}"]~
|
|
|
|
=/ res (mule |.(!<(agent !<(vase q.cage))))
|
|
|
|
?: ?=(%& -.res)
|
|
|
|
&+p.res
|
|
|
|
|+[[leaf+"gall: {<dap>} not valid agent"] p.res]
|
2019-11-20 00:03:07 +03:00
|
|
|
:: +mo-send-foreign-request: handle local request to .ship
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-10-30 23:12:57 +03:00
|
|
|
++ mo-send-foreign-request
|
|
|
|
~/ %mo-send-foreign-request
|
2019-11-20 00:03:07 +03:00
|
|
|
|= [=ship foreign-agent=term =deal]
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ mo-core
|
|
|
|
::
|
2019-11-04 04:35:45 +03:00
|
|
|
=. mo-core (mo-track-ship ship)
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
?< ?=(?(%raw-poke %poke-as) -.deal)
|
2020-12-01 07:12:43 +03:00
|
|
|
=/ =ames-request-all
|
|
|
|
:- %0
|
2019-11-09 04:26:47 +03:00
|
|
|
?- -.deal
|
|
|
|
%poke [%m p.cage.deal q.q.cage.deal]
|
|
|
|
%leave [%u ~]
|
2020-05-01 09:14:16 +03:00
|
|
|
%watch-as [%l [mark path]:deal]
|
2019-11-09 04:26:47 +03:00
|
|
|
%watch [%s path.deal]
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
|
|
|
::
|
2019-11-20 00:03:07 +03:00
|
|
|
=/ wire
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
/sys/way/(scot %p ship)/[foreign-agent]
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
|
|
|
=/ =note-arvo
|
2019-11-01 22:06:09 +03:00
|
|
|
=/ =path /ge/[foreign-agent]
|
2020-12-01 07:12:43 +03:00
|
|
|
[%a %plea ship %g path ames-request-all]
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
=. outstanding.state
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
=/ stand
|
2020-04-22 08:37:12 +03:00
|
|
|
(~(gut by outstanding.state) [wire hen] *(qeu remote-request))
|
|
|
|
(~(put by outstanding.state) [wire hen] (~(put to stand) -.deal))
|
2019-11-03 03:52:48 +03:00
|
|
|
(mo-pass wire note-arvo)
|
2019-11-04 04:35:45 +03:00
|
|
|
:: +mo-track-ship: subscribe to ames and jael for notices about .ship
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-04 04:35:45 +03:00
|
|
|
++ mo-track-ship
|
2019-10-30 23:12:57 +03:00
|
|
|
|= =ship
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ mo-core
|
2019-10-30 23:12:57 +03:00
|
|
|
:: if already contacted, no-op
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
?: (~(has in contacts.state) ship)
|
2019-11-05 07:19:08 +03:00
|
|
|
mo-core
|
2019-11-04 04:35:45 +03:00
|
|
|
:: first contact; update state and subscribe to notifications
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
=. contacts.state (~(put in contacts.state) ship)
|
2019-11-04 04:35:45 +03:00
|
|
|
:: ask ames to track .ship's connectivity
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
=. moves [[system-duct.state %pass /sys/lag %a %heed ship] moves]
|
2019-11-04 04:35:45 +03:00
|
|
|
:: ask jael to track .ship's breaches
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-10-30 23:12:57 +03:00
|
|
|
=/ =note-arvo [%j %public-keys (silt ship ~)]
|
|
|
|
=. moves
|
2020-04-22 08:37:12 +03:00
|
|
|
[[system-duct.state %pass /sys/era note-arvo] moves]
|
2019-10-30 23:12:57 +03:00
|
|
|
mo-core
|
2019-11-04 04:35:45 +03:00
|
|
|
:: +mo-untrack-ship: cancel subscriptions to ames and jael for .ship
|
2019-11-05 07:19:08 +03:00
|
|
|
::
|
2019-11-04 04:35:45 +03:00
|
|
|
++ mo-untrack-ship
|
2019-11-05 07:19:08 +03:00
|
|
|
|= =ship
|
|
|
|
^+ mo-core
|
2019-10-30 23:12:57 +03:00
|
|
|
:: if already canceled, no-op
|
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
?. (~(has in contacts.state) ship)
|
2019-10-30 23:12:57 +03:00
|
|
|
mo-core
|
2019-11-04 04:35:45 +03:00
|
|
|
:: delete .ship from state and kill subscriptions
|
2019-10-30 23:12:57 +03:00
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
=. contacts.state (~(del in contacts.state) ship)
|
2019-11-04 04:35:45 +03:00
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
=. moves [[system-duct.state %pass /sys/lag %a %jilt ship] moves]
|
2019-11-04 04:35:45 +03:00
|
|
|
::
|
2019-11-05 07:19:08 +03:00
|
|
|
=/ =note-arvo [%j %nuke (silt ship ~)]
|
|
|
|
=. moves
|
2020-04-22 08:37:12 +03:00
|
|
|
[[system-duct.state %pass /sys/era note-arvo] moves]
|
2019-11-05 07:19:08 +03:00
|
|
|
mo-core
|
|
|
|
:: +mo-breach: ship breached, so forget about them
|
|
|
|
::
|
|
|
|
++ mo-breach
|
|
|
|
|= =ship
|
|
|
|
^+ mo-core
|
2019-11-04 04:35:45 +03:00
|
|
|
=. mo-core (mo-untrack-ship ship)
|
2020-03-19 02:06:33 +03:00
|
|
|
=. mo-core (mo-filter-queue ship)
|
2020-04-22 08:37:12 +03:00
|
|
|
=/ agents=(list [name=term =yoke]) ~(tap by yokes.state)
|
2020-06-03 07:50:20 +03:00
|
|
|
=. outstanding.state
|
2020-05-08 07:15:35 +03:00
|
|
|
%- malt
|
2020-06-03 07:50:20 +03:00
|
|
|
%+ skip ~(tap by outstanding.state)
|
2020-05-08 07:15:35 +03:00
|
|
|
|= [[=wire duct] (qeu remote-request)]
|
|
|
|
=(/sys/way/(scot %p ship) (scag 3 wire))
|
|
|
|
::
|
2019-11-05 07:19:08 +03:00
|
|
|
|- ^+ mo-core
|
|
|
|
?~ agents
|
|
|
|
mo-core
|
|
|
|
=. mo-core
|
|
|
|
=/ =routes [disclosing=~ attributing=ship]
|
|
|
|
=/ app (ap-abed:ap name.i.agents routes)
|
|
|
|
ap-abet:(ap-breach:app ship)
|
|
|
|
$(agents t.agents)
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +mo-handle-sys: handle a +sign incoming over /sys.
|
|
|
|
::
|
|
|
|
:: (Note that /sys implies the +sign should be routed to a vane.)
|
|
|
|
::
|
|
|
|
++ mo-handle-sys
|
|
|
|
~/ %mo-handle-sys
|
|
|
|
|= [=path =sign-arvo]
|
|
|
|
^+ mo-core
|
|
|
|
::
|
|
|
|
?+ -.path !!
|
2020-04-24 07:13:19 +03:00
|
|
|
%lyv (mo-handle-sys-lyv path sign-arvo)
|
2019-11-04 04:35:45 +03:00
|
|
|
%era (mo-handle-sys-era path sign-arvo)
|
|
|
|
%cor (mo-handle-sys-cor path sign-arvo)
|
|
|
|
%lag (mo-handle-sys-lag path sign-arvo)
|
|
|
|
%req (mo-handle-sys-req path sign-arvo)
|
|
|
|
%way (mo-handle-sys-way path sign-arvo)
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
2019-11-04 04:35:45 +03:00
|
|
|
:: +mo-handle-sys-era: receive update about contact
|
2019-11-05 07:19:08 +03:00
|
|
|
::
|
2019-11-04 04:35:45 +03:00
|
|
|
++ mo-handle-sys-era
|
2019-11-05 07:19:08 +03:00
|
|
|
|= [=path =sign-arvo]
|
|
|
|
^+ mo-core
|
|
|
|
?> ?=([%j %public-keys *] sign-arvo)
|
2019-11-20 00:03:07 +03:00
|
|
|
?> ?=([%era ~] path)
|
2019-11-05 07:19:08 +03:00
|
|
|
?. ?=(%breach -.public-keys-result.sign-arvo)
|
|
|
|
mo-core
|
|
|
|
(mo-breach who.public-keys-result.sign-arvo)
|
2020-04-24 07:13:19 +03:00
|
|
|
:: +mo-handle-sys-cor: receive a built agent from %clay
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-04 04:35:45 +03:00
|
|
|
++ mo-handle-sys-cor
|
2019-08-29 21:44:37 +03:00
|
|
|
|= [=path =sign-arvo]
|
|
|
|
^+ mo-core
|
|
|
|
::
|
2019-11-04 04:35:45 +03:00
|
|
|
?> ?=([%cor @ @ @ @ ~] path)
|
2020-04-22 08:37:12 +03:00
|
|
|
=/ [dap=term her=@ta desk=@ta dat=@ta ~] t.path
|
2020-04-24 07:13:19 +03:00
|
|
|
=/ tim (slav da+dat)
|
|
|
|
=/ =beak [(slav %p her) desk da+tim]
|
2020-04-22 08:37:12 +03:00
|
|
|
?> ?=([?(%b %c) %writ *] sign-arvo)
|
2020-06-13 07:16:09 +03:00
|
|
|
|^ ^+ mo-core
|
|
|
|
?~ p.sign-arvo
|
|
|
|
(fail leaf+"gall: failed to build agent {<dap>}" ~)
|
|
|
|
=/ cag=cage r.u.p.sign-arvo
|
|
|
|
?. =(%vase p.cag)
|
|
|
|
(fail leaf+"gall: bad %writ {<p.cag>} for {<dap>}" ~)
|
|
|
|
=/ res (mule |.(!<(agent !<(vase q.cag))))
|
|
|
|
?: ?=(%| -.res)
|
|
|
|
(fail leaf+["gall: bad agent {<dap>}"] p.res)
|
|
|
|
=. mo-core (mo-receive-core dap beak p.res)
|
|
|
|
(mo-subscribe-to-agent-builds tim)
|
|
|
|
::
|
|
|
|
++ fail
|
|
|
|
|= =tang
|
|
|
|
^+ mo-core
|
|
|
|
=. mo-core (mo-give %onto |+tang)
|
|
|
|
=/ =case [%da tim]
|
|
|
|
=/ =wire /sys/cor/[dap]/[her]/[desk]/(scot case)
|
|
|
|
(mo-pass wire %c %warp p.beak desk ~ %next %a case /app/[dap]/hoon)
|
|
|
|
--
|
2020-05-09 15:09:26 +03:00
|
|
|
:: +mo-handle-sys-lyv: handle notice that agents have been rebuilt
|
2020-04-24 07:13:19 +03:00
|
|
|
::
|
|
|
|
++ mo-handle-sys-lyv
|
|
|
|
|= [=path =sign-arvo]
|
|
|
|
^+ mo-core
|
|
|
|
?> ?=([%lyv ~] path)
|
|
|
|
?> ?=([?(%b %c) %wris *] sign-arvo)
|
|
|
|
=/ bek=beak [our %home p.sign-arvo]
|
|
|
|
=/ nex=(list [=care:clay =^path]) ~(tap in q.sign-arvo)
|
2020-05-09 15:09:26 +03:00
|
|
|
~> %slog.[0 leaf+"gall: reloading agents"]
|
|
|
|
~< %slog.[0 leaf+"gall: reloaded agents"]
|
2020-04-24 07:13:19 +03:00
|
|
|
=; cor (mo-subscribe-to-agent-builds:cor p.p.sign-arvo)
|
|
|
|
%+ roll nex
|
|
|
|
|= [[=care:clay =^path] cor=_mo-core]
|
|
|
|
^+ cor
|
2020-07-22 01:42:46 +03:00
|
|
|
:: We throw away %z results because we only have them to guarantee
|
|
|
|
:: molting. Clay will tell us if e.g. changing hoon.hoon affects
|
|
|
|
:: the result of a particular app (usually it will).
|
|
|
|
::
|
|
|
|
?. =(%a care)
|
|
|
|
cor
|
2020-04-24 07:13:19 +03:00
|
|
|
=/ dap dap:;;([%app dap=@tas %hoon ~] path)
|
2020-05-14 14:24:44 +03:00
|
|
|
=/ rag (mo-scry-agent-cage dap p.sign-arvo)
|
|
|
|
?: ?=(%| -.rag)
|
|
|
|
(mean p.rag)
|
|
|
|
(mo-receive-core:cor dap bek p.rag)
|
2019-11-04 04:35:45 +03:00
|
|
|
:: +mo-handle-sys-lag: handle an ames %clog notification
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-04 04:35:45 +03:00
|
|
|
++ mo-handle-sys-lag
|
2019-08-29 21:44:37 +03:00
|
|
|
|= [=path =sign-arvo]
|
|
|
|
^+ mo-core
|
|
|
|
::
|
2019-11-04 04:35:45 +03:00
|
|
|
?> ?=([%lag ~] path)
|
|
|
|
?> ?=([%a %clog *] sign-arvo)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
=/ agents=(list term) ~(tap in ~(key by yokes.state))
|
2019-11-04 04:35:45 +03:00
|
|
|
|- ^+ mo-core
|
|
|
|
?~ agents mo-core
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-04 04:35:45 +03:00
|
|
|
=. mo-core
|
|
|
|
=/ =routes [disclosing=~ attributing=our]
|
|
|
|
=/ app (ap-abed:ap i.agents routes)
|
|
|
|
ap-abet:(ap-clog:app ship.sign-arvo)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-04 04:35:45 +03:00
|
|
|
$(agents t.agents)
|
2019-10-30 23:12:57 +03:00
|
|
|
:: +mo-handle-sys-req: TODO description
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-10-30 23:12:57 +03:00
|
|
|
:: TODO: what should we do if the remote nacks our %pull?
|
2019-08-29 21:44:37 +03:00
|
|
|
++ mo-handle-sys-req
|
|
|
|
|= [=path =sign-arvo]
|
|
|
|
^+ mo-core
|
|
|
|
::
|
2019-11-03 03:52:48 +03:00
|
|
|
?> ?=([%req @ @ ~] path)
|
2019-08-29 21:44:37 +03:00
|
|
|
=/ him (slav %p i.t.path)
|
|
|
|
=/ dap i.t.t.path
|
|
|
|
::
|
2019-11-21 00:22:36 +03:00
|
|
|
?> ?=([?(%g %b) %unto *] sign-arvo)
|
2019-11-09 10:31:11 +03:00
|
|
|
=/ =sign:agent +>.sign-arvo
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-09 10:31:11 +03:00
|
|
|
?- -.sign
|
2019-09-12 05:55:31 +03:00
|
|
|
%poke-ack
|
2019-10-30 23:12:57 +03:00
|
|
|
=/ err=(unit error:ames)
|
2019-11-20 00:03:07 +03:00
|
|
|
?~ p.sign ~
|
|
|
|
`[%poke-ack u.p.sign]
|
2019-10-30 23:12:57 +03:00
|
|
|
(mo-give %done err)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-07 09:19:32 +03:00
|
|
|
%fact
|
2019-11-20 00:03:07 +03:00
|
|
|
=+ [mark noun]=[p q.q]:cage.sign
|
2019-11-01 23:18:51 +03:00
|
|
|
(mo-give %boon %d mark noun)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-07 09:19:32 +03:00
|
|
|
%kick
|
2019-11-01 23:18:51 +03:00
|
|
|
(mo-give %boon %x ~)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-07 09:19:32 +03:00
|
|
|
%watch-ack
|
2019-10-30 23:12:57 +03:00
|
|
|
=/ err=(unit error:ames)
|
2019-11-20 00:03:07 +03:00
|
|
|
?~ p.sign ~
|
2019-11-27 05:18:44 +03:00
|
|
|
`[%watch-ack u.p.sign]
|
2019-10-30 23:12:57 +03:00
|
|
|
(mo-give %done err)
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
2019-10-30 23:12:57 +03:00
|
|
|
:: +mo-handle-sys-way: handle response to outgoing remote request
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
|
|
|
++ mo-handle-sys-way
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
|= [=wire =sign-arvo]
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ mo-core
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
?> ?=([%way @ @ $@(~ [@ ~])] wire)
|
|
|
|
=/ =ship (slav %p i.t.wire)
|
|
|
|
=/ foreign-agent i.t.t.wire
|
2019-10-30 23:12:57 +03:00
|
|
|
::
|
|
|
|
?+ sign-arvo !!
|
|
|
|
[%a %done *]
|
2020-04-22 08:37:12 +03:00
|
|
|
=^ remote-request outstanding.state
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
?~ t.t.t.wire
|
2020-02-14 02:12:07 +03:00
|
|
|
=/ full-wire sys+wire
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
=/ stand
|
2020-06-12 16:29:10 +03:00
|
|
|
(~(gut by outstanding.state) [full-wire hen] ~)
|
2020-06-05 04:09:01 +03:00
|
|
|
::
|
|
|
|
:: default is to send both ack types; should only hit if
|
|
|
|
:: cleared queue in +load 3-to-4 or +load-4-to-5
|
|
|
|
::
|
|
|
|
=? stand ?=(~ stand)
|
2020-02-14 04:48:33 +03:00
|
|
|
(~(put to *(qeu remote-request)) %missing)
|
2020-06-05 04:09:01 +03:00
|
|
|
~| [full-wire=full-wire hen=hen stand=stand]
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
=^ rr stand ~(get to stand)
|
2020-04-22 08:37:12 +03:00
|
|
|
[rr (~(put by outstanding.state) [full-wire hen] stand)]
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
:: non-null case of wire is old, remove on next breach after
|
|
|
|
:: 2019/12
|
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
[;;(remote-request i.t.t.t.wire) outstanding.state]
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
::
|
2019-10-30 23:12:57 +03:00
|
|
|
=/ err=(unit tang)
|
|
|
|
?~ error=error.sign-arvo
|
|
|
|
~
|
|
|
|
`[[%leaf (trip tag.u.error)] tang.u.error]
|
2019-06-29 04:13:32 +03:00
|
|
|
::
|
2019-11-20 00:03:07 +03:00
|
|
|
?- remote-request
|
|
|
|
%watch-as (mo-give %unto %watch-ack err)
|
|
|
|
%watch (mo-give %unto %watch-ack err)
|
|
|
|
%poke (mo-give %unto %poke-ack err)
|
|
|
|
%leave mo-core
|
2020-02-14 04:48:33 +03:00
|
|
|
%missing (mo-give:(mo-give %unto %watch-ack err) %unto %poke-ack err)
|
2016-12-16 09:34:01 +03:00
|
|
|
==
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-10-30 23:12:57 +03:00
|
|
|
[%a %boon *]
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
?^ t.t.t.wire
|
|
|
|
:: kill subscriptions which use the old wire format
|
|
|
|
::
|
|
|
|
!!
|
2019-10-30 23:12:57 +03:00
|
|
|
=/ =ames-response ;;(ames-response payload.sign-arvo)
|
2019-11-04 04:35:45 +03:00
|
|
|
(mo-handle-ames-response ames-response)
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-10-30 23:12:57 +03:00
|
|
|
[%a %lost *]
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
:: note this should only happen on reverse bones, so only facts
|
|
|
|
:: and kicks
|
|
|
|
::
|
|
|
|
=/ sys-wire [%sys wire]
|
2019-11-20 00:03:07 +03:00
|
|
|
:: TODO: %drip %kick so app crash can't kill the remote %pull
|
2019-08-28 06:12:56 +03:00
|
|
|
::
|
2020-12-01 07:12:43 +03:00
|
|
|
=/ =ames-request-all [%0 %u ~]
|
|
|
|
=. mo-core
|
|
|
|
(mo-pass sys-wire %a %plea ship %g /ge/[foreign-agent] ames-request-all)
|
2019-12-03 00:35:05 +03:00
|
|
|
=. mo-core (mo-give %unto %kick ~)
|
2019-10-30 23:12:57 +03:00
|
|
|
mo-core
|
2016-11-24 07:25:07 +03:00
|
|
|
==
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +mo-handle-use: handle a typed +sign incoming on /use.
|
|
|
|
::
|
|
|
|
:: (Note that /use implies the +sign should be routed to an agent.)
|
|
|
|
::
|
2019-11-20 00:03:07 +03:00
|
|
|
:: Initialises the specified agent and then performs an agent-level
|
|
|
|
:: +take on the supplied +sign.
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
|
|
|
++ mo-handle-use
|
|
|
|
~/ %mo-handle-use
|
2020-07-08 09:08:27 +03:00
|
|
|
|= [=path =sign-arvo]
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ mo-core
|
|
|
|
::
|
2020-11-19 07:12:29 +03:00
|
|
|
?. ?=([@ @ @ *] path)
|
2019-08-29 21:44:37 +03:00
|
|
|
~& [%mo-handle-use-bad-path path]
|
|
|
|
!!
|
|
|
|
::
|
2020-11-17 23:53:05 +03:00
|
|
|
=/ dap=term i.path
|
|
|
|
=/ yoke (~(get by yokes.state) dap)
|
|
|
|
?~ yoke
|
|
|
|
%- (slog leaf+"gall: {<dap>} dead, got {<+<.sign-arvo>}" ~)
|
|
|
|
mo-core
|
2020-11-19 07:12:29 +03:00
|
|
|
?. =(nonce.u.yoke i.t.path)
|
|
|
|
%- (slog leaf+"gall: got old {<+<.sign-arvo>} for {<dap>}" ~)
|
|
|
|
mo-core
|
2019-11-21 00:22:36 +03:00
|
|
|
?. ?=([?(%g %b) %unto *] sign-arvo)
|
2020-11-17 23:53:05 +03:00
|
|
|
?: ?=(%| -.agent.u.yoke)
|
|
|
|
%- (slog leaf+"gall: {<dap>} dozing, dropping {<+<.sign-arvo>}" ~)
|
|
|
|
mo-core
|
2019-11-08 01:46:06 +03:00
|
|
|
=/ app
|
2020-11-19 07:12:29 +03:00
|
|
|
=/ =ship (slav %p i.t.t.path)
|
2019-11-08 01:46:06 +03:00
|
|
|
=/ =routes [disclosing=~ attributing=ship]
|
2020-11-17 23:53:05 +03:00
|
|
|
(ap-abed:ap dap routes)
|
2019-11-08 01:46:06 +03:00
|
|
|
::
|
2020-11-19 07:12:29 +03:00
|
|
|
=. app (ap-generic-take:app t.t.t.path sign-arvo)
|
2019-08-29 21:44:37 +03:00
|
|
|
ap-abet:app
|
2020-11-17 23:53:05 +03:00
|
|
|
?> ?=([%out @ @ *] t.t.path)
|
|
|
|
=/ =ship (slav %p i.t.t.t.path)
|
|
|
|
=/ =routes [disclosing=~ attributing=ship]
|
2019-11-09 10:31:11 +03:00
|
|
|
=/ =sign:agent +>.sign-arvo
|
2020-11-17 23:53:05 +03:00
|
|
|
?: ?=(%| -.agent.u.yoke)
|
|
|
|
=/ blocked=(qeu blocked-move)
|
|
|
|
=/ waiting (~(get by blocked.state) dap)
|
|
|
|
=/ deals (fall waiting *(qeu blocked-move))
|
|
|
|
=/ deal [hen routes |+sign]
|
|
|
|
(~(put to deals) deal)
|
|
|
|
::
|
|
|
|
%- (slog leaf+"gall: {<dap>} dozing, got {<-.sign>}" ~)
|
|
|
|
%_ mo-core
|
|
|
|
blocked.state (~(put by blocked.state) dap blocked)
|
|
|
|
==
|
|
|
|
=/ app (ap-abed:ap dap routes)
|
2019-09-06 04:18:31 +03:00
|
|
|
=. app
|
2019-11-09 10:31:11 +03:00
|
|
|
(ap-specific-take:app t.t.path sign)
|
2019-09-06 04:18:31 +03:00
|
|
|
ap-abet:app
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +mo-clear-queue: clear blocked tasks from the specified running agent.
|
|
|
|
::
|
|
|
|
++ mo-clear-queue
|
2020-04-22 08:37:12 +03:00
|
|
|
|= dap=term
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ mo-core
|
2020-04-22 08:37:12 +03:00
|
|
|
?. (~(has by yokes.state) dap)
|
2019-08-29 21:44:37 +03:00
|
|
|
mo-core
|
2020-04-22 08:37:12 +03:00
|
|
|
?~ maybe-blocked=(~(get by blocked.state) dap)
|
2019-08-29 21:44:37 +03:00
|
|
|
mo-core
|
2020-04-22 08:37:12 +03:00
|
|
|
=/ blocked=(qeu blocked-move) u.maybe-blocked
|
2019-08-29 21:44:37 +03:00
|
|
|
|- ^+ mo-core
|
|
|
|
?: =(~ blocked)
|
2020-04-22 08:37:12 +03:00
|
|
|
=. blocked.state (~(del by blocked.state) dap)
|
|
|
|
mo-core
|
2020-11-17 23:53:05 +03:00
|
|
|
=^ [=duct =routes blocker=(each deal sign:agent)] blocked
|
|
|
|
~(get to blocked)
|
|
|
|
=/ =move
|
2019-08-29 21:44:37 +03:00
|
|
|
=/ =sock [attributing.routes our]
|
2020-11-17 23:53:05 +03:00
|
|
|
=/ card
|
|
|
|
?: ?=(%& -.blocker)
|
|
|
|
[%slip %g %deal sock dap p.blocker]
|
|
|
|
[%pass /clear-huck %b %huck %g %unto p.blocker]
|
2019-08-29 21:44:37 +03:00
|
|
|
[duct card]
|
|
|
|
$(moves [move moves])
|
2020-03-19 02:06:33 +03:00
|
|
|
:: +mo-filter-queue: remove all blocked tasks from ship.
|
|
|
|
::
|
|
|
|
++ mo-filter-queue
|
|
|
|
|= =ship
|
2020-04-22 08:37:12 +03:00
|
|
|
=/ agents=(list [name=term blocked=(qeu blocked-move)])
|
|
|
|
~(tap by blocked.state)
|
|
|
|
=| new-agents=(map term (qeu blocked-move))
|
2020-03-19 02:06:33 +03:00
|
|
|
|- ^+ mo-core
|
|
|
|
?~ agents
|
2020-04-22 08:37:12 +03:00
|
|
|
mo-core(blocked.state new-agents)
|
|
|
|
=| new-blocked=(qeu blocked-move)
|
2020-03-19 02:06:33 +03:00
|
|
|
|- ^+ mo-core
|
|
|
|
?: =(~ blocked.i.agents)
|
|
|
|
?~ new-blocked
|
|
|
|
^$(agents t.agents)
|
|
|
|
%= ^$
|
|
|
|
agents t.agents
|
|
|
|
new-agents (~(put by new-agents) name.i.agents new-blocked)
|
|
|
|
==
|
2020-04-22 08:37:12 +03:00
|
|
|
=^ mov=blocked-move blocked.i.agents ~(get to blocked.i.agents)
|
|
|
|
=? new-blocked !=(ship attributing.routes.mov)
|
2020-03-19 02:06:33 +03:00
|
|
|
(~(put to new-blocked) mov)
|
|
|
|
$
|
2020-11-10 09:26:13 +03:00
|
|
|
:: +mo-fade: put app to sleep
|
|
|
|
::
|
|
|
|
++ mo-fade
|
2020-11-26 01:46:33 +03:00
|
|
|
|= [dap=term style=?(%slay %idle %jolt)]
|
2020-11-10 09:26:13 +03:00
|
|
|
^+ mo-core
|
|
|
|
=/ =routes [disclosing=~ attributing=our]
|
|
|
|
=/ app (ap-abed:ap dap routes)
|
|
|
|
=. mo-core ap-abet:(ap-fade:app style)
|
2020-11-19 07:39:58 +03:00
|
|
|
=. mo-core
|
|
|
|
?- style
|
2020-11-26 01:46:33 +03:00
|
|
|
%slay mo-core(yokes.state (~(del by yokes.state) dap))
|
|
|
|
%idle mo-core
|
|
|
|
%jolt (mo-boot dap our %home)
|
2020-11-19 07:39:58 +03:00
|
|
|
==
|
2020-11-26 01:46:33 +03:00
|
|
|
=? mo-core !?=(%jolt style) (mo-subscribe-to-agent-builds now)
|
2020-11-19 07:39:58 +03:00
|
|
|
mo-core
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +mo-beak: assemble a beak for the specified agent.
|
|
|
|
::
|
|
|
|
++ mo-beak
|
2020-04-22 08:37:12 +03:00
|
|
|
|= dap=term
|
2019-08-29 21:44:37 +03:00
|
|
|
^- beak
|
2020-04-22 08:37:12 +03:00
|
|
|
?^ yoke=(~(get by yokes.state) dap)
|
|
|
|
beak.u.yoke
|
|
|
|
:: XX this fallback is necessary, as .term could be either the source
|
|
|
|
:: or the destination app. ie, it might not exist locally ...
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
[our %home %da now]
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +mo-peek: call to +ap-peek (which is not accessible outside of +mo).
|
|
|
|
::
|
|
|
|
++ mo-peek
|
|
|
|
~/ %mo-peek
|
2020-04-22 08:37:12 +03:00
|
|
|
|= [dap=term =routes care=term =path]
|
2019-08-29 21:44:37 +03:00
|
|
|
^- (unit (unit cage))
|
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
=/ app (ap-abed:ap dap routes)
|
2020-04-22 13:49:23 +03:00
|
|
|
(ap-peek:app care path)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
|
|
|
++ mo-apply
|
2020-04-22 12:27:36 +03:00
|
|
|
|= [dap=term =routes =deal]
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ mo-core
|
2020-04-30 11:15:28 +03:00
|
|
|
?- -.deal
|
|
|
|
?(%watch %watch-as %leave %poke)
|
|
|
|
(mo-apply-sure dap routes deal)
|
|
|
|
::
|
|
|
|
%raw-poke
|
|
|
|
=/ =case:clay da+now
|
|
|
|
=/ sky (ski [%141 %noun] ~ %cb [our %home case] /[mark.deal])
|
|
|
|
?- sky
|
|
|
|
?(~ [~ ~])
|
|
|
|
=/ ror "gall: raw-poke fail :{(trip dap)} {<mark.deal>}"
|
|
|
|
(mo-give %unto %poke-ack `[leaf+ror]~)
|
2020-04-22 08:37:12 +03:00
|
|
|
::
|
2020-04-30 11:15:28 +03:00
|
|
|
[~ ~ *]
|
|
|
|
=+ !<(=dais:clay q.u.u.sky)
|
|
|
|
=/ res (mule |.((vale:dais noun.deal)))
|
|
|
|
?: ?=(%| -.res)
|
|
|
|
=/ ror "gall: raw-poke vale fail :{(trip dap)} {<mark.deal>}"
|
|
|
|
(mo-give %unto %poke-ack `[leaf+ror p.res])
|
|
|
|
=. mo-core
|
|
|
|
%+ mo-pass /nowhere
|
|
|
|
[%c %warp our %home ~ %sing %b case /[mark.deal]]
|
|
|
|
(mo-apply-sure dap routes [%poke mark.deal p.res])
|
2020-04-07 02:40:35 +03:00
|
|
|
==
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-30 11:15:28 +03:00
|
|
|
%poke-as
|
|
|
|
=/ =case:clay da+now
|
|
|
|
=/ =mars:clay [p.cage mark]:deal
|
2020-05-01 09:14:16 +03:00
|
|
|
=/ mars-path /[a.mars]/[b.mars]
|
2020-11-22 00:04:18 +03:00
|
|
|
=/ sky (ski [%141 %noun] ~ %cc [our %home case] mars-path)
|
2020-04-30 11:15:28 +03:00
|
|
|
?- sky
|
|
|
|
?(~ [~ ~])
|
|
|
|
=/ ror "gall: poke cast fail :{(trip dap)} {<mars>}"
|
|
|
|
(mo-give %unto %poke-ack `[leaf+ror]~)
|
|
|
|
::
|
|
|
|
[~ ~ *]
|
|
|
|
=+ !<(=tube:clay q.u.u.sky)
|
|
|
|
=/ res (mule |.((tube q.cage.deal)))
|
|
|
|
?: ?=(%| -.res)
|
|
|
|
=/ ror "gall: poke-as cast fail :{(trip dap)} {<mars>}"
|
|
|
|
(mo-give %unto %poke-ack `[leaf+ror p.res])
|
|
|
|
=. mo-core
|
|
|
|
%+ mo-pass /nowhere
|
|
|
|
[%c %warp our %home ~ %sing %c case /[a.mars]/[b.mars]]
|
|
|
|
(mo-apply-sure dap routes [%poke mark.deal p.res])
|
|
|
|
==
|
|
|
|
==
|
|
|
|
::
|
|
|
|
++ mo-apply-sure
|
|
|
|
|= [dap=term =routes =deal]
|
|
|
|
^+ mo-core
|
2020-04-22 12:27:36 +03:00
|
|
|
=/ app (ap-abed:ap dap routes)
|
2019-11-09 04:26:47 +03:00
|
|
|
=. app (ap-apply:app deal)
|
2019-08-29 21:44:37 +03:00
|
|
|
ap-abet:app
|
|
|
|
:: +mo-handle-local: handle locally.
|
|
|
|
::
|
2020-11-17 23:53:05 +03:00
|
|
|
:: If the agent is not running or blocked, assign it the supplied
|
|
|
|
:: +deal. Otherwise simply apply the action to the agent.
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
|
|
|
++ mo-handle-local
|
2019-11-20 00:03:07 +03:00
|
|
|
|= [=ship agent=term =deal]
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ mo-core
|
|
|
|
::
|
|
|
|
=/ =routes [disclosing=~ attributing=ship]
|
2020-11-17 23:53:05 +03:00
|
|
|
=/ running (~(get by yokes.state) agent)
|
|
|
|
=/ is-running ?~(running %| ?=(%& -.agent.u.running))
|
2020-04-30 09:00:57 +03:00
|
|
|
=/ is-blocked (~(has by blocked.state) agent)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
|
|
|
?: |(!is-running is-blocked)
|
2020-04-30 09:00:57 +03:00
|
|
|
=/ blocked=(qeu blocked-move)
|
|
|
|
=/ waiting (~(get by blocked.state) agent)
|
|
|
|
=/ deals (fall waiting *(qeu blocked-move))
|
2020-11-17 23:53:05 +03:00
|
|
|
=/ deal [hen routes &+deal]
|
2019-11-09 04:26:47 +03:00
|
|
|
(~(put to deals) deal)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-12-04 03:41:29 +03:00
|
|
|
%- (slog leaf+"gall: not running {<agent>} yet, got {<-.deal>}" ~)
|
2019-08-29 21:44:37 +03:00
|
|
|
%_ mo-core
|
2020-04-30 09:00:57 +03:00
|
|
|
blocked.state (~(put by blocked.state) agent blocked)
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
2019-11-20 00:03:07 +03:00
|
|
|
(mo-apply agent routes deal)
|
|
|
|
:: +mo-handle-ames-request: handle %ames request message.
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-10-30 23:12:57 +03:00
|
|
|
++ mo-handle-ames-request
|
|
|
|
|= [=ship agent-name=term =ames-request]
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ mo-core
|
2019-11-20 00:03:07 +03:00
|
|
|
:: %u/%leave gets automatically acked
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-27 01:56:20 +03:00
|
|
|
=. mo-core (mo-track-ship ship)
|
2019-11-03 03:52:48 +03:00
|
|
|
=? mo-core ?=(%u -.ames-request) (mo-give %done ~)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-10-30 23:12:57 +03:00
|
|
|
=/ =wire /sys/req/(scot %p ship)/[agent-name]
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-20 00:03:07 +03:00
|
|
|
=/ =deal
|
2019-10-30 23:12:57 +03:00
|
|
|
?- -.ames-request
|
2019-11-20 00:03:07 +03:00
|
|
|
%m [%raw-poke [mark noun]:ames-request]
|
|
|
|
%l [%watch-as [mark path]:ames-request]
|
|
|
|
%s [%watch path.ames-request]
|
|
|
|
%u [%leave ~]
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
2019-11-20 00:03:07 +03:00
|
|
|
(mo-pass wire %g %deal [ship our] agent-name deal)
|
|
|
|
:: +mo-handle-ames-response: handle ames response message.
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-10-30 23:12:57 +03:00
|
|
|
++ mo-handle-ames-response
|
2019-11-04 04:35:45 +03:00
|
|
|
|= =ames-response
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ mo-core
|
2019-10-30 23:12:57 +03:00
|
|
|
?- -.ames-response
|
2020-04-30 11:15:28 +03:00
|
|
|
:: %d: diff; ask clay to validate .noun as .mark
|
2019-10-30 23:12:57 +03:00
|
|
|
::
|
2019-08-29 21:44:37 +03:00
|
|
|
%d
|
2020-04-30 11:15:28 +03:00
|
|
|
=/ =case:clay da+now
|
|
|
|
=/ sky (ski [%141 %noun] ~ %cb [our %home case] /[mark.ames-response])
|
|
|
|
?- sky
|
|
|
|
?(~ [~ ~])
|
|
|
|
=/ ror "gall: ames mark fail {<mark.ames-response>}"
|
|
|
|
(mo-give %done `vale+[leaf+ror]~)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-30 11:15:28 +03:00
|
|
|
[~ ~ *]
|
|
|
|
=+ !<(=dais:clay q.u.u.sky)
|
|
|
|
=/ res (mule |.((vale:dais noun.ames-response)))
|
|
|
|
?: ?=(%| -.res)
|
|
|
|
=/ ror "gall: ames vale fail {<mark.deal>}"
|
|
|
|
(mo-give %done `vale+[leaf+ror p.res])
|
|
|
|
=. mo-core
|
|
|
|
%+ mo-pass /nowhere
|
|
|
|
[%c %warp our %home ~ %sing %b case /[mark.ames-response]]
|
|
|
|
(mo-give %unto %fact mark.ames-response p.res)
|
|
|
|
==
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-20 00:03:07 +03:00
|
|
|
:: %x: kick; tell agent the publisher canceled the subscription
|
2019-10-30 23:12:57 +03:00
|
|
|
::
|
2019-08-29 21:44:37 +03:00
|
|
|
%x
|
2019-11-20 00:03:07 +03:00
|
|
|
(mo-give %unto %kick ~)
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
|
|
|
:: +ap: agent engine
|
|
|
|
::
|
|
|
|
:: An inner, agent-level core. The sample refers to the agent we're
|
|
|
|
:: currently focused on.
|
|
|
|
::
|
|
|
|
++ ap
|
2019-11-19 07:36:21 +03:00
|
|
|
~% %gall-ap +> ~
|
2019-08-29 21:44:37 +03:00
|
|
|
|_ $: agent-name=term
|
|
|
|
agent-routes=routes
|
2019-09-12 05:55:31 +03:00
|
|
|
agent-duct=duct
|
2019-11-08 03:30:45 +03:00
|
|
|
agent-moves=(list move)
|
2019-08-29 21:44:37 +03:00
|
|
|
agent-config=(list (each suss tang))
|
2020-04-30 09:00:57 +03:00
|
|
|
current-agent=yoke
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
|
|
|
++ ap-core .
|
|
|
|
:: +ap-abed: initialise state for an agent, with the supplied routes.
|
|
|
|
::
|
2019-11-19 07:36:21 +03:00
|
|
|
:: The agent must already be running in +gall -- here we simply update
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +ap's state to focus on it.
|
|
|
|
::
|
|
|
|
++ ap-abed
|
|
|
|
~/ %ap-abed
|
2020-04-22 13:49:23 +03:00
|
|
|
|= [dap=term =routes]
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ ap-core
|
2020-06-23 04:37:17 +03:00
|
|
|
(ap-yoke dap routes (~(got by yokes.state) dap))
|
2020-05-14 14:24:44 +03:00
|
|
|
:: +ap-hatch: initialize agent state from $egg, after upgrade
|
|
|
|
::
|
|
|
|
++ ap-abut
|
|
|
|
|= [dap=term =egg]
|
|
|
|
^+ ap-core
|
2020-11-17 23:53:05 +03:00
|
|
|
=/ =yoke
|
|
|
|
?: ?=(%| -.old-state.egg)
|
|
|
|
egg
|
|
|
|
=/ res (mo-scry-agent-cage dap da+now)
|
|
|
|
?: ?=(%| -.res)
|
|
|
|
(mean p.res)
|
|
|
|
egg(p.old-state `agent`p.res)
|
2020-06-23 04:37:17 +03:00
|
|
|
=/ =routes [disclosing=~ attributing=our]
|
|
|
|
(ap-yoke dap routes yoke)
|
2020-05-14 14:24:44 +03:00
|
|
|
:: +ap-yoke: initialize agent state, starting from a $yoke
|
|
|
|
::
|
|
|
|
++ ap-yoke
|
2020-06-23 04:37:17 +03:00
|
|
|
|= [dap=term =routes =yoke]
|
2020-05-14 14:24:44 +03:00
|
|
|
^+ ap-core
|
|
|
|
=. stats.yoke
|
|
|
|
:+ +(change.stats.yoke)
|
|
|
|
(shaz (mix (add dap change.stats.yoke) eny))
|
|
|
|
now
|
2020-04-30 09:00:57 +03:00
|
|
|
=. agent-name dap
|
2019-08-29 21:44:37 +03:00
|
|
|
=. agent-routes routes
|
2020-04-30 09:00:57 +03:00
|
|
|
=. current-agent yoke
|
2019-09-12 05:55:31 +03:00
|
|
|
=. agent-duct hen
|
|
|
|
ap-core
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +ap-abet: resolve moves.
|
|
|
|
::
|
|
|
|
++ ap-abet
|
|
|
|
^+ mo-core
|
|
|
|
::
|
2020-04-30 09:00:57 +03:00
|
|
|
=/ running (~(put by yokes.state) agent-name current-agent)
|
2019-08-29 21:44:37 +03:00
|
|
|
=/ moves
|
|
|
|
=/ giver |=(report=(each suss tang) [hen %give %onto report])
|
|
|
|
=/ from-suss (turn agent-config giver)
|
2019-11-08 03:30:45 +03:00
|
|
|
:(weld agent-moves from-suss moves)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
|
|
|
%_ mo-core
|
2020-04-22 08:37:12 +03:00
|
|
|
yokes.state running
|
|
|
|
moves moves
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
2020-11-10 09:26:13 +03:00
|
|
|
:: +ap-fade: put affairs in order.
|
|
|
|
::
|
|
|
|
:: For %gone, remove all incoming and outgoing subscriptions.
|
|
|
|
::
|
|
|
|
++ ap-fade
|
2020-11-26 01:46:33 +03:00
|
|
|
|= style=?(%slay %idle %jolt)
|
2020-11-10 09:26:13 +03:00
|
|
|
^+ ap-core
|
2020-11-17 23:53:05 +03:00
|
|
|
?- style
|
2020-11-26 01:46:33 +03:00
|
|
|
%jolt ap-core
|
|
|
|
%idle
|
2020-11-17 23:53:05 +03:00
|
|
|
=. agent.current-agent |+on-save:ap-agent-core
|
|
|
|
ap-core
|
|
|
|
::
|
2020-11-26 01:46:33 +03:00
|
|
|
%slay
|
2020-11-17 23:53:05 +03:00
|
|
|
=/ out=(list [[=wire =ship =term] ? =path])
|
|
|
|
~(tap by outbound.watches.current-agent)
|
|
|
|
=/ inbound-paths=(set path)
|
|
|
|
%- silt
|
|
|
|
%+ turn ~(tap by inbound.watches.current-agent)
|
|
|
|
|= [=duct =ship =path]
|
|
|
|
path
|
|
|
|
=/ will=(list card:agent:gall)
|
|
|
|
%+ welp
|
|
|
|
?: =(~ inbound-paths)
|
|
|
|
~
|
|
|
|
[%give %kick ~(tap in inbound-paths) ~]~
|
|
|
|
%+ turn ~(tap by outbound.watches.current-agent)
|
|
|
|
|= [[=wire =ship =term] ? =path]
|
|
|
|
[%pass wire %agent [ship term] %leave ~]
|
|
|
|
=^ maybe-tang ap-core (ap-ingest ~ |.([will *agent]))
|
|
|
|
ap-core
|
|
|
|
==
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +ap-from-internal: internal move to move.
|
|
|
|
::
|
2019-09-12 05:55:31 +03:00
|
|
|
:: We convert from cards to duct-indexed moves when resolving
|
|
|
|
:: them in Arvo.
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
|
|
|
++ ap-from-internal
|
|
|
|
~/ %ap-from-internal
|
2019-11-09 04:26:47 +03:00
|
|
|
|= card=(wind neat gift:agent)
|
2019-09-12 05:55:31 +03:00
|
|
|
^- (list move)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-09-12 05:55:31 +03:00
|
|
|
?- -.card
|
|
|
|
%slip !!
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-09-12 05:55:31 +03:00
|
|
|
%give
|
|
|
|
=/ =gift:agent p.card
|
2019-11-08 00:17:13 +03:00
|
|
|
?: ?=(%kick -.gift)
|
2019-12-22 23:12:28 +03:00
|
|
|
=/ ducts=(list duct) (ap-ducts-from-paths paths.gift ship.gift)
|
2019-11-08 00:17:13 +03:00
|
|
|
%+ turn ducts
|
|
|
|
|= =duct
|
2020-05-01 09:14:16 +03:00
|
|
|
~? &(=(duct system-duct.state) !=(agent-name %hood))
|
2019-11-08 00:17:13 +03:00
|
|
|
[%agent-giving-on-system-duct agent-name -.gift]
|
2019-11-09 04:26:47 +03:00
|
|
|
[duct %give %unto %kick ~]
|
2019-11-08 01:46:06 +03:00
|
|
|
::
|
2019-11-07 09:19:32 +03:00
|
|
|
?. ?=(%fact -.gift)
|
2019-09-12 05:55:31 +03:00
|
|
|
[agent-duct %give %unto gift]~
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-12-22 23:12:28 +03:00
|
|
|
=/ ducts=(list duct) (ap-ducts-from-paths paths.gift ~)
|
2019-09-12 05:55:31 +03:00
|
|
|
=/ =cage cage.gift
|
2020-05-01 09:14:16 +03:00
|
|
|
%- zing
|
2019-09-12 05:55:31 +03:00
|
|
|
%+ turn ducts
|
|
|
|
|= =duct
|
2020-05-01 09:14:16 +03:00
|
|
|
~? &(=(duct system-duct.state) !=(agent-name %hood))
|
2019-09-12 05:55:31 +03:00
|
|
|
[%agent-giving-on-system-duct agent-name -.gift]
|
2020-05-01 09:14:16 +03:00
|
|
|
^- (list move)
|
2019-09-12 05:55:31 +03:00
|
|
|
=/ =mark
|
|
|
|
(~(gut by marks.current-agent) duct p.cage)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-09-12 05:55:31 +03:00
|
|
|
?: =(mark p.cage)
|
2020-05-01 09:14:16 +03:00
|
|
|
[duct %give %unto %fact cage.gift]~
|
2020-04-30 11:15:28 +03:00
|
|
|
=/ =mars:clay [p.cage mark]
|
|
|
|
=/ =case:clay da+now
|
|
|
|
=/ bek=beak [our %home case]
|
2020-05-01 09:14:16 +03:00
|
|
|
=/ mars-path /[a.mars]/[b.mars]
|
2020-11-22 00:04:18 +03:00
|
|
|
=/ sky (ski [%141 %noun] ~ %cc bek mars-path)
|
2020-04-30 11:15:28 +03:00
|
|
|
?- sky
|
2020-05-01 09:14:16 +03:00
|
|
|
?(~ [~ ~])
|
|
|
|
%- (slog leaf+"watch-as fact conversion find-fail" >sky< ~)
|
|
|
|
(ap-kill-up-slip duct)
|
2019-09-12 05:55:31 +03:00
|
|
|
::
|
2020-04-30 11:15:28 +03:00
|
|
|
[~ ~ *]
|
|
|
|
=+ !<(=tube:clay q.u.u.sky)
|
|
|
|
=/ res (mule |.((tube q.cage)))
|
|
|
|
?: ?=(%| -.res)
|
2020-05-01 09:14:16 +03:00
|
|
|
%- (slog leaf+"watch-as fact conversion failure" p.res)
|
|
|
|
(ap-kill-up-slip duct)
|
|
|
|
:~ [duct %pass /nowhere %c %warp our %home ~ %sing %c case mars-path]
|
|
|
|
[duct %give %unto %fact b.mars p.res]
|
|
|
|
==
|
2020-04-30 11:15:28 +03:00
|
|
|
==
|
2019-09-12 05:55:31 +03:00
|
|
|
::
|
|
|
|
%pass
|
2020-04-22 08:37:12 +03:00
|
|
|
=/ =duct system-duct.state
|
2019-09-29 07:44:31 +03:00
|
|
|
=/ =wire p.card
|
2020-04-22 01:50:47 +03:00
|
|
|
=/ =neat q.card
|
2019-09-29 07:44:31 +03:00
|
|
|
=. wire
|
gall: remove message type from wire
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
2019-12-10 04:52:53 +03:00
|
|
|
?: ?=(%agent -.neat)
|
|
|
|
[%out (scot %p ship.neat) name.neat wire]
|
|
|
|
[(scot %p attributing.agent-routes) wire]
|
2020-11-19 07:12:29 +03:00
|
|
|
=. wire [%use agent-name nonce.current-agent wire]
|
2019-09-12 05:55:31 +03:00
|
|
|
=/ =note-arvo
|
2020-04-22 01:50:47 +03:00
|
|
|
?- -.neat
|
|
|
|
%arvo note-arvo.neat
|
|
|
|
%agent [%g %deal [our ship.neat] [name deal]:neat]
|
2019-09-12 05:55:31 +03:00
|
|
|
==
|
2019-09-29 07:44:31 +03:00
|
|
|
[duct %pass wire note-arvo]~
|
2019-09-12 05:55:31 +03:00
|
|
|
==
|
2019-11-05 07:19:08 +03:00
|
|
|
:: +ap-breach: ship breached, so forget about them
|
|
|
|
::
|
|
|
|
++ ap-breach
|
|
|
|
|= =ship
|
|
|
|
^+ ap-core
|
|
|
|
=/ in=(list [=duct =^ship =path])
|
2020-04-30 09:00:57 +03:00
|
|
|
~(tap by inbound.watches.current-agent)
|
2019-11-05 07:19:08 +03:00
|
|
|
|- ^+ ap-core
|
|
|
|
?^ in
|
|
|
|
=? ap-core =(ship ship.i.in)
|
|
|
|
=/ core ap-load-delete(agent-duct duct.i.in)
|
|
|
|
core(agent-duct agent-duct)
|
|
|
|
$(in t.in)
|
|
|
|
::
|
2019-11-20 00:03:07 +03:00
|
|
|
=/ out=(list [[=wire =^ship =term] ? =path])
|
2020-04-30 09:00:57 +03:00
|
|
|
~(tap by outbound.watches.current-agent)
|
2019-11-05 07:19:08 +03:00
|
|
|
|- ^+ ap-core
|
|
|
|
?~ out
|
|
|
|
ap-core
|
|
|
|
=? ap-core =(ship ship.i.out)
|
|
|
|
=/ core
|
2020-04-30 09:00:57 +03:00
|
|
|
=. agent-duct system-duct.state
|
2019-12-03 10:46:15 +03:00
|
|
|
=/ way [%out (scot %p ship) term.i.out wire.i.out]
|
|
|
|
(ap-specific-take way %kick ~)
|
2019-11-05 07:19:08 +03:00
|
|
|
core(agent-duct agent-duct)
|
|
|
|
$(out t.out)
|
2019-11-04 04:35:45 +03:00
|
|
|
:: +ap-clog: handle %clog notification from ames
|
|
|
|
::
|
|
|
|
:: Kills subscriptions from .ship in both directions:
|
|
|
|
:: - notifies local app that subscription is dead
|
|
|
|
:: - gives remote %quit to notify subscriber ship
|
|
|
|
:: TODO: %drip local app notification for error isolation
|
|
|
|
::
|
|
|
|
++ ap-clog
|
|
|
|
|= =ship
|
|
|
|
^+ ap-core
|
|
|
|
::
|
2019-11-20 00:03:07 +03:00
|
|
|
=/ in=(list [=duct =^ship =path])
|
2020-04-30 09:00:57 +03:00
|
|
|
~(tap by inbound.watches.current-agent)
|
2019-11-04 04:35:45 +03:00
|
|
|
|- ^+ ap-core
|
|
|
|
?~ in ap-core
|
|
|
|
::
|
|
|
|
=? ap-core =(ship ship.i.in)
|
2019-11-20 00:03:07 +03:00
|
|
|
=/ core ap-kill-up(agent-duct duct.i.in)
|
|
|
|
core(agent-duct agent-duct)
|
2019-11-04 04:35:45 +03:00
|
|
|
$(in t.in)
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +ap-agent-core: agent core with current bowl and state
|
|
|
|
::
|
|
|
|
++ ap-agent-core
|
2020-11-17 23:53:05 +03:00
|
|
|
?> ?=(%& -.agent.current-agent)
|
|
|
|
~(. p.agent.current-agent ap-construct-bowl)
|
2019-12-22 23:12:28 +03:00
|
|
|
:: +ap-ducts-from-paths: get ducts subscribed to paths
|
|
|
|
::
|
|
|
|
++ ap-ducts-from-paths
|
|
|
|
|= [target-paths=(list path) target-ship=(unit ship)]
|
|
|
|
^- (list duct)
|
2020-05-08 04:12:57 +03:00
|
|
|
?~ target-paths
|
|
|
|
?~ target-ship
|
|
|
|
~[agent-duct]
|
2020-06-03 07:50:20 +03:00
|
|
|
%+ murn ~(tap by inbound.watches.current-agent)
|
2020-05-08 04:12:57 +03:00
|
|
|
|= [=duct =ship =path]
|
|
|
|
^- (unit ^duct)
|
|
|
|
?: =(target-ship `ship)
|
|
|
|
`duct
|
|
|
|
~
|
2019-12-22 23:12:28 +03:00
|
|
|
%- zing
|
|
|
|
%+ turn target-paths
|
|
|
|
|= =path
|
2020-05-08 04:12:57 +03:00
|
|
|
(ap-ducts-from-path path target-ship)
|
2019-09-12 05:55:31 +03:00
|
|
|
:: +ap-ducts-from-path: get ducts subscribed to path
|
|
|
|
::
|
|
|
|
++ ap-ducts-from-path
|
2020-05-08 04:12:57 +03:00
|
|
|
|= [target-path=path target-ship=(unit ship)]
|
2019-09-12 05:55:31 +03:00
|
|
|
^- (list duct)
|
2020-04-30 09:00:57 +03:00
|
|
|
%+ murn ~(tap by inbound.watches.current-agent)
|
2019-09-12 05:55:31 +03:00
|
|
|
|= [=duct =ship =path]
|
|
|
|
^- (unit ^duct)
|
2020-05-08 04:12:57 +03:00
|
|
|
?: ?& =(target-path path)
|
|
|
|
|(=(target-ship ~) =(target-ship `ship))
|
|
|
|
==
|
2019-09-12 05:55:31 +03:00
|
|
|
`duct
|
|
|
|
~
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +ap-apply: apply effect.
|
|
|
|
::
|
|
|
|
++ ap-apply
|
2019-11-09 04:26:47 +03:00
|
|
|
|= =deal
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ ap-core
|
2019-11-09 04:26:47 +03:00
|
|
|
?- -.deal
|
|
|
|
%watch-as (ap-subscribe-as +.deal)
|
|
|
|
%poke (ap-poke +.deal)
|
|
|
|
%watch (ap-subscribe +.deal)
|
|
|
|
%raw-poke !!
|
|
|
|
%poke-as !!
|
|
|
|
%leave ap-load-delete
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
|
|
|
:: +ap-peek: peek.
|
|
|
|
::
|
|
|
|
++ ap-peek
|
|
|
|
~/ %ap-peek
|
2020-04-22 13:49:23 +03:00
|
|
|
|= [care=term tyl=path]
|
2019-08-29 21:44:37 +03:00
|
|
|
^- (unit (unit cage))
|
2020-06-12 03:03:55 +03:00
|
|
|
:: take trailing mark off path for %x scrys
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-06-12 03:03:55 +03:00
|
|
|
=^ want=mark tyl
|
|
|
|
?. ?=(%x care) [%$ tyl]
|
|
|
|
=. tyl (flop tyl)
|
|
|
|
[(head tyl) (flop (tail tyl))]
|
|
|
|
:: call the app's +on-peek, producing [~ ~] if it crashes
|
2019-09-25 23:19:09 +03:00
|
|
|
::
|
2019-08-29 21:44:37 +03:00
|
|
|
=/ peek-result=(each (unit (unit cage)) tang)
|
2020-04-22 13:49:23 +03:00
|
|
|
(ap-mule-peek |.((on-peek:ap-agent-core [care tyl])))
|
2020-06-12 03:03:55 +03:00
|
|
|
?: ?=(%| -.peek-result)
|
|
|
|
((slog leaf+"peek bad result" p.peek-result) [~ ~])
|
|
|
|
:: for non-%x scries, or failed %x scries, or %x results that already
|
|
|
|
:: have the requested mark, produce the result as-is
|
|
|
|
::
|
|
|
|
?. ?& ?=(%x care)
|
|
|
|
?=([~ ~ *] p.peek-result)
|
|
|
|
!=(mark p.u.u.p.peek-result)
|
|
|
|
==
|
|
|
|
p.peek-result
|
|
|
|
:: for %x scries, attempt to convert to the requested mark if needed
|
|
|
|
::
|
|
|
|
=* have p.u.u.p.peek-result
|
|
|
|
=* vase q.u.u.p.peek-result
|
|
|
|
=/ tub=(unit tube:clay)
|
|
|
|
?: =(have want) `(bake same ^vase)
|
|
|
|
=/ tuc=(unit (unit cage))
|
2020-11-22 00:04:18 +03:00
|
|
|
(ski [%141 %noun] ~ %cc [our %home da+now] /[have]/[want])
|
2020-06-12 03:03:55 +03:00
|
|
|
?. ?=([~ ~ *] tuc) ~
|
|
|
|
`!<(tube:clay q.u.u.tuc)
|
|
|
|
?~ tub
|
|
|
|
((slog leaf+"peek no tube from {(trip have)} to {(trip want)}" ~) ~)
|
|
|
|
=/ res (mule |.((u.tub vase)))
|
|
|
|
?: ?=(%& -.res)
|
|
|
|
``want^p.res
|
|
|
|
((slog leaf+"peek failed tube from {(trip have)} to {(trip want)}" ~) ~)
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +ap-update-subscription: update subscription.
|
|
|
|
::
|
|
|
|
++ ap-update-subscription
|
|
|
|
~/ %ap-update-subscription
|
2019-09-29 07:44:31 +03:00
|
|
|
|= [is-ok=? =other=ship other-agent=term =wire]
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ ap-core
|
|
|
|
?: is-ok
|
|
|
|
ap-core
|
2019-11-20 00:03:07 +03:00
|
|
|
(ap-kill-down wire [other-ship other-agent])
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +ap-give: return result.
|
|
|
|
::
|
|
|
|
++ ap-give
|
2019-09-12 05:55:31 +03:00
|
|
|
|= =gift:agent
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ ap-core
|
2019-11-08 03:30:45 +03:00
|
|
|
=/ internal-moves
|
|
|
|
(weld (ap-from-internal %give gift) agent-moves)
|
|
|
|
ap-core(agent-moves internal-moves)
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +ap-construct-bowl: set up bowl.
|
|
|
|
::
|
|
|
|
++ ap-construct-bowl
|
|
|
|
^- bowl
|
|
|
|
:* :* our :: host
|
|
|
|
attributing.agent-routes :: guest
|
|
|
|
agent-name :: agent
|
|
|
|
== ::
|
2020-04-30 09:00:57 +03:00
|
|
|
:* wex=outbound.watches.current-agent :: outgoing
|
|
|
|
sup=inbound.watches.current-agent :: incoming
|
2019-08-29 21:44:37 +03:00
|
|
|
== ::
|
2019-09-12 05:55:31 +03:00
|
|
|
:* act=change.stats.current-agent :: tick
|
2019-08-29 21:44:37 +03:00
|
|
|
eny=eny.stats.current-agent :: nonce
|
|
|
|
now=time.stats.current-agent :: time
|
|
|
|
byk=beak.current-agent :: source
|
|
|
|
== ==
|
|
|
|
:: +ap-pass: request action.
|
|
|
|
::
|
|
|
|
++ ap-pass
|
2019-11-09 04:26:47 +03:00
|
|
|
|= [=path =neat]
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ ap-core
|
2019-11-08 03:30:45 +03:00
|
|
|
=/ internal-moves
|
2019-11-09 04:26:47 +03:00
|
|
|
(ap-from-internal %pass path neat)
|
2019-11-08 03:30:45 +03:00
|
|
|
ap-core(agent-moves (weld internal-moves agent-moves))
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +ap-reinstall: reinstall.
|
|
|
|
::
|
|
|
|
++ ap-reinstall
|
|
|
|
~/ %ap-reinstall
|
2020-04-22 08:37:12 +03:00
|
|
|
|= =agent
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ ap-core
|
2020-11-17 23:53:05 +03:00
|
|
|
=/ old-state=vase
|
|
|
|
?: ?=(%& -.agent.current-agent)
|
|
|
|
on-save:ap-agent-core
|
|
|
|
p.agent.current-agent
|
2020-04-22 08:37:12 +03:00
|
|
|
=^ error ap-core
|
2020-11-17 23:53:05 +03:00
|
|
|
(ap-install(agent.current-agent &+agent) `old-state)
|
2020-04-22 08:37:12 +03:00
|
|
|
?~ error
|
2019-08-29 21:44:37 +03:00
|
|
|
ap-core
|
2020-06-18 06:31:37 +03:00
|
|
|
(mean >%load-failed< u.error)
|
2019-11-09 04:26:47 +03:00
|
|
|
:: +ap-subscribe-as: apply %watch-as.
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-09 04:26:47 +03:00
|
|
|
++ ap-subscribe-as
|
2019-08-29 21:44:37 +03:00
|
|
|
|= [=mark =path]
|
|
|
|
^+ ap-core
|
2019-09-12 05:55:31 +03:00
|
|
|
=. marks.current-agent (~(put by marks.current-agent) agent-duct mark)
|
|
|
|
(ap-subscribe path)
|
2019-11-07 09:19:32 +03:00
|
|
|
:: +ap-subscribe: apply %watch.
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-09-12 05:55:31 +03:00
|
|
|
++ ap-subscribe
|
|
|
|
~/ %ap-subscribe
|
2019-08-29 21:44:37 +03:00
|
|
|
|= pax=path
|
|
|
|
^+ ap-core
|
|
|
|
=/ incoming [attributing.agent-routes pax]
|
2020-04-30 09:00:57 +03:00
|
|
|
=. inbound.watches.current-agent
|
|
|
|
(~(put by inbound.watches.current-agent) agent-duct incoming)
|
2019-08-29 21:44:37 +03:00
|
|
|
=^ maybe-tang ap-core
|
2019-11-07 09:19:32 +03:00
|
|
|
%+ ap-ingest %watch-ack |.
|
|
|
|
(on-watch:ap-agent-core pax)
|
2019-08-29 21:44:37 +03:00
|
|
|
?^ maybe-tang
|
|
|
|
ap-silent-delete
|
|
|
|
ap-core
|
|
|
|
:: +ap-poke: apply %poke.
|
|
|
|
::
|
|
|
|
++ ap-poke
|
|
|
|
~/ %ap-poke
|
|
|
|
|= =cage
|
|
|
|
^+ ap-core
|
|
|
|
=^ maybe-tang ap-core
|
2019-09-12 05:55:31 +03:00
|
|
|
%+ ap-ingest %poke-ack |.
|
2019-11-07 09:19:32 +03:00
|
|
|
(on-poke:ap-agent-core cage)
|
2019-08-29 21:44:37 +03:00
|
|
|
ap-core
|
2019-09-12 05:55:31 +03:00
|
|
|
:: +ap-error: pour error.
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-09-12 05:55:31 +03:00
|
|
|
++ ap-error
|
2019-08-29 21:44:37 +03:00
|
|
|
|= [=term =tang]
|
|
|
|
^+ ap-core
|
|
|
|
=/ form |=(=tank [%rose [~ "! " ~] tank ~])
|
2019-08-29 22:57:33 +03:00
|
|
|
=^ maybe-tang ap-core
|
|
|
|
%+ ap-ingest ~ |.
|
2019-11-07 09:19:32 +03:00
|
|
|
(on-fail:ap-agent-core term (turn tang form))
|
2019-08-29 21:44:37 +03:00
|
|
|
ap-core
|
|
|
|
:: +ap-generic-take: generic take.
|
|
|
|
::
|
|
|
|
++ ap-generic-take
|
|
|
|
~/ %ap-generic-take
|
2019-09-12 05:55:31 +03:00
|
|
|
|= [=wire =sign-arvo]
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ ap-core
|
|
|
|
=^ maybe-tang ap-core
|
|
|
|
%+ ap-ingest ~ |.
|
2019-11-07 09:19:32 +03:00
|
|
|
(on-arvo:ap-agent-core wire sign-arvo)
|
2019-08-29 21:44:37 +03:00
|
|
|
?^ maybe-tang
|
2019-09-12 05:55:31 +03:00
|
|
|
(ap-error %arvo-response u.maybe-tang)
|
2019-08-29 21:44:37 +03:00
|
|
|
ap-core
|
|
|
|
:: +ap-specific-take: specific take.
|
|
|
|
::
|
|
|
|
++ ap-specific-take
|
2019-11-09 04:26:47 +03:00
|
|
|
|= [=wire =sign:agent]
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ ap-core
|
2019-09-29 07:44:31 +03:00
|
|
|
~| wire=wire
|
|
|
|
?> ?=([%out @ @ *] wire)
|
|
|
|
=/ other-ship (slav %p i.t.wire)
|
|
|
|
=/ other-agent i.t.t.wire
|
2019-10-01 06:53:02 +03:00
|
|
|
=/ =dock [other-ship other-agent]
|
2019-09-29 07:44:31 +03:00
|
|
|
=/ agent-wire t.t.t.wire
|
2019-10-01 06:53:02 +03:00
|
|
|
:: if subscription ack or close, handle before calling user code
|
|
|
|
::
|
2020-04-30 09:00:57 +03:00
|
|
|
=? outbound.watches.current-agent ?=(%kick -.sign)
|
|
|
|
%- ~(del by outbound.watches.current-agent)
|
2019-11-08 05:25:19 +03:00
|
|
|
[agent-wire dock]
|
2019-11-09 04:26:47 +03:00
|
|
|
?: ?& ?=(%watch-ack -.sign)
|
2020-04-30 09:00:57 +03:00
|
|
|
!(~(has by outbound.watches.current-agent) [agent-wire dock])
|
2019-11-06 06:55:51 +03:00
|
|
|
==
|
|
|
|
%- %: slog
|
|
|
|
leaf+"{<agent-name>}: got ack for nonexistent subscription"
|
|
|
|
leaf+"{<dock>}: {<agent-wire>}"
|
2019-11-08 05:25:19 +03:00
|
|
|
>wire=wire<
|
2019-11-06 06:55:51 +03:00
|
|
|
~
|
|
|
|
==
|
|
|
|
ap-core
|
|
|
|
::
|
2020-04-30 09:00:57 +03:00
|
|
|
=? outbound.watches.current-agent ?=(%watch-ack -.sign)
|
2019-11-09 04:26:47 +03:00
|
|
|
?^ p.sign
|
2020-04-30 09:00:57 +03:00
|
|
|
%- ~(del by outbound.watches.current-agent)
|
2019-11-27 05:18:44 +03:00
|
|
|
[agent-wire dock]
|
2020-04-30 09:00:57 +03:00
|
|
|
%+ ~(jab by outbound.watches.current-agent) [agent-wire dock]
|
2019-10-01 06:53:02 +03:00
|
|
|
|= [acked=? =path]
|
2019-12-10 11:21:03 +03:00
|
|
|
=. .
|
|
|
|
?. acked
|
|
|
|
.
|
|
|
|
%- =/ =tape
|
|
|
|
"{<agent-name>}: received 2nd watch-ack on {<wire dock path>}"
|
|
|
|
(slog leaf+tape ~)
|
|
|
|
.
|
2019-10-01 06:53:02 +03:00
|
|
|
[& path]
|
|
|
|
::
|
2019-08-29 21:44:37 +03:00
|
|
|
=^ maybe-tang ap-core
|
|
|
|
%+ ap-ingest ~ |.
|
2019-11-09 04:26:47 +03:00
|
|
|
(on-agent:ap-agent-core agent-wire sign)
|
2019-12-10 11:21:03 +03:00
|
|
|
:: if failed %fact handling, kill subscription
|
2019-10-01 06:53:02 +03:00
|
|
|
::
|
2019-11-09 04:26:47 +03:00
|
|
|
=? ap-core ?=(%fact -.sign)
|
2019-10-01 06:53:02 +03:00
|
|
|
(ap-update-subscription =(~ maybe-tang) p.dock q.dock agent-wire)
|
2019-08-29 21:44:37 +03:00
|
|
|
?^ maybe-tang
|
2019-11-09 04:26:47 +03:00
|
|
|
(ap-error -.sign leaf/"closing subscription" u.maybe-tang)
|
2019-08-29 21:44:37 +03:00
|
|
|
ap-core
|
|
|
|
:: +ap-install: install wrapper.
|
|
|
|
::
|
|
|
|
++ ap-install
|
2020-04-22 08:37:12 +03:00
|
|
|
|= old-agent-state=(unit vase)
|
2019-08-29 21:44:37 +03:00
|
|
|
^- [(unit tang) _ap-core]
|
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
=^ maybe-tang ap-core (ap-upgrade-state old-agent-state)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-30 09:00:57 +03:00
|
|
|
=. agent-config
|
2020-04-22 08:37:12 +03:00
|
|
|
=/ =term ?~(old-agent-state %boot %bump)
|
2019-08-29 21:44:37 +03:00
|
|
|
=/ possibly-suss
|
|
|
|
?~ maybe-tang
|
|
|
|
=/ =suss [agent-name term now]
|
|
|
|
[%.y suss]
|
|
|
|
[%.n u.maybe-tang]
|
|
|
|
[possibly-suss agent-config]
|
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
[maybe-tang ap-core]
|
2019-09-12 05:55:31 +03:00
|
|
|
:: +ap-upgrade-state: low-level install.
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-09-12 05:55:31 +03:00
|
|
|
++ ap-upgrade-state
|
|
|
|
~/ %ap-upgrade-state
|
2019-08-29 21:44:37 +03:00
|
|
|
|= maybe-vase=(unit vase)
|
|
|
|
^- [(unit tang) _ap-core]
|
|
|
|
::
|
|
|
|
=^ maybe-tang ap-core
|
|
|
|
%+ ap-ingest ~
|
|
|
|
?~ maybe-vase
|
2019-11-07 09:19:32 +03:00
|
|
|
|. on-init:ap-agent-core
|
|
|
|
|. (on-load:ap-agent-core u.maybe-vase)
|
2019-08-29 21:44:37 +03:00
|
|
|
[maybe-tang ap-core]
|
|
|
|
:: +ap-silent-delete: silent delete.
|
|
|
|
::
|
|
|
|
++ ap-silent-delete
|
|
|
|
^+ ap-core
|
|
|
|
::
|
2019-11-01 23:18:51 +03:00
|
|
|
%= ap-core
|
2020-04-30 09:00:57 +03:00
|
|
|
inbound.watches.current-agent
|
|
|
|
(~(del by inbound.watches.current-agent) agent-duct)
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
|
|
|
:: +ap-load-delete: load delete.
|
|
|
|
::
|
|
|
|
++ ap-load-delete
|
|
|
|
^+ ap-core
|
|
|
|
::
|
|
|
|
=/ maybe-incoming
|
2020-04-30 09:00:57 +03:00
|
|
|
(~(get by inbound.watches.current-agent) agent-duct)
|
2019-08-29 21:44:37 +03:00
|
|
|
?~ maybe-incoming
|
|
|
|
ap-core
|
|
|
|
::
|
|
|
|
=/ incoming u.maybe-incoming
|
2020-04-30 09:00:57 +03:00
|
|
|
=. inbound.watches.current-agent
|
|
|
|
(~(del by inbound.watches.current-agent) agent-duct)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
|
|
|
=^ maybe-tang ap-core
|
|
|
|
%+ ap-ingest ~ |.
|
2019-11-07 09:19:32 +03:00
|
|
|
(on-leave:ap-agent-core q.incoming)
|
2019-08-29 21:44:37 +03:00
|
|
|
?^ maybe-tang
|
2019-11-07 09:19:32 +03:00
|
|
|
(ap-error %leave u.maybe-tang)
|
2019-08-29 21:44:37 +03:00
|
|
|
ap-core
|
2019-09-29 07:44:31 +03:00
|
|
|
:: +ap-kill-up: 2-sided kill from publisher side
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-09-29 07:44:31 +03:00
|
|
|
++ ap-kill-up
|
2019-08-29 21:44:37 +03:00
|
|
|
^+ ap-core
|
|
|
|
::
|
|
|
|
=> ap-load-delete
|
2019-11-07 09:19:32 +03:00
|
|
|
(ap-give %kick ~ ~)
|
2020-05-01 09:14:16 +03:00
|
|
|
:: +ap-kill-up-slip: 2-sided kill from publisher side by slip
|
|
|
|
::
|
|
|
|
:: +ap-kill-up is reentrant if you call it in the
|
|
|
|
:: middle of processing another deal
|
|
|
|
::
|
|
|
|
:: Should probably call +ap-error with error message
|
|
|
|
::
|
|
|
|
++ ap-kill-up-slip
|
|
|
|
|= =duct
|
|
|
|
^- (list move)
|
|
|
|
::
|
|
|
|
:~ [duct %slip %g %deal [our our] agent-name %leave ~]
|
|
|
|
[duct %give %unto %kick ~]
|
|
|
|
==
|
2019-09-29 07:44:31 +03:00
|
|
|
:: +ap-kill-down: 2-sided kill from subscriber side
|
|
|
|
::
|
2019-11-21 00:22:36 +03:00
|
|
|
:: Must process leave first in case kick handler rewatches.
|
|
|
|
::
|
2019-09-29 07:44:31 +03:00
|
|
|
++ ap-kill-down
|
|
|
|
|= [=wire =dock]
|
|
|
|
^+ ap-core
|
|
|
|
::
|
|
|
|
=. ap-core
|
2019-11-21 00:22:36 +03:00
|
|
|
(ap-pass wire %agent dock %leave ~)
|
|
|
|
=/ way [%out (scot %p p.dock) q.dock wire]
|
2020-07-08 09:08:27 +03:00
|
|
|
(ap-pass way %arvo %b %huck `sign-arvo`[%g %unto %kick ~])
|
2019-11-22 01:45:56 +03:00
|
|
|
:: +ap-mule: run virtualized with intercepted scry, preserving type
|
|
|
|
::
|
|
|
|
:: Compare +mute and +mule. Those pass through scry, which
|
|
|
|
:: doesn't allow us to catch crashes due to blocking scry. If
|
|
|
|
:: you intercept scry, you can't preserve the type
|
|
|
|
:: polymorphically. By monomorphizing, we are able to do so
|
|
|
|
:: safely.
|
|
|
|
::
|
|
|
|
++ ap-mule
|
|
|
|
|= run=_^?(|.(*step:agent))
|
|
|
|
^- (each step:agent tang)
|
2019-12-06 02:50:36 +03:00
|
|
|
=/ res (mock [run %9 2 %0 1] (sloy ski))
|
2019-11-22 01:45:56 +03:00
|
|
|
?- -.res
|
|
|
|
%0 [%& !<(step:agent [-:!>(*step:agent) p.res])]
|
2020-05-21 03:20:51 +03:00
|
|
|
%1 [%| (smyt ;;(path p.res)) ~]
|
2019-11-22 01:45:56 +03:00
|
|
|
%2 [%| p.res]
|
|
|
|
==
|
|
|
|
:: +ap-mule-peek: same as +ap-mule but for (unit (unit cage))
|
|
|
|
::
|
|
|
|
++ ap-mule-peek
|
|
|
|
|= run=_^?(|.(*(unit (unit cage))))
|
|
|
|
^- (each (unit (unit cage)) tang)
|
2019-12-06 02:50:36 +03:00
|
|
|
=/ res (mock [run %9 2 %0 1] (sloy ski))
|
2019-11-22 01:45:56 +03:00
|
|
|
?- -.res
|
|
|
|
%0 [%& !<((unit (unit cage)) [-:!>(*(unit (unit cage))) p.res])]
|
2020-05-21 03:20:51 +03:00
|
|
|
%1 [%| (smyt ;;(path p.res)) ~]
|
2019-11-22 01:45:56 +03:00
|
|
|
%2 [%| p.res]
|
|
|
|
==
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +ap-ingest: call agent arm
|
|
|
|
::
|
|
|
|
:: Handle acks here because they need to be emitted before the
|
|
|
|
:: rest of the moves.
|
|
|
|
::
|
|
|
|
++ ap-ingest
|
2019-11-07 09:19:32 +03:00
|
|
|
|= [ack=?(%poke-ack %watch-ack ~) run=_^?(|.(*step:agent))]
|
2019-08-29 21:44:37 +03:00
|
|
|
^- [(unit tang) _ap-core]
|
2019-11-22 01:45:56 +03:00
|
|
|
=/ result (ap-mule run)
|
2019-11-08 03:30:45 +03:00
|
|
|
=^ new-moves ap-core (ap-handle-result result)
|
2019-08-29 21:44:37 +03:00
|
|
|
=/ maybe-tang=(unit tang)
|
2019-09-04 22:48:36 +03:00
|
|
|
?: ?=(%& -.result)
|
2019-08-29 21:44:37 +03:00
|
|
|
~
|
2019-09-04 22:48:36 +03:00
|
|
|
`p.result
|
2019-11-08 03:30:45 +03:00
|
|
|
=/ ack-moves=(list move)
|
|
|
|
%- zing
|
|
|
|
%- turn :_ ap-from-internal
|
|
|
|
^- (list card:agent)
|
2019-08-29 21:44:37 +03:00
|
|
|
?- ack
|
|
|
|
~ ~
|
2019-11-08 03:30:45 +03:00
|
|
|
%poke-ack [%give %poke-ack maybe-tang]~
|
2019-11-07 09:19:32 +03:00
|
|
|
%watch-ack [%give %watch-ack maybe-tang]~
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
|
|
|
::
|
2019-11-08 03:30:45 +03:00
|
|
|
=. agent-moves
|
|
|
|
:(weld (flop new-moves) ack-moves agent-moves)
|
2019-08-29 21:44:37 +03:00
|
|
|
[maybe-tang ap-core]
|
|
|
|
:: +ap-handle-result: handle result.
|
|
|
|
::
|
|
|
|
++ ap-handle-result
|
|
|
|
~/ %ap-handle-result
|
2019-09-04 22:48:36 +03:00
|
|
|
|= result=(each step:agent tang)
|
2019-11-08 03:30:45 +03:00
|
|
|
^- [(list move) _ap-core]
|
2019-08-29 21:44:37 +03:00
|
|
|
?: ?=(%| -.result)
|
2019-09-04 22:48:36 +03:00
|
|
|
`ap-core
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-11-17 23:53:05 +03:00
|
|
|
=. agent.current-agent &++.p.result
|
2019-11-08 03:30:45 +03:00
|
|
|
=/ moves (zing (turn -.p.result ap-from-internal))
|
2020-04-30 09:00:57 +03:00
|
|
|
=. inbound.watches.current-agent
|
2019-11-08 03:30:45 +03:00
|
|
|
(ap-handle-kicks moves)
|
|
|
|
(ap-handle-peers moves)
|
2020-04-22 08:37:12 +03:00
|
|
|
:: +ap-handle-kicks: handle cancels of inbound.watches
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-08 03:30:45 +03:00
|
|
|
++ ap-handle-kicks
|
|
|
|
~/ %ap-handle-kicks
|
|
|
|
|= moves=(list move)
|
2019-08-29 21:44:37 +03:00
|
|
|
^- bitt
|
2019-09-12 05:55:31 +03:00
|
|
|
=/ quits=(list duct)
|
2019-11-08 03:30:45 +03:00
|
|
|
%+ murn moves
|
|
|
|
|= =move
|
|
|
|
^- (unit duct)
|
|
|
|
?. ?=([* %give %unto %kick *] move)
|
2019-08-29 21:44:37 +03:00
|
|
|
~
|
2019-11-08 03:30:45 +03:00
|
|
|
`duct.move
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
|
|
|
=/ quit-map=bitt
|
2019-09-12 05:55:31 +03:00
|
|
|
(malt (turn quits |=(=duct [duct *[ship path]])))
|
2020-04-30 09:00:57 +03:00
|
|
|
(~(dif by inbound.watches.current-agent) quit-map)
|
2020-04-22 08:37:12 +03:00
|
|
|
:: +ap-handle-peers: handle new outbound.watches
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-10-01 06:53:02 +03:00
|
|
|
++ ap-handle-peers
|
|
|
|
~/ %ap-handle-peers
|
2019-11-08 03:30:45 +03:00
|
|
|
|= moves=(list move)
|
|
|
|
^- [(list move) _ap-core]
|
|
|
|
=| new-moves=(list move)
|
|
|
|
|- ^- [(list move) _ap-core]
|
2019-10-01 06:53:02 +03:00
|
|
|
?~ moves
|
2019-11-08 03:30:45 +03:00
|
|
|
[(flop new-moves) ap-core]
|
|
|
|
=/ =move i.moves
|
2019-11-19 07:36:21 +03:00
|
|
|
?: ?=([* %pass * %g %deal * * %leave *] move)
|
2019-11-08 03:30:45 +03:00
|
|
|
=/ =wire p.move.move
|
2019-11-08 05:25:19 +03:00
|
|
|
?> ?=([%use @ @ %out @ @ *] wire)
|
|
|
|
=/ short-wire t.t.t.t.t.t.wire
|
2019-11-08 03:30:45 +03:00
|
|
|
=/ =dock [q.p q]:q.move.move
|
2020-04-30 09:00:57 +03:00
|
|
|
=. outbound.watches.current-agent
|
|
|
|
(~(del by outbound.watches.current-agent) [short-wire dock])
|
2019-11-08 03:30:45 +03:00
|
|
|
$(moves t.moves, new-moves [move new-moves])
|
2020-05-01 09:14:16 +03:00
|
|
|
?. ?=([* %pass * %g %deal * * ?(%watch %watch-as) *] move)
|
2019-11-08 03:30:45 +03:00
|
|
|
$(moves t.moves, new-moves [move new-moves])
|
|
|
|
=/ =wire p.move.move
|
2019-11-08 05:25:19 +03:00
|
|
|
?> ?=([%use @ @ %out @ @ *] wire)
|
|
|
|
=/ short-wire t.t.t.t.t.t.wire
|
2019-11-08 03:30:45 +03:00
|
|
|
=/ =dock [q.p q]:q.move.move
|
2020-05-01 09:14:16 +03:00
|
|
|
=/ =path
|
|
|
|
?- -.r.q.move.move
|
|
|
|
%watch path.r.q.move.move
|
|
|
|
%watch-as path.r.q.move.move
|
|
|
|
==
|
2020-04-30 09:00:57 +03:00
|
|
|
?: (~(has by outbound.watches.current-agent) short-wire dock)
|
2019-11-05 07:19:08 +03:00
|
|
|
=. ap-core
|
2019-10-01 06:53:02 +03:00
|
|
|
=/ =tang
|
2019-11-08 05:25:19 +03:00
|
|
|
~[leaf+"subscribe wire not unique" >agent-name< >short-wire< >dock<]
|
2020-05-04 00:21:30 +03:00
|
|
|
=/ have
|
2020-06-03 07:50:20 +03:00
|
|
|
(~(got by outbound.watches.current-agent) short-wire dock)
|
2020-05-04 00:21:30 +03:00
|
|
|
%- (slog >out=have< tang)
|
2020-05-01 09:14:16 +03:00
|
|
|
(ap-error %watch-not-unique tang) :: reentrant, maybe bad?
|
2019-10-01 06:53:02 +03:00
|
|
|
$(moves t.moves)
|
2020-04-30 09:00:57 +03:00
|
|
|
=. outbound.watches.current-agent
|
|
|
|
(~(put by outbound.watches.current-agent) [short-wire dock] [| path])
|
2019-11-08 03:30:45 +03:00
|
|
|
$(moves t.moves, new-moves [move new-moves])
|
2019-08-29 21:44:37 +03:00
|
|
|
--
|
|
|
|
--
|
|
|
|
:: +call: request
|
|
|
|
::
|
|
|
|
++ call
|
2019-11-19 07:36:21 +03:00
|
|
|
~% %gall-call +> ~
|
2020-02-11 01:03:03 +03:00
|
|
|
|= [=duct dud=(unit goof) hic=(hypo (hobo task:able))]
|
2019-11-19 07:36:21 +03:00
|
|
|
^- [(list move) _gall-payload]
|
2020-02-25 01:10:59 +03:00
|
|
|
?^ dud
|
|
|
|
~|(%gall-call-dud (mean tang.u.dud))
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-19 07:36:21 +03:00
|
|
|
~| [%gall-call-failed duct q.hic]
|
2020-01-21 02:01:36 +03:00
|
|
|
=/ =task:able ((harden task:able) q.hic)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-22 01:50:47 +03:00
|
|
|
=/ mo-core (mo-abed:mo duct)
|
2019-08-29 21:44:37 +03:00
|
|
|
?- -.task
|
2020-04-22 01:50:47 +03:00
|
|
|
%conf mo-abet:(mo-boot:mo-core dap.task our %home)
|
2019-11-09 04:26:47 +03:00
|
|
|
%deal
|
2020-04-22 08:37:12 +03:00
|
|
|
=/ [=sock =term =deal] [p q r]:task
|
2019-08-29 21:44:37 +03:00
|
|
|
?. =(q.sock our)
|
|
|
|
?> =(p.sock our)
|
2020-04-22 01:50:47 +03:00
|
|
|
mo-abet:(mo-send-foreign-request:mo-core q.sock term deal)
|
|
|
|
mo-abet:(mo-handle-local:mo-core p.sock term deal)
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
%goad mo-abet:(mo-goad:mo-core agent.task)
|
|
|
|
%init [~ gall-payload(system-duct.state duct)]
|
2019-10-30 23:12:57 +03:00
|
|
|
%plea
|
|
|
|
=/ =ship ship.task
|
2019-11-01 22:06:09 +03:00
|
|
|
=/ =path path.plea.task
|
|
|
|
=/ =noun payload.plea.task
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-10-30 23:12:57 +03:00
|
|
|
~| [ship=ship plea-path=path]
|
|
|
|
?> ?=([%ge @ ~] path)
|
2019-08-29 21:44:37 +03:00
|
|
|
=/ agent-name i.t.path
|
|
|
|
::
|
2020-12-01 07:12:43 +03:00
|
|
|
=+ ;;(=ames-request-all noun)
|
|
|
|
?> ?=(%0 -.ames-request-all)
|
|
|
|
=> (mo-handle-ames-request:mo-core ship agent-name +.ames-request-all)
|
2019-08-29 21:44:37 +03:00
|
|
|
mo-abet
|
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
%sear mo-abet:(mo-filter-queue:mo-core ship.task)
|
2020-11-10 09:26:13 +03:00
|
|
|
%fade mo-abet:(mo-fade:mo-core dap.task style.task)
|
2020-04-22 08:37:12 +03:00
|
|
|
%trim [~ gall-payload]
|
|
|
|
%vega [~ gall-payload]
|
2019-08-29 21:44:37 +03:00
|
|
|
==
|
2020-05-14 14:24:44 +03:00
|
|
|
:: +load: recreate vane; note, only valid if called from pupa
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2020-05-14 14:24:44 +03:00
|
|
|
++ load !!
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +scry: standard scry
|
|
|
|
::
|
|
|
|
++ scry
|
2019-11-19 07:36:21 +03:00
|
|
|
~/ %gall-scry
|
2020-11-24 00:06:50 +03:00
|
|
|
|= [lyc=gang cyr=term bem=beam]
|
2019-08-29 21:44:37 +03:00
|
|
|
^- (unit (unit cage))
|
2020-11-24 00:06:50 +03:00
|
|
|
=* care cyr
|
|
|
|
=/ =shop &/p.bem
|
|
|
|
=* dap q.bem
|
|
|
|
=/ =coin $/r.bem
|
|
|
|
=* path s.bem
|
|
|
|
::
|
2019-08-29 21:44:37 +03:00
|
|
|
?. ?=(%.y -.shop)
|
|
|
|
~
|
|
|
|
=/ =ship p.shop
|
2020-05-07 11:51:08 +03:00
|
|
|
?: &(=(care %$) =(path /whey))
|
|
|
|
=/ blocked
|
|
|
|
=/ queued (~(run by blocked.state) |=((qeu blocked-move) [%.y +<]))
|
|
|
|
(sort ~(tap by queued) aor)
|
|
|
|
::
|
|
|
|
=/ running
|
|
|
|
=/ active (~(run by yokes.state) |=(yoke [%.y +<]))
|
|
|
|
(sort ~(tap by active) aor)
|
|
|
|
::
|
|
|
|
=/ maz=(list mass)
|
|
|
|
:~ [%foreign %.y contacts.state]
|
|
|
|
[%blocked %.n blocked]
|
|
|
|
[%active %.n running]
|
|
|
|
==
|
|
|
|
``mass+!>(maz)
|
|
|
|
::
|
2020-04-22 08:37:12 +03:00
|
|
|
?: ?& =(%u care)
|
2019-08-29 21:44:37 +03:00
|
|
|
=(~ path)
|
|
|
|
=([%$ %da now] coin)
|
|
|
|
=(our ship)
|
|
|
|
==
|
2020-04-22 08:37:12 +03:00
|
|
|
[~ ~ noun+!>((~(has by yokes.state) dap))]
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
|
|
|
?. =(our ship)
|
|
|
|
~
|
|
|
|
?. =([%$ %da now] coin)
|
|
|
|
~
|
2020-04-22 08:37:12 +03:00
|
|
|
?. (~(has by yokes.state) dap)
|
|
|
|
[~ ~]
|
2019-08-29 21:44:37 +03:00
|
|
|
?. ?=(^ path)
|
|
|
|
~
|
|
|
|
=/ =routes [~ ship]
|
2020-04-22 08:37:12 +03:00
|
|
|
(mo-peek:mo dap routes care path)
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +stay: save without cache
|
|
|
|
::
|
2020-05-14 14:24:44 +03:00
|
|
|
++ stay
|
|
|
|
^- spore
|
2020-08-26 18:15:48 +03:00
|
|
|
=; eggs=(map term egg) [- | +]:state(yokes eggs)
|
2020-05-14 14:24:44 +03:00
|
|
|
%- ~(run by yokes.state)
|
2020-11-19 07:12:29 +03:00
|
|
|
|= =yoke
|
2020-11-17 23:53:05 +03:00
|
|
|
^- egg
|
|
|
|
%= yoke
|
|
|
|
agent
|
|
|
|
?: ?=(%& -.agent.yoke)
|
|
|
|
[%& on-save:p.agent.yoke]
|
|
|
|
[%| p.agent.yoke]
|
|
|
|
==
|
2019-08-29 21:44:37 +03:00
|
|
|
:: +take: response
|
|
|
|
::
|
|
|
|
++ take
|
2019-11-19 07:36:21 +03:00
|
|
|
~/ %gall-take
|
2020-07-08 09:08:27 +03:00
|
|
|
|= [=wire =duct dud=(unit goof) typ=type syn=sign-arvo]
|
2019-11-19 07:36:21 +03:00
|
|
|
^- [(list move) _gall-payload]
|
2020-02-25 01:10:59 +03:00
|
|
|
?^ dud
|
2020-04-24 07:13:19 +03:00
|
|
|
~&(%gall-take-dud ((slog tang.u.dud) [~ gall-payload]))
|
2020-04-30 11:15:28 +03:00
|
|
|
?: =(/nowhere wire)
|
|
|
|
[~ gall-payload]
|
2019-08-29 21:44:37 +03:00
|
|
|
::
|
2019-11-19 07:36:21 +03:00
|
|
|
~| [%gall-take-failed wire]
|
2019-08-29 21:44:37 +03:00
|
|
|
?> ?=([?(%sys %use) *] wire)
|
2020-07-08 09:08:27 +03:00
|
|
|
=< mo-abet
|
|
|
|
%. [t.wire ?:(?=([%b %heck *] syn) syn.syn syn)]
|
|
|
|
?- i.wire
|
|
|
|
%sys mo-handle-sys:(mo-abed:mo duct)
|
|
|
|
%use mo-handle-use:(mo-abed:mo duct)
|
|
|
|
==
|
2019-08-29 21:44:37 +03:00
|
|
|
--
|