2016-11-24 07:25:07 +03:00
|
|
|
:: clay (4c), revision control
|
2019-02-02 00:46:09 +03:00
|
|
|
!:
|
2016-11-24 07:25:07 +03:00
|
|
|
:: This is split in three top-level sections: structure definitions, main
|
|
|
|
:: logic, and arvo interface.
|
|
|
|
::
|
|
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
|
|
::
|
|
|
|
:: Here are the structures. `++raft` is the formal arvo state. It's also
|
|
|
|
:: worth noting that many of the clay-related structures are defined in zuse.
|
|
|
|
::
|
|
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
|
|
|= pit/vase
|
2016-12-07 06:13:33 +03:00
|
|
|
=, clay
|
2016-11-24 07:25:07 +03:00
|
|
|
=> |%
|
2018-08-16 02:48:37 +03:00
|
|
|
+$ aeon @ud :: version number
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
:: Recursive structure of a desk's data.
|
|
|
|
::
|
|
|
|
:: We keep an ankh only for the current version of local desks. Everywhere
|
|
|
|
:: else we store it as (map path lobe).
|
|
|
|
::
|
2018-08-16 02:48:37 +03:00
|
|
|
+$ ankh :: expanded node
|
2018-02-11 08:24:22 +03:00
|
|
|
$~ [~ ~]
|
2016-11-24 07:25:07 +03:00
|
|
|
$: fil/(unit {p/lobe q/cage}) :: file
|
|
|
|
dir/(map @ta ankh) :: folders
|
|
|
|
== ::
|
|
|
|
::
|
|
|
|
:: Part of ++mery, representing the set of changes between the mergebase and
|
|
|
|
:: one of the desks being merged.
|
|
|
|
::
|
|
|
|
:: -- `new` is the set of files in the new desk and not in the mergebase.
|
|
|
|
:: -- `cal` is the set of changes in the new desk from the mergebase except
|
|
|
|
:: for any that are also in the other new desk.
|
|
|
|
:: -- `can` is the set of changes in the new desk from the mergebase and that
|
|
|
|
:: are also in the other new desk (potential conflicts).
|
|
|
|
:: -- `old` is the set of files in the mergebase and not in the new desk.
|
|
|
|
::
|
2018-08-16 02:48:37 +03:00
|
|
|
+$ cane
|
2016-11-24 07:25:07 +03:00
|
|
|
$: new/(map path lobe)
|
|
|
|
cal/(map path lobe)
|
|
|
|
can/(map path cage)
|
2018-03-19 07:18:20 +03:00
|
|
|
old/(map path ~)
|
2016-11-24 07:25:07 +03:00
|
|
|
==
|
|
|
|
::
|
|
|
|
:: Type of request.
|
|
|
|
::
|
2020-01-23 08:23:14 +03:00
|
|
|
:: %d produces a set of desks, %p gets file permissions, %t gets all paths
|
|
|
|
:: with the specified prefix, %u checks for existence, %v produces a ++dome
|
|
|
|
:: of all desk data, %w gets @ud and @da variants for the given case, %x
|
|
|
|
:: gets file contents, %y gets a directory listing, and %z gets a recursive
|
|
|
|
:: hash of the file contents and children.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2020-01-23 08:23:14 +03:00
|
|
|
:: ++ care ?($d $p $t $u $v $w $x $y $z)
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
:: Keeps track of subscribers.
|
|
|
|
::
|
|
|
|
:: A map of requests to a set of all the subscribers who should be notified
|
|
|
|
:: when the request is filled/updated.
|
|
|
|
::
|
2018-08-16 02:48:37 +03:00
|
|
|
+$ cult (jug wove duct)
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
:: Domestic desk state.
|
|
|
|
::
|
|
|
|
:: Includes subscriber list, dome (desk content), possible commit state (for
|
2018-01-25 18:15:01 +03:00
|
|
|
:: local changes), possible merge state (for incoming merges), and permissions.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
++ dojo
|
|
|
|
$: qyx/cult :: subscribers
|
|
|
|
dom/dome :: desk state
|
2018-02-12 19:56:48 +03:00
|
|
|
per/regs :: read perms per path
|
|
|
|
pew/regs :: write perms per path
|
2016-11-24 07:25:07 +03:00
|
|
|
==
|
|
|
|
::
|
|
|
|
:: Desk state.
|
|
|
|
::
|
|
|
|
:: Includes a checked-out ankh with current content, most recent version, map
|
|
|
|
:: of all version numbers to commit hashes (commits are in hut.rang), and map
|
|
|
|
:: of labels to version numbers.
|
|
|
|
::
|
2019-05-16 01:50:13 +03:00
|
|
|
:: `mim` is a cache of the content in the directories that are mounted
|
|
|
|
:: to unix. Often, we convert to/from mime without anything really
|
|
|
|
:: having changed; this lets us short-circuit that in some cases.
|
|
|
|
:: Whenever you give an `%ergo`, you must update this.
|
|
|
|
::
|
2016-11-24 07:25:07 +03:00
|
|
|
++ dome
|
|
|
|
$: ank/ankh :: state
|
|
|
|
let/aeon :: top id
|
|
|
|
hit/(map aeon tako) :: versions by id
|
|
|
|
lab/(map @tas aeon) :: labels
|
2019-05-16 01:50:13 +03:00
|
|
|
mim/(map path mime) :: mime cache
|
2020-04-16 02:24:48 +03:00
|
|
|
fod/ford-cache :: ford cache
|
2020-06-02 06:52:20 +03:00
|
|
|
fer/(unit reef-cache) :: reef cache
|
2016-11-24 07:25:07 +03:00
|
|
|
== ::
|
|
|
|
::
|
|
|
|
:: Commit state.
|
|
|
|
::
|
|
|
|
:: -- `del` is the paths we're deleting.
|
|
|
|
:: -- `ink` is the insertions of hoon files (short-circuited for
|
|
|
|
:: bootstrapping).
|
|
|
|
:: -- `ins` is all the other insertions.
|
|
|
|
:: -- `dif` is the diffs in `dig` applied to their files.
|
|
|
|
:: -- `mut` is the diffs between `muc` and the original files.
|
|
|
|
::
|
|
|
|
++ dork :: diff work
|
|
|
|
$: del/(list path) :: deletes
|
|
|
|
ink/(list (pair path cage)) :: hoon inserts
|
2019-05-02 04:21:32 +03:00
|
|
|
ins/(list (pair path cage)) :: inserts
|
|
|
|
dif/(list (trel path lobe cage)) :: changes
|
|
|
|
mut/(list (trel path lobe cage)) :: mutations
|
2016-11-24 07:25:07 +03:00
|
|
|
== ::
|
|
|
|
::
|
2020-07-23 07:57:44 +03:00
|
|
|
:: Over-the-wire backfill request
|
|
|
|
::
|
2020-07-23 11:36:38 +03:00
|
|
|
+$ fill [=desk =lobe]
|
2020-07-23 07:57:44 +03:00
|
|
|
::
|
2020-04-16 02:24:48 +03:00
|
|
|
:: Ford cache
|
|
|
|
::
|
|
|
|
+$ ford-cache
|
|
|
|
$: vases=(map path [res=vase dez=(set path)])
|
|
|
|
marks=(map mark [res=dais dez=(set path)])
|
|
|
|
casts=(map mars [res=tube dez=(set path)])
|
2020-06-01 19:56:21 +03:00
|
|
|
==
|
|
|
|
:: $reef-cache: built system files
|
|
|
|
::
|
|
|
|
+$ reef-cache
|
2020-06-02 06:52:20 +03:00
|
|
|
$: hoon=vase
|
|
|
|
arvo=vase
|
|
|
|
zuse=vase
|
2020-04-16 02:24:48 +03:00
|
|
|
==
|
|
|
|
::
|
2016-11-24 07:25:07 +03:00
|
|
|
:: Hash of a blob, for lookup in the object store (lat.ran)
|
|
|
|
::
|
|
|
|
++ lobe @uvI :: blob ref
|
|
|
|
::
|
|
|
|
:: New desk data.
|
|
|
|
::
|
|
|
|
:: Sent to other ships to update them about a particular desk. Includes a map
|
|
|
|
:: of all new aeons to hashes of their commits, the most recent aeon, and sets
|
|
|
|
:: of all new commits and data.
|
|
|
|
::
|
2016-12-16 09:34:01 +03:00
|
|
|
++ nako :: subscription state
|
2016-11-24 07:25:07 +03:00
|
|
|
$: gar/(map aeon tako) :: new ids
|
|
|
|
let/aeon :: next id
|
|
|
|
lar/(set yaki) :: new commits
|
|
|
|
bar/(set plop) :: new content
|
|
|
|
== ::
|
|
|
|
::
|
|
|
|
:: Formal vane state.
|
|
|
|
::
|
2018-12-13 10:42:15 +03:00
|
|
|
:: -- `rom` is our domestic state.
|
2016-11-24 07:25:07 +03:00
|
|
|
:: -- `hoy` is a collection of foreign ships where we know something about
|
|
|
|
:: their clay.
|
|
|
|
:: -- `ran` is the object store.
|
|
|
|
:: -- `mon` is a collection of mount points (mount point name to urbit
|
|
|
|
:: location).
|
|
|
|
:: -- `hez` is the unix duct that %ergo's should be sent to.
|
2018-01-24 00:52:31 +03:00
|
|
|
:: -- `cez` is a collection of named permission groups.
|
2020-05-12 12:09:41 +03:00
|
|
|
:: -- `pud` is an update that's waiting on a kernel upgrade
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
++ raft :: filesystem
|
2019-05-02 04:21:32 +03:00
|
|
|
$: rom=room :: domestic
|
|
|
|
hoy=(map ship rung) :: foreign
|
|
|
|
ran=rang :: hashes
|
|
|
|
mon=(map term beam) :: mount points
|
|
|
|
hez=(unit duct) :: sync duct
|
|
|
|
cez=(map @ta crew) :: permission groups
|
2020-04-30 03:38:24 +03:00
|
|
|
pud=(unit [=desk =yoki]) :: pending update
|
2020-06-12 05:41:22 +03:00
|
|
|
pun=(list move) :: upgrade moves
|
2016-11-24 07:25:07 +03:00
|
|
|
== ::
|
|
|
|
::
|
|
|
|
:: Object store.
|
|
|
|
::
|
|
|
|
:: Maps of commit hashes to commits and content hashes to content.
|
|
|
|
::
|
2016-12-16 09:34:01 +03:00
|
|
|
++ rang ::
|
2016-11-24 07:25:07 +03:00
|
|
|
$: hut/(map tako yaki) ::
|
|
|
|
lat/(map lobe blob) ::
|
|
|
|
== ::
|
|
|
|
::
|
|
|
|
:: Unvalidated response to a request.
|
|
|
|
::
|
|
|
|
:: Like a ++rant, but with a page of data rather than a cage of it.
|
|
|
|
::
|
|
|
|
++ rand :: unvalidated rant
|
|
|
|
$: p/{p/care q/case r/@tas} :: clade release book
|
|
|
|
q/path :: spur
|
|
|
|
r/page :: data
|
|
|
|
== ::
|
|
|
|
::
|
|
|
|
:: Generic desk state.
|
|
|
|
::
|
|
|
|
:: -- `lim` is the most recent date we're confident we have all the
|
|
|
|
:: information for. For local desks, this is always `now`. For foreign
|
|
|
|
:: desks, this is the last time we got a full update from the foreign
|
|
|
|
:: urbit.
|
|
|
|
:: -- `ref` is a possible request manager. For local desks, this is null.
|
|
|
|
:: For foreign desks, this keeps track of all pending foreign requests
|
|
|
|
:: plus a cache of the responses to previous requests.
|
|
|
|
:: -- `qyx` is the set of subscriptions, with listening ducts. These
|
|
|
|
:: subscriptions exist only until they've been filled.
|
|
|
|
:: -- `dom` is the actual state of the filetree. Since this is used almost
|
|
|
|
:: exclusively in `++ze`, we describe it there.
|
|
|
|
::
|
|
|
|
++ rede :: universal project
|
|
|
|
$: lim/@da :: complete to
|
|
|
|
ref/(unit rind) :: outgoing requests
|
|
|
|
qyx/cult :: subscribers
|
|
|
|
dom/dome :: revision state
|
2018-02-12 19:56:48 +03:00
|
|
|
per/regs :: read perms per path
|
|
|
|
pew/regs :: write perms per path
|
2016-11-24 07:25:07 +03:00
|
|
|
== ::
|
|
|
|
::
|
|
|
|
:: Foreign request manager.
|
|
|
|
::
|
|
|
|
:: When we send a request to a foreign ship, we keep track of it in here. This
|
|
|
|
:: includes a request counter, a map of request numbers to requests, a reverse
|
|
|
|
:: map of requesters to request numbers, a simple cache of common %sing
|
|
|
|
:: requests, and a possible nako if we've received data from the other ship and
|
|
|
|
:: are in the process of validating it.
|
|
|
|
::
|
2020-07-23 07:57:44 +03:00
|
|
|
+$ rind :: request manager
|
|
|
|
$: nix=@ud :: request index
|
2020-07-23 11:36:38 +03:00
|
|
|
bom=(map @ud update-state) :: outstanding
|
2020-07-23 07:57:44 +03:00
|
|
|
fod=(map duct @ud) :: current requests
|
|
|
|
haw=(map mood (unit cage)) :: simple cache
|
|
|
|
== ::
|
2020-07-23 11:36:38 +03:00
|
|
|
::
|
|
|
|
:: Active downloads
|
|
|
|
::
|
|
|
|
+$ update-state
|
|
|
|
$: =duct
|
|
|
|
=rave
|
|
|
|
have=(map lobe blob)
|
|
|
|
need=(list lobe)
|
|
|
|
nako=(qeu (unit nako))
|
|
|
|
busy=_|
|
|
|
|
==
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
:: Result of a subscription
|
|
|
|
::
|
|
|
|
++ sub-result
|
|
|
|
$% [%blab =mood data=(each cage lobe)]
|
2020-07-23 07:57:44 +03:00
|
|
|
[%bleb ver=@ud ins=@ud range=(unit (pair aeon aeon))]
|
2019-05-23 00:39:12 +03:00
|
|
|
[%balk cage=(unit (each cage lobe)) =mood]
|
|
|
|
[%blas moods=(set mood)]
|
|
|
|
[%blub ~]
|
|
|
|
==
|
|
|
|
::
|
2016-11-24 07:25:07 +03:00
|
|
|
:: Domestic ship.
|
|
|
|
::
|
|
|
|
:: `hun` is the duct to dill, and `dos` is a collection of our desks.
|
|
|
|
::
|
|
|
|
++ room :: fs per ship
|
|
|
|
$: hun/duct :: terminal duct
|
|
|
|
dos/(map desk dojo) :: native desk
|
|
|
|
== ::
|
|
|
|
::
|
|
|
|
:: Stored request.
|
|
|
|
::
|
|
|
|
:: Like a ++rave but with caches of current versions for %next and %many.
|
|
|
|
:: Generally used when we store a request in our state somewhere.
|
|
|
|
::
|
2018-01-22 18:01:00 +03:00
|
|
|
++ cach (unit (unit (each cage lobe))) :: cached result
|
2020-07-23 07:57:44 +03:00
|
|
|
+$ wove [for=(unit [=ship ver=@ud]) =rove] :: stored source + req
|
2019-05-23 08:45:06 +03:00
|
|
|
++ rove :: stored request
|
2019-05-23 00:39:12 +03:00
|
|
|
$% [%sing =mood] :: single request
|
|
|
|
[%next =mood aeon=(unit aeon) =cach] :: next version of one
|
|
|
|
$: %mult :: next version of any
|
|
|
|
=mool :: original request
|
|
|
|
aeon=(unit aeon) :: checking for change
|
|
|
|
old-cach=(map [=care =path] cach) :: old version
|
|
|
|
new-cach=(map [=care =path] cach) :: new version
|
2018-01-23 19:35:12 +03:00
|
|
|
== ::
|
2019-05-23 00:39:12 +03:00
|
|
|
[%many track=? =moat lobes=(map path lobe)] :: change range
|
2016-11-24 07:25:07 +03:00
|
|
|
== ::
|
|
|
|
::
|
|
|
|
:: Foreign desk data.
|
|
|
|
::
|
2019-02-02 00:46:09 +03:00
|
|
|
++ rung
|
jael: provide edge-triggered breach notification
Until now, clients of Jael have had to store the first-seen rift if they
want to reliably detect breaches. Otherwise, they would get a false
positive if they heard an old message about a breach (eg if you kick
azimuth-tracker). Clay and Gall did this correctly, but Ames did not.
Jael already maintains this state, so I added a notification to the
existing subscription that happens whenever it notices a breach (a diff
or full where the new rift is greater than the old one).
Because this is an issue on the live network, I wrote state adapters
for Gall and Clay. The Gall one just removes the rift from our state,
but the Clay one is much more involved because we have to upgrade
instances of the clad monad that are possibly in progress.
Specifically, since more input is possible than before, we must wrap any
in-progress instances of the monad in a function that handles the
potential new input from Jael. This temporarily preservers a copy of
the old kernel, but only until the current commit/merge/update has
completed.
The real solution for Clay is to factor out those IO-heavy instances to
userspace tapp/async/imp/threads, and if an upgrade happens in the
middle, you should simply restart them.
Fixes #1852
2019-10-24 07:26:38 +03:00
|
|
|
$: rus=(map desk rede) :: neighbor desks
|
2019-02-02 00:46:09 +03:00
|
|
|
==
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
++ move {p/duct q/(wind note gift:able)} :: local move
|
|
|
|
++ note :: out request $->
|
2019-05-25 12:29:42 +03:00
|
|
|
$~ [%b %wait *@da] ::
|
|
|
|
$% $: %a :: to %ames
|
2019-07-29 09:37:49 +03:00
|
|
|
$>(%plea task:able:ames) ::
|
2019-05-25 12:29:42 +03:00
|
|
|
== ::
|
|
|
|
$: %b :: to %behn
|
2020-05-21 11:10:39 +03:00
|
|
|
$> $? %drip ::
|
|
|
|
%rest ::
|
2019-05-25 12:29:42 +03:00
|
|
|
%wait ::
|
|
|
|
== ::
|
|
|
|
task:able:behn ::
|
|
|
|
== ::
|
|
|
|
$: %c :: to %clay
|
|
|
|
$> $? %info :: internal edit
|
|
|
|
%merg :: merge desks
|
2020-04-25 03:44:29 +03:00
|
|
|
%pork ::
|
2019-05-25 12:29:42 +03:00
|
|
|
%warp ::
|
|
|
|
%werp ::
|
|
|
|
== ::
|
|
|
|
task:able ::
|
|
|
|
== ::
|
|
|
|
$: %d :: to %dill
|
|
|
|
$>(%flog task:able:dill) ::
|
|
|
|
== ::
|
2020-03-25 02:48:18 +03:00
|
|
|
$: %g :: to %gall
|
|
|
|
$>(%deal task:able:gall) ::
|
|
|
|
== ::
|
2019-08-07 01:42:37 +03:00
|
|
|
$: %j :: by %jael
|
|
|
|
$>(%public-keys task:able:jael) ::
|
2019-01-31 05:48:30 +03:00
|
|
|
== == ::
|
2016-11-24 07:25:07 +03:00
|
|
|
++ riot (unit rant) :: response+complete
|
|
|
|
++ sign :: in result $<-
|
2019-05-25 12:29:42 +03:00
|
|
|
$~ [%b %wake ~] ::
|
2020-05-13 08:53:23 +03:00
|
|
|
$% $: %a :: by %ames
|
2019-08-28 06:12:56 +03:00
|
|
|
$> $? %boon :: response
|
|
|
|
%done :: (n)ack
|
|
|
|
%lost :: lost boon
|
2019-05-25 12:29:42 +03:00
|
|
|
== ::
|
|
|
|
gift:able:ames ::
|
|
|
|
== ::
|
|
|
|
$: %b :: by %behn
|
|
|
|
$% $>(%wake gift:able:behn) :: timer activate
|
|
|
|
$>(%writ gift:able) :: XX %slip
|
|
|
|
== == ::
|
|
|
|
$: %c :: by %clay
|
|
|
|
$> $? %mere ::
|
|
|
|
%note ::
|
|
|
|
%writ ::
|
|
|
|
== ::
|
|
|
|
gift:able ::
|
|
|
|
== ::
|
2019-08-07 01:42:37 +03:00
|
|
|
$: %j :: by %jael
|
|
|
|
$>(%public-keys gift:able:jael) ::
|
2019-07-27 06:43:07 +03:00
|
|
|
== ::
|
2019-05-25 12:29:42 +03:00
|
|
|
$: @tas :: by any
|
2019-05-27 10:41:03 +03:00
|
|
|
$>(%crud vane-task) :: XX strange
|
|
|
|
== == ::
|
2016-11-24 07:25:07 +03:00
|
|
|
-- =>
|
2020-03-04 01:12:01 +03:00
|
|
|
~% %clay-utilities ..is ~
|
2018-10-04 21:37:42 +03:00
|
|
|
:: %utilities
|
|
|
|
::
|
|
|
|
|%
|
|
|
|
:: +sort-by-head: sorts alphabetically using the head of each element
|
|
|
|
::
|
|
|
|
++ sort-by-head
|
|
|
|
|=([a=(pair path *) b=(pair path *)] (aor p.a p.b))
|
|
|
|
::
|
2020-04-28 12:56:28 +03:00
|
|
|
:: By convention: paf == (weld pax pat)
|
|
|
|
::
|
|
|
|
++ mode-to-commit
|
|
|
|
|= [hat=(map path lobe) pax=path all=? mod=mode]
|
|
|
|
^- [deletes=(set path) changes=(map path cage)]
|
|
|
|
=/ deletes
|
|
|
|
%- silt
|
|
|
|
%+ turn
|
|
|
|
^- (list path)
|
|
|
|
%+ weld
|
|
|
|
^- (list path)
|
|
|
|
%+ murn mod
|
|
|
|
|= [pat=path mim=(unit mime)]
|
|
|
|
^- (unit path)
|
|
|
|
?^ mim
|
|
|
|
~
|
|
|
|
`pat
|
|
|
|
^- (list path)
|
|
|
|
?. all
|
|
|
|
~
|
|
|
|
=+ mad=(malt mod)
|
|
|
|
=+ len=(lent pax)
|
|
|
|
=/ descendants=(list path)
|
|
|
|
%+ turn
|
|
|
|
%+ skim ~(tap by hat)
|
|
|
|
|= [paf=path lob=lobe]
|
|
|
|
=(pax (scag len paf))
|
|
|
|
|= [paf=path lob=lobe]
|
|
|
|
(slag len paf)
|
|
|
|
%+ skim
|
|
|
|
descendants
|
|
|
|
|= pat=path
|
|
|
|
(~(has by mad) pat)
|
|
|
|
|= pat=path
|
|
|
|
(weld pax pat)
|
|
|
|
::
|
|
|
|
=/ changes
|
|
|
|
%- malt
|
|
|
|
%+ murn mod
|
|
|
|
|= [pat=path mim=(unit mime)]
|
|
|
|
^- (unit [path cage])
|
|
|
|
?~ mim
|
|
|
|
~
|
|
|
|
`[(weld pax pat) %mime !>(u.mim)]
|
|
|
|
::
|
|
|
|
[deletes changes]
|
2018-10-04 21:37:42 +03:00
|
|
|
-- =>
|
2020-03-04 01:12:01 +03:00
|
|
|
~% %clay + ~
|
2019-05-03 04:50:20 +03:00
|
|
|
|%
|
2019-05-23 08:35:09 +03:00
|
|
|
:: Printable form of a wove; useful for debugging
|
|
|
|
::
|
|
|
|
++ print-wove
|
|
|
|
|= =wove
|
|
|
|
:- for.wove
|
|
|
|
?- -.rove.wove
|
|
|
|
%sing [%sing mood.rove.wove]
|
|
|
|
%next [%next [mood aeon]:rove.wove]
|
|
|
|
%mult [%mult [mool aeon]:rove.wove]
|
|
|
|
%many [%many [track moat]:rove.wove]
|
|
|
|
==
|
|
|
|
::
|
|
|
|
:: Printable form of a cult; useful for debugging
|
|
|
|
::
|
|
|
|
++ print-cult
|
|
|
|
|= =cult
|
|
|
|
%+ turn ~(tap by cult)
|
|
|
|
|= [=wove ducts=(set duct)]
|
|
|
|
[ducts (print-wove wove)]
|
|
|
|
::
|
2020-04-16 05:10:22 +03:00
|
|
|
++ fusion
|
|
|
|
=>
|
|
|
|
|%
|
|
|
|
:: +an: $ankh interface door
|
|
|
|
::
|
|
|
|
++ an
|
|
|
|
|_ nak=ankh
|
|
|
|
:: +get: produce file at path
|
|
|
|
::
|
|
|
|
++ get
|
|
|
|
|= =path
|
|
|
|
^- (unit cage)
|
|
|
|
?~ path
|
|
|
|
?~ fil.nak
|
|
|
|
~
|
|
|
|
`q.u.fil.nak
|
|
|
|
?~ kid=(~(get by dir.nak) i.path)
|
|
|
|
~
|
|
|
|
$(nak u.kid, path t.path)
|
|
|
|
--
|
|
|
|
++ with-face |=([face=@tas =vase] vase(p [%face face p.vase]))
|
|
|
|
++ with-faces
|
|
|
|
=| res=(unit vase)
|
|
|
|
|= vaz=(list [face=@tas =vase])
|
|
|
|
^- vase
|
|
|
|
?~ vaz (need res)
|
|
|
|
=/ faz (with-face i.vaz)
|
|
|
|
=. res `?~(res faz (slop faz u.res))
|
|
|
|
$(vaz t.vaz)
|
|
|
|
--
|
|
|
|
|%
|
2020-04-17 06:18:02 +03:00
|
|
|
:: +wrap: external wrapper
|
|
|
|
::
|
|
|
|
++ wrap
|
|
|
|
|* [* state:ford]
|
|
|
|
[+<- +<+>-] :: cache.state
|
|
|
|
::
|
2020-04-16 05:10:22 +03:00
|
|
|
++ ford
|
2020-06-20 10:45:53 +03:00
|
|
|
!.
|
2020-04-16 05:10:22 +03:00
|
|
|
=> |%
|
2020-04-16 23:30:55 +03:00
|
|
|
+$ build
|
|
|
|
$% [%file =path]
|
|
|
|
[%mark =mark]
|
|
|
|
[%cast =mars]
|
|
|
|
[%vale =path]
|
|
|
|
==
|
2020-04-16 05:10:22 +03:00
|
|
|
+$ state
|
2020-04-17 09:23:19 +03:00
|
|
|
$: baked=(map path cage)
|
2020-04-16 05:10:22 +03:00
|
|
|
cache=ford-cache
|
|
|
|
stack=(list (set path))
|
2020-04-16 23:30:55 +03:00
|
|
|
cycle=(set build)
|
2020-04-16 05:10:22 +03:00
|
|
|
==
|
2020-04-17 06:18:02 +03:00
|
|
|
+$ args
|
2020-06-02 06:52:20 +03:00
|
|
|
$: bud=vase
|
|
|
|
=ankh
|
2020-04-17 06:18:02 +03:00
|
|
|
deletes=(set path)
|
|
|
|
changes=(map path (each page lobe))
|
|
|
|
file-store=(map lobe blob)
|
|
|
|
=ford-cache
|
|
|
|
==
|
2020-04-16 05:10:22 +03:00
|
|
|
--
|
2020-04-17 06:18:02 +03:00
|
|
|
|= args
|
2020-04-16 05:10:22 +03:00
|
|
|
:: nub: internal mutable state for this computation
|
|
|
|
::
|
|
|
|
=| nub=state
|
|
|
|
=. cache.nub ford-cache
|
|
|
|
|%
|
|
|
|
:: +pop-stack: pop build stack, copying deps downward
|
|
|
|
::
|
|
|
|
++ pop-stack
|
|
|
|
^- [(set path) _stack.nub]
|
|
|
|
=^ top=(set path) stack.nub stack.nub
|
|
|
|
=? stack.nub ?=(^ stack.nub)
|
|
|
|
stack.nub(i (~(uni in i.stack.nub) top))
|
|
|
|
[top stack.nub]
|
|
|
|
::
|
|
|
|
++ get-value
|
|
|
|
|= =path
|
2020-04-17 09:23:19 +03:00
|
|
|
^- [cage state]
|
2020-04-28 07:52:07 +03:00
|
|
|
~| %error-validating^path
|
2020-04-17 09:14:41 +03:00
|
|
|
?^ got=(~(get by baked.nub) path)
|
|
|
|
[u.got nub]
|
2020-04-17 09:23:19 +03:00
|
|
|
=; [res=cage bun=state]
|
2020-04-17 09:14:41 +03:00
|
|
|
=. nub bun
|
|
|
|
=. baked.nub (~(put by baked.nub) path res)
|
|
|
|
[res nub]
|
2020-04-16 23:30:55 +03:00
|
|
|
?: (~(has in cycle.nub) vale+path)
|
|
|
|
~|(cycle+vale+path^stack.nub !!)
|
|
|
|
=. cycle.nub (~(put in cycle.nub) vale+path)
|
2020-04-16 05:10:22 +03:00
|
|
|
?^ change=(~(get by changes) path)
|
|
|
|
=^ page nub
|
|
|
|
?: ?=(%& -.u.change)
|
|
|
|
[p.u.change nub]
|
|
|
|
~| %ugly-lobe^p.u.change^path
|
|
|
|
(lobe-to-page p.u.change)
|
2020-04-28 07:52:07 +03:00
|
|
|
=^ cage nub (validate-page path page)
|
2020-04-17 09:23:19 +03:00
|
|
|
[cage nub]
|
|
|
|
?< (~(has in deletes) path)
|
2020-06-20 10:45:53 +03:00
|
|
|
~| %file-not-found^path
|
2020-04-17 09:23:19 +03:00
|
|
|
:_(nub (need (~(get an ankh) path)))
|
2020-04-16 05:10:22 +03:00
|
|
|
:: +get-mark: build a mark definition
|
|
|
|
::
|
|
|
|
++ get-mark
|
|
|
|
|= mak=mark
|
|
|
|
^- [dais state]
|
2020-04-16 15:45:48 +03:00
|
|
|
~| %error-building-mark^mak
|
2020-04-16 05:10:22 +03:00
|
|
|
?^ got=(~(get by marks.cache.nub) mak)
|
|
|
|
=? stack.nub ?=(^ stack.nub)
|
|
|
|
stack.nub(i (~(uni in i.stack.nub) dez.u.got))
|
|
|
|
[res.u.got nub]
|
2020-04-16 23:30:55 +03:00
|
|
|
?: (~(has in cycle.nub) mark+mak)
|
|
|
|
~|(cycle+mark+mak^stack.nub !!)
|
|
|
|
=. cycle.nub (~(put in cycle.nub) mark+mak)
|
2020-04-16 05:10:22 +03:00
|
|
|
=. stack.nub [~ stack.nub]
|
|
|
|
=; res=[=dais nub=state]
|
|
|
|
=. nub nub.res
|
|
|
|
=^ top stack.nub pop-stack
|
|
|
|
=. marks.cache.nub (~(put by marks.cache.nub) mak [dais.res top])
|
|
|
|
[dais.res nub]
|
2020-04-20 09:41:20 +03:00
|
|
|
=^ cor=vase nub (build-fit %mar mak)
|
2020-04-16 05:10:22 +03:00
|
|
|
=/ gad=vase (slap cor %limb %grad)
|
|
|
|
?@ q.gad
|
|
|
|
=+ !<(mok=mark gad)
|
|
|
|
=^ deg=dais nub $(mak mok)
|
|
|
|
=^ tub=tube nub (get-cast mak mok)
|
|
|
|
=^ but=tube nub (get-cast mok mak)
|
|
|
|
:_ nub
|
|
|
|
^- dais
|
|
|
|
|_ sam=vase
|
|
|
|
++ bunt (slap cor $+6)
|
|
|
|
++ diff
|
|
|
|
|= new=vase
|
|
|
|
^- vase
|
|
|
|
(~(diff deg (tub sam)) (tub new))
|
|
|
|
++ form form:deg
|
|
|
|
++ join join:deg
|
|
|
|
++ mash mash:deg
|
|
|
|
++ pact
|
|
|
|
|= diff=vase
|
|
|
|
^+ sam
|
|
|
|
(but (~(pact deg (tub sam)) diff))
|
|
|
|
++ vale
|
|
|
|
|= =noun
|
|
|
|
^+ sam
|
2020-11-03 02:27:10 +03:00
|
|
|
(slam (slap cor !,(*hoon noun:grab)) !>(noun))
|
2020-04-16 05:10:22 +03:00
|
|
|
++ volt
|
|
|
|
|= =noun
|
|
|
|
^+ sam
|
|
|
|
[p:bunt noun]
|
|
|
|
--
|
|
|
|
:_ nub
|
|
|
|
=+ !<(fom=mark (slap gad %limb %form))
|
|
|
|
^- dais
|
|
|
|
|_ sam=vase
|
|
|
|
++ bunt (slap cor $+6)
|
|
|
|
++ diff
|
|
|
|
|= new=vase
|
|
|
|
^- vase
|
|
|
|
%+ slap
|
|
|
|
(with-faces cor+cor sam+sam new+new ~)
|
2020-11-03 02:27:10 +03:00
|
|
|
!, *hoon
|
|
|
|
(diff:~(grad cor sam) new)
|
2020-04-16 05:10:22 +03:00
|
|
|
++ form fom
|
|
|
|
++ join
|
|
|
|
|= [a=vase b=vase]
|
|
|
|
^- (unit (unit vase))
|
|
|
|
?: =(q.a q.b)
|
|
|
|
~
|
2020-11-03 02:27:10 +03:00
|
|
|
=; res `?~(q.res ~ `(slap res !,(*hoon ?~(. !! u))))
|
|
|
|
(slam (slap cor !,(*hoon join:grad)) (slop a b))
|
2020-04-16 05:10:22 +03:00
|
|
|
++ mash
|
|
|
|
|= [a=[=ship =desk diff=vase] b=[=ship =desk diff=vase]]
|
|
|
|
^- (unit vase)
|
|
|
|
?: =(q.diff.a q.diff.b)
|
|
|
|
~
|
|
|
|
:- ~
|
2020-11-03 02:27:10 +03:00
|
|
|
%+ slam (slap cor !,(*hoon mash:grad))
|
2020-04-16 05:10:22 +03:00
|
|
|
%+ slop
|
|
|
|
:(slop !>(ship.a) !>(desk.a) diff.a)
|
|
|
|
:(slop !>(ship.b) !>(desk.b) diff.b)
|
|
|
|
++ pact
|
|
|
|
|= diff=vase
|
|
|
|
^+ sam
|
|
|
|
%+ slap
|
|
|
|
(with-faces cor+cor sam+sam diff+diff ~)
|
2020-11-03 02:27:10 +03:00
|
|
|
!, *hoon
|
|
|
|
(pact:~(grad cor sam) diff)
|
2020-04-16 05:10:22 +03:00
|
|
|
++ vale
|
|
|
|
|= =noun
|
|
|
|
^+ sam
|
2020-11-03 02:27:10 +03:00
|
|
|
(slam (slap cor !,(*hoon noun:grab)) !>(noun))
|
2020-04-16 05:10:22 +03:00
|
|
|
++ volt
|
|
|
|
|= =noun
|
|
|
|
^+ sam
|
|
|
|
[p:bunt noun]
|
|
|
|
--
|
2020-04-16 15:45:48 +03:00
|
|
|
:: +get-cast: produce a $tube mark conversion gate from .a to .b
|
2020-04-16 05:10:22 +03:00
|
|
|
::
|
|
|
|
++ get-cast
|
|
|
|
|= [a=mark b=mark]
|
|
|
|
^- [tube state]
|
2020-04-16 15:45:48 +03:00
|
|
|
~| error-building-cast+[a b]
|
2020-04-28 07:52:07 +03:00
|
|
|
?: =([%mime %hoon] [a b])
|
|
|
|
:_ nub
|
|
|
|
|= sam=vase
|
|
|
|
=+ !<(=mime sam)
|
|
|
|
!>(q.q.mime)
|
2020-04-16 15:45:48 +03:00
|
|
|
?^ got=(~(get by casts.cache.nub) [a b])
|
|
|
|
=? stack.nub ?=(^ stack.nub)
|
|
|
|
stack.nub(i (~(uni in i.stack.nub) dez.u.got))
|
|
|
|
[res.u.got nub]
|
2020-04-16 23:30:55 +03:00
|
|
|
?: (~(has in cycle.nub) cast+[a b])
|
|
|
|
~|(cycle+cast+[a b]^stack.nub !!)
|
2020-04-16 15:45:48 +03:00
|
|
|
=. stack.nub [~ stack.nub]
|
|
|
|
=; res=[=tube nub=state]
|
|
|
|
=. nub nub.res
|
|
|
|
=^ top stack.nub pop-stack
|
|
|
|
=. casts.cache.nub (~(put by casts.cache.nub) [a b] [tube.res top])
|
|
|
|
[tube.res nub]
|
2020-05-06 01:24:16 +03:00
|
|
|
:: try +grow; is there a +grow core with a .b arm?
|
2020-04-16 15:45:48 +03:00
|
|
|
::
|
2020-04-20 09:41:20 +03:00
|
|
|
=^ old=vase nub (build-fit %mar a)
|
2020-11-03 02:27:10 +03:00
|
|
|
?: =/ ram (mule |.((slap old !,(*hoon grow))))
|
2020-05-06 01:24:16 +03:00
|
|
|
?: ?=(%| -.ram) %.n
|
2020-05-06 08:09:35 +03:00
|
|
|
=/ lab (mule |.((slob b p.p.ram)))
|
2020-05-06 01:24:16 +03:00
|
|
|
?: ?=(%| -.lab) %.n
|
|
|
|
p.lab
|
|
|
|
:: +grow core has .b arm; use that
|
|
|
|
::
|
2020-04-16 15:45:48 +03:00
|
|
|
:_ nub
|
|
|
|
^- tube
|
|
|
|
|= sam=vase
|
|
|
|
^- vase
|
|
|
|
%+ slap
|
|
|
|
(with-faces old+old sam+sam ~)
|
2020-11-03 02:27:10 +03:00
|
|
|
:+ %sgzp !,(*hoon old=old)
|
|
|
|
:+ %sgzp !,(*hoon sam=sam)
|
2020-11-17 10:05:17 +03:00
|
|
|
:+ %tsgl [%limb b]
|
2020-11-03 02:27:10 +03:00
|
|
|
!, *hoon
|
|
|
|
~(grow old sam)
|
2020-04-16 15:45:48 +03:00
|
|
|
:: try direct +grab
|
|
|
|
::
|
2020-04-20 09:41:20 +03:00
|
|
|
=^ new=vase nub (build-fit %mar b)
|
2020-11-03 02:27:10 +03:00
|
|
|
=/ rab
|
|
|
|
%- mule |.
|
|
|
|
%+ slap new
|
2020-11-17 10:05:17 +03:00
|
|
|
:+ %tsgl [%limb a]
|
2020-11-03 18:33:22 +03:00
|
|
|
[%limb %grab]
|
2020-04-16 15:45:48 +03:00
|
|
|
?: &(?=(%& -.rab) ?=(^ q.p.rab))
|
2020-05-01 09:14:16 +03:00
|
|
|
:_(nub |=(sam=vase ~|([%grab a b] (slam p.rab sam))))
|
2020-04-16 15:45:48 +03:00
|
|
|
:: try +jump
|
|
|
|
::
|
2020-11-03 02:27:10 +03:00
|
|
|
=/ jum
|
|
|
|
%- mule |.
|
|
|
|
%+ slap old
|
2020-11-17 10:05:17 +03:00
|
|
|
:+ %tsgl [%limb b]
|
2020-11-03 18:33:22 +03:00
|
|
|
[%limb %jump]
|
2020-04-16 15:45:48 +03:00
|
|
|
?: ?=(%& -.jum)
|
|
|
|
(compose-casts a !<(mark p.jum) b)
|
|
|
|
:: try indirect +grab
|
|
|
|
::
|
|
|
|
?: ?=(%& -.rab)
|
|
|
|
(compose-casts a !<(mark p.rab) b)
|
|
|
|
~|(no-cast-from+[a b] !!)
|
|
|
|
::
|
|
|
|
++ compose-casts
|
|
|
|
|= [x=mark y=mark z=mark]
|
|
|
|
^- [tube state]
|
|
|
|
=^ uno=tube nub (get-cast x y)
|
|
|
|
=^ dos=tube nub (get-cast y z)
|
|
|
|
:_(nub |=(sam=vase (dos (uno sam))))
|
|
|
|
::
|
2020-04-16 05:10:22 +03:00
|
|
|
++ lobe-to-page
|
|
|
|
|= =lobe
|
|
|
|
^- [page state]
|
|
|
|
=/ =blob (~(got by file-store) lobe)
|
|
|
|
|- ^- [page state]
|
|
|
|
?- -.blob
|
|
|
|
%direct [q.blob nub]
|
|
|
|
%delta
|
|
|
|
=/ [[=mark =parent=^lobe] diff=page] [q r]:blob
|
|
|
|
=^ parent-page nub $(blob (~(got by file-store) parent-lobe))
|
|
|
|
=^ =cage nub (run-pact parent-page diff)
|
|
|
|
[[p q.q]:cage nub]
|
|
|
|
==
|
2020-04-16 15:45:48 +03:00
|
|
|
::
|
2020-04-28 07:52:07 +03:00
|
|
|
++ validate-page
|
2020-04-16 05:10:22 +03:00
|
|
|
|= [=path =page]
|
|
|
|
^- [cage state]
|
2020-04-28 07:52:07 +03:00
|
|
|
~| validate-page-fail+path^from+p.page
|
2020-04-16 16:28:14 +03:00
|
|
|
=/ mak=mark (head (flop path))
|
|
|
|
?: =(mak p.page)
|
|
|
|
(page-to-cage page)
|
|
|
|
=^ [mark vax=vase] nub (page-to-cage page)
|
|
|
|
=^ =tube nub (get-cast p.page mak)
|
|
|
|
:_(nub [mak (tube vax)])
|
|
|
|
::
|
|
|
|
++ page-to-cage
|
|
|
|
|= =page
|
|
|
|
^- [cage state]
|
2020-04-16 15:45:48 +03:00
|
|
|
?: =(%hoon p.page)
|
|
|
|
:_(nub [%hoon -:!>(*@t) q.page])
|
2020-04-28 07:52:07 +03:00
|
|
|
?: =(%mime p.page)
|
|
|
|
:_(nub [%mime !>(;;(mime q.page))])
|
2020-04-16 15:45:48 +03:00
|
|
|
=^ =dais nub (get-mark p.page)
|
|
|
|
:_(nub [p.page (vale:dais q.page)])
|
|
|
|
::
|
2020-04-16 05:10:22 +03:00
|
|
|
++ cast-path
|
2020-04-16 16:28:14 +03:00
|
|
|
|= [=path mak=mark]
|
2020-04-16 05:10:22 +03:00
|
|
|
^- [cage state]
|
2020-04-16 16:28:14 +03:00
|
|
|
=/ mok (head (flop path))
|
2020-04-18 05:50:03 +03:00
|
|
|
~| error-casting-path+[path mok mak]
|
|
|
|
=^ cag=cage nub (get-value path)
|
2020-04-16 16:28:14 +03:00
|
|
|
?: =(mok mak)
|
2020-04-17 09:23:19 +03:00
|
|
|
[cag nub]
|
2020-04-17 06:18:02 +03:00
|
|
|
=^ =tube nub (get-cast mok mak)
|
2020-04-18 05:50:03 +03:00
|
|
|
~| error-running-cast+[path mok mak]
|
2020-04-17 09:23:19 +03:00
|
|
|
:_(nub [mak (tube q.cag)])
|
2020-04-16 16:28:14 +03:00
|
|
|
::
|
2020-04-16 05:10:22 +03:00
|
|
|
++ run-pact
|
|
|
|
|= [old=page diff=page]
|
|
|
|
^- [cage state]
|
2020-06-25 06:26:04 +03:00
|
|
|
?: ?=(%hoon p.old)
|
|
|
|
=/ txt=wain (to-wain:format ;;(@t q.old))
|
|
|
|
=+ ;;(dif=(urge cord) q.diff)
|
|
|
|
=/ new=@t (of-wain:format (lurk:differ txt dif))
|
|
|
|
:_(nub [%hoon !>(new)])
|
2020-04-16 16:38:34 +03:00
|
|
|
=^ dys=dais nub (get-mark p.old)
|
|
|
|
=^ syd=dais nub (get-mark p.diff)
|
|
|
|
:_(nub [p.old (~(pact dys (vale:dys q.old)) (vale:syd q.diff))])
|
|
|
|
::
|
2020-05-14 09:26:52 +03:00
|
|
|
++ prelude
|
|
|
|
|= =path
|
|
|
|
^- vase
|
|
|
|
=^ cag=cage nub (get-value path)
|
|
|
|
?> =(%hoon p.cag)
|
|
|
|
=/ tex=tape (trip !<(@t q.cag))
|
|
|
|
=/ =pile (parse-pile path tex)
|
|
|
|
=. hoon.pile !,(*hoon .)
|
|
|
|
=^ res=vase nub (run-pile pile)
|
|
|
|
res
|
|
|
|
::
|
2020-04-16 05:10:22 +03:00
|
|
|
++ build-file
|
|
|
|
|= =path
|
|
|
|
^- [vase state]
|
2020-04-19 02:53:45 +03:00
|
|
|
~| %error-building^path
|
2020-04-16 05:10:22 +03:00
|
|
|
?^ got=(~(get by vases.cache.nub) path)
|
|
|
|
=? stack.nub ?=(^ stack.nub)
|
|
|
|
stack.nub(i (~(uni in i.stack.nub) dez.u.got))
|
|
|
|
[res.u.got nub]
|
2020-04-16 23:30:55 +03:00
|
|
|
?: (~(has in cycle.nub) file+path)
|
|
|
|
~|(cycle+file+path^stack.nub !!)
|
|
|
|
=. cycle.nub (~(put in cycle.nub) file+path)
|
2020-04-16 05:10:22 +03:00
|
|
|
=. stack.nub [(sy path ~) stack.nub]
|
2020-04-17 09:23:19 +03:00
|
|
|
=^ cag=cage nub (get-value path)
|
|
|
|
?> =(%hoon p.cag)
|
|
|
|
=/ tex=tape (trip !<(@t q.cag))
|
2020-04-16 05:10:22 +03:00
|
|
|
=/ =pile (parse-pile path tex)
|
2020-05-14 09:26:52 +03:00
|
|
|
=^ res=vase nub (run-pile pile)
|
|
|
|
=^ top stack.nub pop-stack
|
|
|
|
=. vases.cache.nub (~(put by vases.cache.nub) path [res top])
|
|
|
|
[res nub]
|
|
|
|
::
|
|
|
|
++ run-pile
|
|
|
|
|= =pile
|
2020-06-02 06:52:20 +03:00
|
|
|
=^ sut=vase nub (run-tauts bud %sur sur.pile)
|
2020-04-19 02:53:45 +03:00
|
|
|
=^ sut=vase nub (run-tauts sut %lib lib.pile)
|
|
|
|
=^ sut=vase nub (run-raw sut raw.pile)
|
|
|
|
=^ sut=vase nub (run-bar sut bar.pile)
|
2020-06-19 07:44:17 +03:00
|
|
|
=/ res=vase (road |.((slap sut hoon.pile)))
|
2020-04-16 05:10:22 +03:00
|
|
|
[res nub]
|
|
|
|
::
|
|
|
|
++ parse-pile
|
2020-04-19 02:53:45 +03:00
|
|
|
|= [pax=path tex=tape]
|
2020-04-16 05:10:22 +03:00
|
|
|
^- pile
|
2020-04-19 02:53:45 +03:00
|
|
|
=/ [=hair res=(unit [=pile =nail])] ((pile-rule pax) [1 1] tex)
|
|
|
|
?^ res pile.u.res
|
2020-06-29 18:01:23 +03:00
|
|
|
%- mean %- flop
|
2020-04-16 16:55:48 +03:00
|
|
|
=/ lyn p.hair
|
|
|
|
=/ col q.hair
|
2020-04-19 02:53:45 +03:00
|
|
|
:~ leaf+"syntax error at [{<lyn>} {<col>}] in {<pax>}"
|
2020-04-16 16:55:48 +03:00
|
|
|
leaf+(trip (snag (dec lyn) (to-wain:format (crip tex))))
|
|
|
|
leaf+(runt [(dec col) '-'] "^")
|
|
|
|
==
|
2020-04-16 05:10:22 +03:00
|
|
|
::
|
2020-04-19 02:53:45 +03:00
|
|
|
++ pile-rule
|
|
|
|
|= pax=path
|
|
|
|
%- full
|
2020-04-16 05:10:22 +03:00
|
|
|
%+ ifix [gay gay]
|
2020-04-19 02:53:45 +03:00
|
|
|
%+ cook |=(pile +<)
|
2020-04-16 15:56:06 +03:00
|
|
|
;~ pfix
|
|
|
|
:: parse optional /? and ignore
|
|
|
|
::
|
|
|
|
;~ pose
|
2020-11-15 08:08:52 +03:00
|
|
|
(cold ~ ;~(plug fas wut gap dem gap))
|
2020-04-16 15:56:06 +03:00
|
|
|
(easy ~)
|
|
|
|
==
|
2020-04-16 05:10:22 +03:00
|
|
|
::
|
2020-04-19 02:53:45 +03:00
|
|
|
;~ plug
|
|
|
|
;~ pose
|
|
|
|
;~ sfix
|
|
|
|
%+ cook |=((list (list taut)) (zing +<))
|
|
|
|
%+ more gap
|
2020-11-15 08:08:52 +03:00
|
|
|
;~ pfix ;~(plug fas hep gap)
|
2020-04-19 02:53:45 +03:00
|
|
|
(most ;~(plug com gaw) taut-rule)
|
|
|
|
==
|
|
|
|
gap
|
|
|
|
==
|
|
|
|
(easy ~)
|
|
|
|
==
|
|
|
|
::
|
|
|
|
;~ pose
|
|
|
|
;~ sfix
|
|
|
|
%+ cook |=((list (list taut)) (zing +<))
|
|
|
|
%+ more gap
|
2020-11-15 08:08:52 +03:00
|
|
|
;~ pfix ;~(plug fas lus gap)
|
2020-04-19 02:53:45 +03:00
|
|
|
(most ;~(plug com gaw) taut-rule)
|
|
|
|
==
|
|
|
|
gap
|
|
|
|
==
|
|
|
|
(easy ~)
|
|
|
|
==
|
|
|
|
::
|
|
|
|
;~ pose
|
|
|
|
;~ sfix
|
|
|
|
%+ cook |=((list [face=term =path]) +<)
|
|
|
|
%+ more gap
|
2020-11-15 08:08:52 +03:00
|
|
|
;~ pfix ;~(plug fas tis gap)
|
2020-04-19 02:53:45 +03:00
|
|
|
%+ cook |=([term path] +<)
|
2020-11-15 08:08:52 +03:00
|
|
|
;~(plug sym ;~(pfix ;~(plug gap fas) (more fas urs:ab)))
|
2020-04-19 02:53:45 +03:00
|
|
|
==
|
|
|
|
gap
|
|
|
|
==
|
|
|
|
(easy ~)
|
|
|
|
==
|
|
|
|
::
|
|
|
|
;~ pose
|
|
|
|
;~ sfix
|
|
|
|
%+ cook |=((list [face=term =mark =path]) +<)
|
|
|
|
%+ more gap
|
2020-11-15 08:08:52 +03:00
|
|
|
;~ pfix ;~(plug fas tar gap)
|
2020-04-19 02:53:45 +03:00
|
|
|
%+ cook |=([term mark path] +<)
|
|
|
|
;~ plug
|
|
|
|
sym
|
|
|
|
;~(pfix ;~(plug gap cen) sym)
|
2020-11-15 08:08:52 +03:00
|
|
|
;~(pfix ;~(plug gap fas) (more fas urs:ab))
|
2020-04-19 02:53:45 +03:00
|
|
|
==
|
|
|
|
==
|
|
|
|
gap
|
|
|
|
==
|
|
|
|
(easy ~)
|
|
|
|
==
|
|
|
|
::
|
|
|
|
%+ cook |=(huz=(list hoon) `hoon`tssg+huz)
|
2020-05-20 11:25:00 +03:00
|
|
|
(most gap tall:(vang & pax))
|
2020-04-19 02:53:45 +03:00
|
|
|
==
|
|
|
|
==
|
2020-04-16 05:10:22 +03:00
|
|
|
::
|
|
|
|
++ taut-rule
|
|
|
|
%+ cook |=(taut +<)
|
|
|
|
;~ pose
|
|
|
|
(stag ~ ;~(pfix tar sym))
|
|
|
|
;~(plug (stag ~ sym) ;~(pfix tis sym))
|
|
|
|
(cook |=(a=term [`a a]) sym)
|
|
|
|
==
|
|
|
|
::
|
|
|
|
++ run-tauts
|
|
|
|
|= [sut=vase wer=?(%lib %sur) taz=(list taut)]
|
|
|
|
^- [vase state]
|
|
|
|
?~ taz [sut nub]
|
2020-04-20 09:41:20 +03:00
|
|
|
=^ pin=vase nub (build-fit wer pax.i.taz)
|
2020-04-16 05:10:22 +03:00
|
|
|
=? p.pin ?=(^ face.i.taz) [%face u.face.i.taz p.pin]
|
|
|
|
$(sut (slop pin sut), taz t.taz)
|
|
|
|
::
|
|
|
|
++ run-raw
|
|
|
|
|= [sut=vase raw=(list [face=term =path])]
|
|
|
|
^- [vase state]
|
|
|
|
?~ raw [sut nub]
|
2020-04-19 02:53:45 +03:00
|
|
|
=^ pin=vase nub (build-file (snoc path.i.raw %hoon))
|
2020-04-16 05:10:22 +03:00
|
|
|
=. p.pin [%face face.i.raw p.pin]
|
|
|
|
$(sut (slop pin sut), raw t.raw)
|
|
|
|
::
|
2020-04-19 02:53:45 +03:00
|
|
|
++ run-bar
|
|
|
|
|= [sut=vase bar=(list [face=term =mark =path])]
|
|
|
|
^- [vase state]
|
|
|
|
?~ bar [sut nub]
|
|
|
|
=^ =cage nub (cast-path [path mark]:i.bar)
|
|
|
|
=. p.q.cage [%face face.i.bar p.q.cage]
|
|
|
|
$(sut (slop q.cage sut), bar t.bar)
|
|
|
|
::
|
2020-04-20 09:41:20 +03:00
|
|
|
:: +build-fit: build file at path, maybe converting '-'s to '/'s in path
|
|
|
|
::
|
2020-04-16 05:10:22 +03:00
|
|
|
++ build-fit
|
2020-04-20 09:41:20 +03:00
|
|
|
|= [pre=@tas pax=@tas]
|
2020-04-16 05:10:22 +03:00
|
|
|
^- [vase state]
|
2020-04-28 03:39:18 +03:00
|
|
|
(build-file (fit-path pre pax))
|
|
|
|
::
|
|
|
|
:: +fit-path: find path, maybe converting '-'s to '/'s
|
|
|
|
::
|
|
|
|
:: Try '-' before '/', applied left-to-right through the path,
|
|
|
|
:: e.g. 'a-foo/bar' takes precedence over 'a/foo-bar'.
|
|
|
|
::
|
|
|
|
++ fit-path
|
|
|
|
|= [pre=@tas pax=@tas]
|
|
|
|
^- path
|
|
|
|
=/ paz (segments pax)
|
|
|
|
|- ^- path
|
|
|
|
?~ paz ~|(no-file+pre^pax !!)
|
|
|
|
=/ pux=path pre^(snoc i.paz %hoon)
|
|
|
|
?: (~(has in deletes) pux)
|
|
|
|
$(paz t.paz)
|
|
|
|
?: (~(has by changes) pux)
|
|
|
|
pux
|
|
|
|
?^ (~(get an ankh) pux)
|
|
|
|
pux
|
|
|
|
$(paz t.paz)
|
2020-04-16 05:10:22 +03:00
|
|
|
--
|
|
|
|
--
|
2016-11-24 07:25:07 +03:00
|
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
|
|
:: section 4cA, filesystem logic
|
|
|
|
::
|
|
|
|
:: This core contains the main logic of clay. Besides `++ze`, this directly
|
|
|
|
:: contains the logic for commiting new revisions (local urbits), managing
|
|
|
|
:: and notifying subscribers (reactivity), and pulling and validating content
|
|
|
|
:: (remote urbits).
|
|
|
|
::
|
|
|
|
:: The state includes:
|
|
|
|
::
|
2018-12-13 10:42:15 +03:00
|
|
|
:: -- local urbit `our`
|
2016-11-24 07:25:07 +03:00
|
|
|
:: -- current time `now`
|
|
|
|
:: -- current duct `hen`
|
2019-02-02 00:46:09 +03:00
|
|
|
:: -- scry handler `ski`
|
2018-12-13 10:42:15 +03:00
|
|
|
:: -- all vane state `++raft` (rarely used, except for the object store)
|
2016-11-24 07:25:07 +03:00
|
|
|
:: -- target urbit `her`
|
|
|
|
:: -- target desk `syd`
|
|
|
|
::
|
|
|
|
:: For local desks, `our` == `her` is one of the urbits on our pier. For
|
|
|
|
:: foreign desks, `her` is the urbit the desk is on and `our` is the local
|
|
|
|
:: urbit that's managing the relationship with the foreign urbit. Don't mix
|
|
|
|
:: up those two, or there will be wailing and gnashing of teeth.
|
|
|
|
::
|
2018-12-13 10:42:15 +03:00
|
|
|
:: While setting up `++de`, we check if `our` == `her`. If so, we get
|
|
|
|
:: the desk information from `dos.rom`. Otherwise, we get the rung from
|
|
|
|
:: `hoy` and get the desk information from `rus` in there. In either case,
|
|
|
|
:: we normalize the desk information to a `++rede`, which is all the
|
|
|
|
:: desk-specific data that we utilize in `++de`. Because it's effectively
|
|
|
|
:: a part of the `++de` state, let's look at what we've got:
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
:: -- `lim` is the most recent date we're confident we have all the
|
|
|
|
:: information for. For local desks, this is always `now`. For foreign
|
|
|
|
:: desks, this is the last time we got a full update from the foreign
|
|
|
|
:: urbit.
|
|
|
|
:: -- `ref` is a possible request manager. For local desks, this is null.
|
|
|
|
:: For foreign desks, this keeps track of all pending foreign requests
|
|
|
|
:: plus a cache of the responses to previous requests.
|
|
|
|
:: -- `qyx` is the set of subscriptions, with listening ducts. These
|
|
|
|
:: subscriptions exist only until they've been filled.
|
|
|
|
:: -- `dom` is the actual state of the filetree. Since this is used almost
|
|
|
|
:: exclusively in `++ze`, we describe it there.
|
|
|
|
::
|
|
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
|
|
++ de :: per desk
|
2019-02-02 00:46:09 +03:00
|
|
|
|= [our=ship now=@da ski=sley hen=duct raft]
|
2018-12-13 10:42:15 +03:00
|
|
|
|= [her=ship syd=desk]
|
|
|
|
:: XX ruf=raft crashes in the compiler
|
|
|
|
::
|
2019-02-02 00:46:09 +03:00
|
|
|
=* ruf |4.+6.^$
|
2018-12-13 10:42:15 +03:00
|
|
|
::
|
2019-12-18 03:48:08 +03:00
|
|
|
=/ [mow=(list move) hun=(unit duct) rede]
|
2018-12-13 10:42:15 +03:00
|
|
|
?. =(our her)
|
|
|
|
:: no duct, foreign +rede or default
|
|
|
|
::
|
2019-07-27 09:36:59 +03:00
|
|
|
:+ ?: (~(has by hoy.ruf) her)
|
|
|
|
~
|
2019-08-07 01:42:37 +03:00
|
|
|
[hun.rom.ruf %pass /sinks %j %public-keys (silt her ~)]~
|
2019-07-27 09:36:59 +03:00
|
|
|
~
|
2019-06-30 15:50:00 +03:00
|
|
|
=/ rus rus:(~(gut by hoy.ruf) her *rung)
|
|
|
|
%+ ~(gut by rus) syd
|
2019-05-04 05:24:24 +03:00
|
|
|
[lim=~2000.1.1 ref=`*rind qyx=~ dom=*dome per=~ pew=~]
|
2018-12-13 10:42:15 +03:00
|
|
|
:: administrative duct, domestic +rede
|
|
|
|
::
|
2019-07-27 09:36:59 +03:00
|
|
|
:+ ~ `hun.rom.ruf
|
2019-06-30 15:50:00 +03:00
|
|
|
=/ jod (~(gut by dos.rom.ruf) syd *dojo)
|
2019-05-04 05:24:24 +03:00
|
|
|
[lim=now ref=~ [qyx dom per pew]:jod]
|
2018-12-13 10:42:15 +03:00
|
|
|
::
|
2019-07-27 09:36:59 +03:00
|
|
|
=* red=rede ->+
|
2016-11-24 07:25:07 +03:00
|
|
|
|%
|
|
|
|
++ abet :: resolve
|
2018-12-13 10:42:15 +03:00
|
|
|
^- [(list move) raft]
|
|
|
|
:- (flop mow)
|
|
|
|
?. =(our her)
|
|
|
|
:: save foreign +rede
|
|
|
|
::
|
2019-06-30 15:50:00 +03:00
|
|
|
=/ run (~(gut by hoy.ruf) her *rung)
|
2019-02-02 00:46:09 +03:00
|
|
|
=/ rug (~(put by rus.run) syd red)
|
|
|
|
ruf(hoy (~(put by hoy.ruf) her run(rus rug)))
|
2018-12-13 10:42:15 +03:00
|
|
|
:: save domestic +room
|
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
%= ruf
|
|
|
|
hun.rom (need hun)
|
2019-05-04 05:24:24 +03:00
|
|
|
dos.rom (~(put by dos.rom.ruf) syd [qyx dom per pew]:red)
|
2019-05-03 04:50:20 +03:00
|
|
|
==
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Handle `%sing` requests
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ aver
|
|
|
|
|= {for/(unit ship) mun/mood}
|
2020-04-19 11:58:12 +03:00
|
|
|
^- [(unit (unit (each cage lobe))) ford-cache]
|
2019-05-03 04:50:20 +03:00
|
|
|
=+ ezy=?~(ref ~ (~(get by haw.u.ref) mun))
|
|
|
|
?^ ezy
|
2020-04-19 11:58:12 +03:00
|
|
|
:_(fod.dom.red `(bind u.ezy |=(a/cage [%& a])))
|
2020-07-21 22:03:30 +03:00
|
|
|
?: ?=([%s [%ud *] %late *] mun)
|
|
|
|
:_ fod.dom.red
|
|
|
|
^- (unit (unit (each cage lobe)))
|
|
|
|
:^ ~ ~ %&
|
|
|
|
^- cage
|
|
|
|
:- %cass
|
|
|
|
?~ let.dom
|
|
|
|
!>([0 *@da])
|
|
|
|
!>([let.dom t:(~(got by hut.ran) (~(got by hit.dom) let.dom))])
|
2019-05-23 00:39:12 +03:00
|
|
|
=+ nao=(case-to-aeon case.mun)
|
2020-04-19 11:58:12 +03:00
|
|
|
?~(nao [~ fod.dom.red] (read-at-aeon:ze for u.nao mun))
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Queue a move.
|
2018-02-12 18:02:32 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ emit
|
|
|
|
|= mof/move
|
|
|
|
%_(+> mow [mof mow])
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Queue a list of moves
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ emil
|
|
|
|
|= mof/(list move)
|
2019-05-14 09:18:52 +03:00
|
|
|
%_(+> mow (weld (flop mof) mow))
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Produce either null or a result along a subscription.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Producing null means subscription has been completed or cancelled.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ balk
|
|
|
|
|= {hen/duct cay/(unit (each cage lobe)) mun/mood}
|
2016-11-24 07:25:07 +03:00
|
|
|
^+ +>
|
2019-05-03 04:50:20 +03:00
|
|
|
?~ cay (blub hen)
|
|
|
|
(blab hen mun u.cay)
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Set timer.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ bait
|
|
|
|
|= {hen/duct tym/@da}
|
2019-05-23 03:01:02 +03:00
|
|
|
(emit hen %pass /tyme/(scot %p her)/[syd] %b %wait tym)
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Cancel timer.
|
2019-05-02 04:21:32 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ best
|
|
|
|
|= {hen/duct tym/@da}
|
2019-05-23 03:01:02 +03:00
|
|
|
(emit hen %pass /tyme/(scot %p her)/[syd] %b %rest tym)
|
2019-05-03 04:50:20 +03:00
|
|
|
::
|
|
|
|
:: Give subscription result.
|
|
|
|
::
|
|
|
|
:: Result can be either a direct result (cage) or a lobe of a result. In
|
|
|
|
:: the latter case we fetch the data at the lobe and produce that.
|
|
|
|
::
|
|
|
|
++ blab
|
2020-05-13 09:36:55 +03:00
|
|
|
|= [hen=duct mun=mood dat=(each cage lobe)]
|
2019-05-03 04:50:20 +03:00
|
|
|
^+ +>
|
2020-05-13 09:36:55 +03:00
|
|
|
=^ =cage fod.dom
|
|
|
|
?: ?=(%& -.dat)
|
|
|
|
[p.dat fod.dom]
|
2020-06-02 06:52:20 +03:00
|
|
|
=^ =page fod.dom
|
2020-05-13 09:36:55 +03:00
|
|
|
%- wrap:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
(lobe-to-page:(ford:fusion static-ford-args) p.dat)
|
|
|
|
=^ =cage fod.dom
|
2020-05-13 09:36:55 +03:00
|
|
|
%- wrap:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
(page-to-cage:(ford:fusion static-ford-args) page)
|
|
|
|
[cage fod.dom]
|
2020-05-21 11:10:39 +03:00
|
|
|
=/ gift [%writ ~ [care.mun case.mun syd] path.mun cage]
|
|
|
|
?: ?=(^ ref)
|
|
|
|
(emit hen %slip %b %drip !>(gift))
|
|
|
|
(emit hen %give gift)
|
2019-05-02 04:21:32 +03:00
|
|
|
::
|
2020-05-12 10:37:04 +03:00
|
|
|
++ case-to-date
|
|
|
|
|= =case
|
|
|
|
^- @da
|
|
|
|
:: if the case is already a date, use it.
|
|
|
|
::
|
|
|
|
?: ?=([%da *] case)
|
|
|
|
p.case
|
|
|
|
:: translate other cases to dates
|
|
|
|
::
|
|
|
|
=/ aey (case-to-aeon-before lim case)
|
|
|
|
?~ aey `@da`0
|
|
|
|
?: =(0 u.aey) `@da`0
|
|
|
|
t:(aeon-to-yaki:ze u.aey)
|
|
|
|
::
|
|
|
|
++ case-to-aeon (cury case-to-aeon-before lim)
|
|
|
|
::
|
|
|
|
:: Reduce a case to an aeon (version number)
|
|
|
|
::
|
|
|
|
:: We produce null if we can't yet reduce the case for whatever
|
|
|
|
:: resaon (usually either the time or aeon hasn't happened yet or
|
|
|
|
:: the label hasn't been created).
|
|
|
|
::
|
|
|
|
++ case-to-aeon-before
|
|
|
|
|= [lim=@da lok=case]
|
|
|
|
^- (unit aeon)
|
|
|
|
?- -.lok
|
|
|
|
$da
|
|
|
|
?: (gth p.lok lim) ~
|
|
|
|
|- ^- (unit aeon)
|
|
|
|
?: =(0 let.dom) [~ 0] :: avoid underflow
|
|
|
|
?: %+ gte p.lok
|
|
|
|
=< t
|
|
|
|
~| [%letdom let=let.dom hit=hit.dom hut=~(key by hut.ran)]
|
|
|
|
~| [%getdom (~(get by hit.dom) let.dom)]
|
|
|
|
%- aeon-to-yaki:ze
|
|
|
|
let.dom
|
|
|
|
[~ let.dom]
|
|
|
|
$(let.dom (dec let.dom))
|
|
|
|
::
|
|
|
|
$tas (~(get by lab.dom) p.lok)
|
|
|
|
$ud ?:((gth p.lok let.dom) ~ [~ p.lok])
|
|
|
|
==
|
2019-05-02 04:21:32 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ blas
|
|
|
|
|= {hen/duct das/(set mood)}
|
2019-05-02 04:21:32 +03:00
|
|
|
^+ +>
|
2019-05-03 04:50:20 +03:00
|
|
|
?> ?=(^ das)
|
|
|
|
:: translate the case to a date
|
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
=/ cas [%da (case-to-date case.n.das)]
|
2020-05-21 11:10:39 +03:00
|
|
|
=/ res
|
|
|
|
(~(run in `(set mood)`das) |=(m/mood [care.m path.m]))
|
|
|
|
=/ gift [%wris cas res]
|
|
|
|
?: ?=(^ ref)
|
|
|
|
(emit hen %slip %b %drip !>(gift))
|
|
|
|
(emit hen %give gift)
|
2019-05-02 04:21:32 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Give next step in a subscription.
|
2019-05-02 04:21:32 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ bleb
|
2020-07-23 07:57:44 +03:00
|
|
|
|= [hen=duct ver=@ud ins=@ud hip=(unit (pair aeon aeon))]
|
2019-05-02 04:21:32 +03:00
|
|
|
^+ +>
|
2019-05-03 04:50:20 +03:00
|
|
|
%^ blab hen [%w [%ud ins] ~]
|
|
|
|
:- %&
|
|
|
|
?~ hip
|
|
|
|
[%null [%atom %n ~] ~]
|
2020-07-23 07:57:44 +03:00
|
|
|
[%nako !>((make-nako:ze ver u.hip))]
|
2019-05-02 04:21:32 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Tell subscriber that subscription is done.
|
2019-05-02 04:21:32 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ blub
|
|
|
|
|= hen/duct
|
2020-05-21 11:10:39 +03:00
|
|
|
?: ?=(^ ref)
|
|
|
|
(emit hen %slip %b %drip !>([%writ ~]))
|
2020-05-08 06:58:03 +03:00
|
|
|
(emit hen %give %writ ~)
|
2019-05-02 04:21:32 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Lifts a function so that a single result can be fanned out over a set of
|
|
|
|
:: subscriber ducts.
|
2019-05-02 04:21:32 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Thus, `((duct-lift func) subs arg)` runs `(func sub arg)` for each `sub`
|
|
|
|
:: in `subs`.
|
2019-05-02 04:21:32 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ duct-lift
|
|
|
|
|* send/_|=({duct *} ..duct-lift)
|
|
|
|
|= {a/(set duct) arg/_+<+.send} ^+ ..duct-lift
|
|
|
|
=+ all=~(tap by a)
|
|
|
|
|- ^+ ..duct-lift
|
|
|
|
?~ all ..duct-lift
|
|
|
|
=. +>.send ..duct-lift
|
|
|
|
$(all t.all, duct-lift (send i.all arg))
|
2019-05-02 04:21:32 +03:00
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
++ blub-all (duct-lift |=([a=duct ~] (blub a)))
|
|
|
|
++ blab-all (duct-lift blab)
|
|
|
|
++ blas-all (duct-lift blas)
|
|
|
|
++ balk-all (duct-lift balk)
|
|
|
|
++ bleb-all (duct-lift bleb)
|
2019-05-03 04:50:20 +03:00
|
|
|
::
|
2020-06-02 06:52:20 +03:00
|
|
|
++ static-ford-args
|
|
|
|
[zuse:(need fer.dom) ank.dom ~ ~ lat.ran fod.dom]
|
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Transfer a request to another ship's clay.
|
|
|
|
::
|
|
|
|
++ send-over-ames
|
2019-06-29 02:43:52 +03:00
|
|
|
|= [=duct =ship index=@ud =riff]
|
|
|
|
^+ +>
|
|
|
|
::
|
|
|
|
=/ =desk p.riff
|
|
|
|
=/ =wire /warp-index/(scot %p ship)/(scot %tas desk)/(scot %ud index)
|
2019-07-29 09:37:49 +03:00
|
|
|
=/ =path [%question desk (scot %ud index) ~]
|
2020-07-23 07:57:44 +03:00
|
|
|
(emit duct %pass wire %a %plea ship %c path [[%1 ~] riff])
|
2019-05-03 04:50:20 +03:00
|
|
|
::
|
|
|
|
:: Create a request that cannot be filled immediately.
|
|
|
|
::
|
|
|
|
:: If it's a local request, we just put in in `qyx`, setting a timer if it's
|
|
|
|
:: waiting for a particular time. If it's a foreign request, we add it to
|
|
|
|
:: our request manager (ref, which is a ++rind) and make the request to the
|
|
|
|
:: foreign ship.
|
|
|
|
::
|
|
|
|
++ duce :: produce request
|
2019-05-13 23:53:46 +03:00
|
|
|
|= wov=wove
|
2019-05-03 04:50:20 +03:00
|
|
|
^+ +>
|
|
|
|
=. wov (dedupe wov)
|
|
|
|
=. qyx (~(put ju qyx) wov hen)
|
|
|
|
?~ ref
|
2019-05-23 00:39:12 +03:00
|
|
|
(run-if-future rove.wov |=(@da (bait hen +<)))
|
2019-05-14 08:20:46 +03:00
|
|
|
|- ^+ +>+.$
|
2019-05-23 00:39:12 +03:00
|
|
|
=/ =rave (rove-to-rave rove.wov)
|
|
|
|
=. rave
|
|
|
|
?. ?=([%sing %v *] rave) rave
|
|
|
|
[%many %| [%ud let.dom] case.mood.rave path.mood.rave]
|
2019-05-03 04:50:20 +03:00
|
|
|
=+ inx=nix.u.ref
|
2019-05-14 08:20:46 +03:00
|
|
|
=. +>+.$
|
2019-05-03 04:50:20 +03:00
|
|
|
=< ?>(?=(^ ref) .)
|
2019-06-29 02:43:52 +03:00
|
|
|
(send-over-ames hen her inx syd `rave)
|
2019-05-14 08:20:46 +03:00
|
|
|
%= +>+.$
|
2019-05-03 04:50:20 +03:00
|
|
|
nix.u.ref +(nix.u.ref)
|
2020-07-23 11:36:38 +03:00
|
|
|
bom.u.ref (~(put by bom.u.ref) inx [hen rave ~ ~ ~ |])
|
2019-05-03 04:50:20 +03:00
|
|
|
fod.u.ref (~(put by fod.u.ref) hen inx)
|
|
|
|
==
|
|
|
|
::
|
|
|
|
:: If a similar request exists, switch to the existing request.
|
|
|
|
::
|
|
|
|
:: "Similar" requests are those %next and %many requests which are the same
|
|
|
|
:: up to starting case, but we're already after the starting case. This
|
|
|
|
:: stacks later requests for something onto the same request so that they
|
|
|
|
:: all get filled at once.
|
|
|
|
::
|
|
|
|
++ dedupe :: find existing alias
|
|
|
|
|= wov/wove
|
|
|
|
^- wove
|
|
|
|
=; won/(unit wove) (fall won wov)
|
2019-05-23 00:39:12 +03:00
|
|
|
=* rov rove.wov
|
2019-05-03 04:50:20 +03:00
|
|
|
?- -.rov
|
|
|
|
$sing ~
|
|
|
|
$next
|
2019-05-23 00:39:12 +03:00
|
|
|
=+ aey=(case-to-aeon case.mood.rov)
|
2019-05-03 04:50:20 +03:00
|
|
|
?~ aey ~
|
|
|
|
%- ~(rep in ~(key by qyx))
|
|
|
|
|= {haw/wove res/(unit wove)}
|
|
|
|
?^ res res
|
2019-05-23 00:39:12 +03:00
|
|
|
?. =(for.wov for.haw) ~
|
|
|
|
=* hav rove.haw
|
2019-05-03 04:50:20 +03:00
|
|
|
=- ?:(- `haw ~)
|
|
|
|
?& ?=($next -.hav)
|
2019-05-23 00:39:12 +03:00
|
|
|
=(mood.hav mood.rov(case case.mood.hav))
|
2019-05-03 04:50:20 +03:00
|
|
|
::
|
|
|
|
:: only a match if this request is before
|
|
|
|
:: or at our starting case.
|
2019-05-23 00:39:12 +03:00
|
|
|
=+ hay=(case-to-aeon case.mood.hav)
|
2019-05-03 04:50:20 +03:00
|
|
|
?~(hay | (lte u.hay u.aey))
|
2019-05-02 04:21:32 +03:00
|
|
|
==
|
2019-05-03 04:50:20 +03:00
|
|
|
::
|
|
|
|
$mult
|
2019-05-23 00:39:12 +03:00
|
|
|
=+ aey=(case-to-aeon case.mool.rov)
|
2019-05-03 04:50:20 +03:00
|
|
|
?~ aey ~
|
|
|
|
%- ~(rep in ~(key by qyx))
|
|
|
|
|= {haw/wove res/(unit wove)}
|
|
|
|
?^ res res
|
2019-05-23 00:39:12 +03:00
|
|
|
?. =(for.wov for.haw) ~
|
|
|
|
=* hav rove.haw
|
2019-05-03 04:50:20 +03:00
|
|
|
=- ?:(- `haw ~)
|
|
|
|
?& ?=($mult -.hav)
|
2019-05-23 00:39:12 +03:00
|
|
|
=(mool.hav mool.rov(case case.mool.hav))
|
2019-05-03 04:50:20 +03:00
|
|
|
::
|
|
|
|
:: only a match if this request is before
|
|
|
|
:: or at our starting case, and it has been
|
|
|
|
:: tested at least that far.
|
2019-05-23 00:39:12 +03:00
|
|
|
=+ hay=(case-to-aeon case.mool.hav)
|
2019-05-03 04:50:20 +03:00
|
|
|
?& ?=(^ hay)
|
|
|
|
(lte u.hay u.aey)
|
2019-05-23 00:39:12 +03:00
|
|
|
?=(^ aeon.hav)
|
|
|
|
(gte u.aeon.hav u.aey)
|
2019-05-03 04:50:20 +03:00
|
|
|
==
|
2019-05-02 04:21:32 +03:00
|
|
|
==
|
2019-05-03 04:50:20 +03:00
|
|
|
::
|
|
|
|
$many
|
2019-05-23 00:39:12 +03:00
|
|
|
=+ aey=(case-to-aeon from.moat.rov)
|
2019-05-03 04:50:20 +03:00
|
|
|
?~ aey ~
|
|
|
|
%- ~(rep in ~(key by qyx))
|
|
|
|
|= {haw/wove res/(unit wove)}
|
|
|
|
?^ res res
|
2019-05-23 00:39:12 +03:00
|
|
|
?. =(for.wov for.haw) ~
|
|
|
|
=* hav rove.haw
|
2019-05-03 04:50:20 +03:00
|
|
|
=- ?:(- `haw ~)
|
|
|
|
?& ?=($many -.hav)
|
2019-05-23 00:39:12 +03:00
|
|
|
=(hav rov(from.moat from.moat.hav))
|
2019-05-03 04:50:20 +03:00
|
|
|
::
|
|
|
|
:: only a match if this request is before
|
|
|
|
:: or at our starting case.
|
2019-05-23 00:39:12 +03:00
|
|
|
=+ hay=(case-to-aeon from.moat.hav)
|
2019-05-03 04:50:20 +03:00
|
|
|
?~(hay | (lte u.hay u.aey))
|
|
|
|
==
|
|
|
|
==
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2020-04-24 03:12:23 +03:00
|
|
|
:: Porcelain commit
|
|
|
|
::
|
|
|
|
++ info
|
|
|
|
|= [deletes=(set path) changes=(map path cage)]
|
2020-04-28 12:56:28 +03:00
|
|
|
^+ ..park
|
2020-04-24 22:17:22 +03:00
|
|
|
?: =(0 let.dom)
|
|
|
|
?> ?=(~ deletes)
|
|
|
|
=/ data=(map path (each page lobe))
|
|
|
|
(~(run by changes) |=(=cage &+[p q.q]:cage))
|
2020-04-30 03:38:24 +03:00
|
|
|
(park | &+[~ data] *rang)
|
2020-04-24 22:17:22 +03:00
|
|
|
::
|
2020-04-24 03:12:23 +03:00
|
|
|
=/ parent-tako=tako (aeon-to-tako:ze let.dom)
|
|
|
|
=/ data=(map path (each page lobe))
|
|
|
|
=/ parent-yaki (tako-to-yaki:ze parent-tako)
|
|
|
|
=/ after-deletes
|
|
|
|
%- ~(dif by q.parent-yaki)
|
|
|
|
(malt (turn ~(tap in deletes) |=(=path [path *lobe])))
|
|
|
|
=/ after=(map path (each page lobe))
|
|
|
|
(~(run by after-deletes) |=(=lobe |+lobe))
|
|
|
|
%- ~(uni by after)
|
|
|
|
^- (map path (each page lobe))
|
|
|
|
(~(run by changes) |=(=cage &+[p q.q]:cage))
|
|
|
|
::
|
|
|
|
=/ =yuki [~[parent-tako] data]
|
2020-04-30 03:38:24 +03:00
|
|
|
(park | &+yuki *rang)
|
2020-04-24 03:12:23 +03:00
|
|
|
::
|
2020-04-28 12:56:28 +03:00
|
|
|
:: Unix commit
|
|
|
|
::
|
|
|
|
++ into
|
|
|
|
|= [pax=path all=? mod=(list [pax=path mim=(unit mime)])]
|
|
|
|
^+ ..park
|
|
|
|
:: filter out unchanged, cached %mime values
|
|
|
|
::
|
|
|
|
=. mod
|
|
|
|
%+ skip mod
|
|
|
|
|= [pax=path mim=(unit mime)]
|
|
|
|
?~ mim
|
|
|
|
|
|
|
|
|
?~ mum=(~(get by mim.dom) pax)
|
|
|
|
|
|
|
|
|
:: TODO: check mimetype
|
|
|
|
::
|
|
|
|
=(q.u.mim q.u.mum)
|
|
|
|
=/ =yaki
|
|
|
|
?: =(0 let.dom)
|
|
|
|
*yaki
|
|
|
|
(~(got by hut.ran) (~(got by hit.dom) let.dom))
|
|
|
|
(info (mode-to-commit q.yaki pax all mod))
|
|
|
|
::
|
2020-03-21 01:30:52 +03:00
|
|
|
:: Plumbing commit
|
|
|
|
::
|
|
|
|
:: Guaranteed to finish in one event.
|
|
|
|
::
|
|
|
|
:: XX needs to check that head is ancestor of tako
|
|
|
|
:: XX needs to check tako in rang
|
2020-04-23 06:07:41 +03:00
|
|
|
:: XX needs to check that commit doesn't have same date
|
2020-03-21 01:30:52 +03:00
|
|
|
::
|
|
|
|
++ park
|
2020-04-30 00:50:30 +03:00
|
|
|
=/ check-sane |
|
2020-03-21 01:30:52 +03:00
|
|
|
|^
|
2020-04-30 03:38:24 +03:00
|
|
|
|= [updated=? =yoki =rang]
|
2020-03-21 01:30:52 +03:00
|
|
|
^+ ..park
|
2020-04-23 06:07:41 +03:00
|
|
|
=: hut.ran (~(uni by hut.rang) hut.ran)
|
2020-03-21 01:30:52 +03:00
|
|
|
lat.ran (~(uni by lat.rang) lat.ran)
|
|
|
|
==
|
2020-04-30 03:38:24 +03:00
|
|
|
=/ new-data=(map path (each page lobe))
|
|
|
|
?- -.yoki
|
|
|
|
%& q.p.yoki
|
|
|
|
%| (~(run by q.p.yoki) |=(=lobe |+lobe))
|
|
|
|
==
|
2020-08-26 04:00:31 +03:00
|
|
|
=/ old-yaki
|
2020-05-08 13:03:29 +03:00
|
|
|
?: =(0 let.dom)
|
2020-08-26 04:00:31 +03:00
|
|
|
*yaki
|
|
|
|
(aeon-to-yaki:ze let.dom)
|
2020-04-17 06:18:02 +03:00
|
|
|
=/ [deletes=(set path) changes=(map path (each page lobe))]
|
2020-08-26 04:00:31 +03:00
|
|
|
(get-changes q.old-yaki new-data)
|
2020-04-23 06:07:41 +03:00
|
|
|
~| [from=let.dom deletes=deletes changes=~(key by changes)]
|
2020-04-17 06:18:02 +03:00
|
|
|
::
|
|
|
|
:: promote ford cache
|
|
|
|
:: promote and fill in ankh
|
|
|
|
:: promote and fill in mime cache
|
|
|
|
::
|
2020-05-08 13:03:29 +03:00
|
|
|
=/ sys-changes (need-sys-update changes)
|
2020-06-02 06:52:20 +03:00
|
|
|
?: ?& =(%home syd)
|
|
|
|
!updated
|
|
|
|
|(!=(~ sys-changes) !=(~ (need-vane-update changes)))
|
|
|
|
==
|
|
|
|
(sys-update yoki new-data changes)
|
2020-05-08 13:03:29 +03:00
|
|
|
:: clear caches if zuse reloaded
|
|
|
|
::
|
2020-06-02 06:52:20 +03:00
|
|
|
=/ is-zuse-new=? !=(~ sys-changes)
|
|
|
|
=. fod.dom
|
|
|
|
?: is-zuse-new
|
|
|
|
*ford-cache
|
|
|
|
(promote-ford fod.dom deletes ~(key by changes))
|
|
|
|
=. fer.dom `(build-reef fer.dom ~(key by changes) new-data)
|
2020-05-08 13:03:29 +03:00
|
|
|
=? ank.dom is-zuse-new *ankh
|
|
|
|
=? changes is-zuse-new
|
2020-08-26 04:00:31 +03:00
|
|
|
(changes-for-upgrade q.old-yaki deletes changes)
|
2020-06-02 06:52:20 +03:00
|
|
|
::
|
2020-04-17 06:18:02 +03:00
|
|
|
=/ =args:ford:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
[zuse:(need fer.dom) ank.dom deletes changes lat.ran fod.dom]
|
2020-04-17 06:18:02 +03:00
|
|
|
::
|
2020-04-23 06:07:41 +03:00
|
|
|
=^ change-cages ford-cache.args
|
2020-04-25 03:44:29 +03:00
|
|
|
(checkout-changes args changes)
|
2020-04-30 00:50:30 +03:00
|
|
|
=/ sane-continuation (sane-changes changes change-cages)
|
2020-04-23 06:07:41 +03:00
|
|
|
=/ new-blobs=(map lobe blob)
|
|
|
|
%- malt
|
|
|
|
%+ turn ~(tap by change-cages)
|
|
|
|
|= [=path =lobe =cage]
|
|
|
|
[lobe %direct lobe [p q.q]:cage]
|
|
|
|
=/ data=(map path lobe)
|
2020-04-30 03:38:24 +03:00
|
|
|
%- ~(urn by new-data)
|
2020-04-23 06:07:41 +03:00
|
|
|
|= [=path value=(each page lobe)]
|
|
|
|
?- -.value
|
|
|
|
%| p.value
|
|
|
|
%& lobe:(~(got by change-cages) path)
|
|
|
|
==
|
2020-08-26 02:24:36 +03:00
|
|
|
:: if we didn't change the data and it's not a merge commit, abort
|
|
|
|
::
|
2020-08-26 04:00:31 +03:00
|
|
|
:: very important to keep all permanent changes below this point
|
|
|
|
::
|
|
|
|
?: &(=([r.old-yaki ~] p.p.yoki) =(data q.old-yaki))
|
|
|
|
..park
|
2020-05-01 05:32:48 +03:00
|
|
|
=/ =yaki
|
|
|
|
?- -.yoki
|
|
|
|
%& (make-yaki p.p.yoki data now)
|
|
|
|
%| ?> =(data q.p.yoki)
|
|
|
|
p.yoki
|
|
|
|
==
|
2020-04-23 06:07:41 +03:00
|
|
|
=: let.dom +(let.dom)
|
|
|
|
hit.dom (~(put by hit.dom) +(let.dom) r.yaki)
|
|
|
|
hut.ran (~(put by hut.ran) r.yaki yaki)
|
|
|
|
lat.ran (~(uni by new-blobs) lat.ran)
|
|
|
|
==
|
|
|
|
=. file-store.args lat.ran
|
|
|
|
::
|
2020-04-18 04:04:51 +03:00
|
|
|
=^ ankh ford-cache.args
|
2020-04-23 06:07:41 +03:00
|
|
|
(checkout-ankh args deletes change-cages ank.dom)
|
2020-04-30 00:50:30 +03:00
|
|
|
=/ null (sane-ankh sane-continuation ankh)
|
2020-04-18 08:36:59 +03:00
|
|
|
=. ankh.args ankh
|
2020-04-17 06:18:02 +03:00
|
|
|
=. ank.dom ankh
|
2020-04-18 04:04:51 +03:00
|
|
|
=^ mim ford-cache.args
|
|
|
|
(checkout-mime args deletes ~(key by changes))
|
2020-04-17 06:18:02 +03:00
|
|
|
=. mim.dom (apply-changes-to-mim mim.dom mim)
|
|
|
|
=. fod.dom ford-cache.args
|
2020-08-26 04:00:31 +03:00
|
|
|
=. ..park (emil (print q.old-yaki data))
|
2020-04-17 00:05:19 +03:00
|
|
|
::
|
2020-04-17 06:18:02 +03:00
|
|
|
wake:(ergo mim)
|
2020-03-21 01:30:52 +03:00
|
|
|
::
|
2020-04-17 00:05:19 +03:00
|
|
|
:: Find which files changed or were deleted
|
|
|
|
::
|
|
|
|
++ get-changes
|
2020-04-23 06:07:41 +03:00
|
|
|
|= [old=(map path lobe) new=(map path (each page lobe))]
|
2020-05-08 13:03:29 +03:00
|
|
|
^- [deletes=(set path) changes=(map path (each page lobe))]
|
2020-04-23 06:07:41 +03:00
|
|
|
=/ old=(map path (each page lobe))
|
|
|
|
(~(run by old) |=(=lobe |+lobe))
|
2020-04-17 00:05:19 +03:00
|
|
|
:* %- silt ^- (list path)
|
2020-04-23 06:07:41 +03:00
|
|
|
%+ murn ~(tap by (~(uni by old) new))
|
|
|
|
|= [=path *]
|
2020-04-17 00:05:19 +03:00
|
|
|
^- (unit ^path)
|
2020-04-23 06:07:41 +03:00
|
|
|
=/ a (~(get by new) path)
|
|
|
|
=/ b (~(get by old) path)
|
2020-04-17 00:05:19 +03:00
|
|
|
?: |(=(a b) !=(~ a))
|
|
|
|
~
|
|
|
|
`path
|
|
|
|
::
|
2020-04-24 22:17:22 +03:00
|
|
|
%- malt ^- (list [path (each page lobe)])
|
2020-04-23 06:07:41 +03:00
|
|
|
%+ murn ~(tap by (~(uni by old) new))
|
|
|
|
|= [=path *]
|
|
|
|
^- (unit [^path (each page lobe)])
|
|
|
|
=/ a (~(get by new) path)
|
|
|
|
=/ b (~(get by old) path)
|
|
|
|
?: |(=(a b) ?=(~ a))
|
2020-04-17 00:05:19 +03:00
|
|
|
~
|
2020-04-23 06:07:41 +03:00
|
|
|
`[path u.a]
|
2020-04-17 00:05:19 +03:00
|
|
|
==
|
2020-05-08 13:03:29 +03:00
|
|
|
:: Find all files for full desk rebuild
|
|
|
|
::
|
|
|
|
++ changes-for-upgrade
|
|
|
|
|= $: old=(map path lobe)
|
|
|
|
deletes=(set path)
|
|
|
|
changes=(map path (each page lobe))
|
|
|
|
==
|
|
|
|
^+ changes
|
|
|
|
=. old
|
|
|
|
%+ roll ~(tap in deletes)
|
|
|
|
|= [pax=path old=_old]
|
|
|
|
(~(del by old) pax)
|
|
|
|
=/ pre=_changes (~(run by old) |=(lob=lobe |+lob))
|
|
|
|
(~(uni by pre) changes)
|
2020-04-17 00:05:19 +03:00
|
|
|
::
|
|
|
|
:: Keep any parts of the ford cache whose dependencies didn't change
|
|
|
|
::
|
2020-05-05 09:31:35 +03:00
|
|
|
:: Make sure to invalidate any paths whose '-'s or '/'s could be
|
|
|
|
:: converted in an import; i.e. /mar, /lib, and /sur hoon files.
|
|
|
|
::
|
2020-04-16 02:24:48 +03:00
|
|
|
++ promote-ford
|
2020-04-17 06:18:02 +03:00
|
|
|
|= [=ford-cache deletes=(set path) changes=(set path)]
|
2020-04-16 23:09:02 +03:00
|
|
|
^+ ford-cache
|
2020-04-17 06:18:02 +03:00
|
|
|
=/ invalid=(set path) (~(uni in deletes) changes)
|
2020-05-05 09:31:35 +03:00
|
|
|
=. invalid
|
|
|
|
%- ~(gas in invalid)
|
|
|
|
%- zing
|
|
|
|
%+ turn ~(tap in invalid)
|
|
|
|
|= pax=path
|
|
|
|
^- (list path)
|
|
|
|
=/ xap=path (flop pax)
|
|
|
|
?. &(=(%hoon (head xap)) ?=([?(%mar %sur %lib) @ @ *] pax))
|
|
|
|
~
|
|
|
|
=- (turn - |=(suf=path [i.pax (snoc suf %hoon)]))
|
|
|
|
%- segments
|
|
|
|
%- crip
|
|
|
|
=/ xup (tail xap) :: lose %hoon extension
|
|
|
|
=/ pux (tail (flop xup)) :: lose static prefix
|
|
|
|
%+ turn (tail (spud pux)) :: lose leading '/'
|
|
|
|
|=(c=@tD `@tD`?:(=('/' c) '-' c)) :: convert '/' to '-'
|
|
|
|
::
|
2020-04-16 23:09:02 +03:00
|
|
|
:* ((invalidate path vase) vases.ford-cache invalid)
|
|
|
|
((invalidate mark dais) marks.ford-cache invalid)
|
|
|
|
((invalidate mars tube) casts.ford-cache invalid)
|
|
|
|
==
|
2020-04-16 02:24:48 +03:00
|
|
|
::
|
|
|
|
++ invalidate
|
|
|
|
|* [key=mold value=mold]
|
|
|
|
|= [cache=(map key [value dez=(set path)]) invalid=(set path)]
|
|
|
|
=/ builds=(list [key value dez=(set path)]) ~(tap by cache)
|
|
|
|
|- ^+ cache
|
|
|
|
?~ builds
|
|
|
|
~
|
|
|
|
?: ?=(^ (~(int in dez.i.builds) invalid))
|
|
|
|
$(builds t.builds)
|
|
|
|
(~(put by $(builds t.builds)) i.builds)
|
|
|
|
::
|
2020-06-02 06:52:20 +03:00
|
|
|
++ build-reef
|
|
|
|
|= $: fer=(unit reef-cache)
|
|
|
|
invalid=(set path)
|
|
|
|
data=(map path (each page lobe))
|
|
|
|
==
|
2020-06-01 19:56:21 +03:00
|
|
|
^- reef-cache
|
2020-06-02 06:52:20 +03:00
|
|
|
?: =(%home syd)
|
|
|
|
[!>(..ride) !>(..is) !>(..zuse)]
|
|
|
|
|^
|
|
|
|
?: |(?=(~ fer) (~(has in invalid) /sys/hoon/hoon))
|
|
|
|
=/ [home=? hoon=vase]
|
|
|
|
?: (same-as-home /sys/hoon/hoon)
|
|
|
|
&+!>(..ride)
|
|
|
|
|+build-hoon
|
|
|
|
:- hoon
|
|
|
|
=/ [home=? arvo=vase]
|
|
|
|
?: &(home (same-as-home /sys/arvo/hoon))
|
|
|
|
&+!>(..is)
|
|
|
|
|+(build-arvo hoon)
|
|
|
|
:- arvo
|
|
|
|
?: &(home (same-as-home /sys/zuse/hoon))
|
|
|
|
!>(..zuse)
|
|
|
|
(build-zuse arvo)
|
|
|
|
:- hoon.u.fer
|
|
|
|
?: (~(has in invalid) /sys/arvo/hoon)
|
|
|
|
=/ [home=? arvo=vase]
|
|
|
|
?: &((same-as-home /sys/hoon/hoon) (same-as-home /sys/arvo/hoon))
|
|
|
|
&+!>(..is)
|
|
|
|
|+(build-arvo hoon.u.fer)
|
|
|
|
:- arvo
|
|
|
|
?: &(home (same-as-home /sys/zuse/hoon))
|
|
|
|
!>(..zuse)
|
|
|
|
(build-zuse arvo)
|
|
|
|
:- arvo.u.fer
|
|
|
|
?: (~(has in invalid) /sys/zuse/hoon)
|
|
|
|
?: ?& (same-as-home /sys/hoon/hoon)
|
|
|
|
(same-as-home /sys/arvo/hoon)
|
|
|
|
(same-as-home /sys/zuse/hoon)
|
|
|
|
==
|
|
|
|
!>(..zuse)
|
|
|
|
(build-zuse arvo.u.fer)
|
|
|
|
zuse.u.fer
|
|
|
|
::
|
|
|
|
++ build-hoon
|
2020-06-19 07:44:17 +03:00
|
|
|
%- road |.
|
2020-06-02 06:52:20 +03:00
|
|
|
~> %slog.0^leaf+"clay: building hoon on {<syd>}"
|
|
|
|
=/ gen
|
|
|
|
~> %mean.%hoon-parse-fail
|
|
|
|
(path-to-hoon data /sys/hoon/hoon)
|
|
|
|
~> %mean.%hoon-compile-fail
|
|
|
|
(slot 7 (slap !>(0) gen))
|
|
|
|
::
|
|
|
|
++ build-arvo
|
|
|
|
|= hoon=vase
|
2020-06-19 07:44:17 +03:00
|
|
|
%- road |.
|
2020-06-02 06:52:20 +03:00
|
|
|
~> %slog.0^leaf+"clay: building arvo on {<syd>}"
|
|
|
|
=/ gen
|
|
|
|
~> %mean.%arvo-parse-fail
|
|
|
|
(path-to-hoon data /sys/arvo/hoon)
|
|
|
|
~> %mean.%arvo-compile-fail
|
2020-11-03 02:27:10 +03:00
|
|
|
(slap (slap hoon gen) !,(*^hoon ..is))
|
2020-06-02 06:52:20 +03:00
|
|
|
::
|
|
|
|
++ build-zuse
|
|
|
|
|= arvo=vase
|
2020-06-19 07:44:17 +03:00
|
|
|
%- road |.
|
2020-06-02 06:52:20 +03:00
|
|
|
~> %slog.0^leaf+"clay: building zuse on {<syd>}"
|
|
|
|
=/ gen
|
|
|
|
~> %mean.%zuse-parse-fail
|
|
|
|
(path-to-hoon data /sys/zuse/hoon)
|
|
|
|
~> %mean.%zuse-compile-fail
|
|
|
|
(slap arvo gen)
|
|
|
|
::
|
|
|
|
++ same-as-home
|
|
|
|
|= =path
|
|
|
|
^- ?
|
2020-06-13 07:40:32 +03:00
|
|
|
=/ our-lobe=lobe
|
2020-06-02 06:52:20 +03:00
|
|
|
=/ datum (~(got by data) path)
|
|
|
|
?- -.datum
|
|
|
|
%& (page-to-lobe %hoon (page-to-cord p.datum))
|
|
|
|
%| p.datum
|
|
|
|
==
|
|
|
|
=/ =dome dom:(~(got by dos.rom) %home)
|
|
|
|
=/ =yaki (~(got by hut.ran) (~(got by hit.dome) let.dome))
|
2020-06-13 07:40:32 +03:00
|
|
|
=(`our-lobe (~(get by q.yaki) path))
|
2020-06-02 06:52:20 +03:00
|
|
|
--
|
|
|
|
::
|
|
|
|
++ page-to-cord
|
|
|
|
|= =page
|
|
|
|
^- @t
|
|
|
|
?+ p.page ~|([%sys-bad-mark p.page] !!)
|
|
|
|
%hoon ;;(@t q.page)
|
|
|
|
%mime q.q:;;(mime q.page)
|
|
|
|
==
|
|
|
|
::
|
|
|
|
++ path-to-hoon
|
|
|
|
|= [data=(map path (each page lobe)) =path]
|
|
|
|
(rain path (path-to-cord data path))
|
|
|
|
::
|
|
|
|
++ path-to-cord
|
|
|
|
|= [data=(map path (each page lobe)) =path]
|
|
|
|
^- @t
|
|
|
|
=/ datum (~(got by data) path)
|
|
|
|
?- -.datum
|
|
|
|
%& (page-to-cord p.datum)
|
2020-06-13 07:40:32 +03:00
|
|
|
%| (lobe-to-cord p.datum)
|
2020-06-02 06:52:20 +03:00
|
|
|
==
|
|
|
|
::
|
|
|
|
++ lobe-to-cord
|
2020-06-13 07:40:32 +03:00
|
|
|
|= =lobe
|
2020-06-02 06:52:20 +03:00
|
|
|
^- @t
|
|
|
|
=- ?:(?=(%& -<) p.- (of-wain:format p.-))
|
|
|
|
|- ^- (each @t wain)
|
|
|
|
=/ =blob (~(got by lat.ran) lobe)
|
|
|
|
?- -.blob
|
|
|
|
%direct [%& ;;(@t q.q.blob)]
|
|
|
|
%delta
|
|
|
|
:- %|
|
|
|
|
%+ lurk:differ
|
|
|
|
=- ?:(?=(%| -<) p.- (to-wain:format p.-))
|
|
|
|
$(lobe q.q.blob)
|
2020-06-13 07:40:32 +03:00
|
|
|
;;((urge cord) q.r.blob)
|
2020-06-02 06:52:20 +03:00
|
|
|
==
|
2020-06-01 19:56:21 +03:00
|
|
|
::
|
2020-04-23 06:07:41 +03:00
|
|
|
:: Updated q.yaki
|
|
|
|
::
|
|
|
|
++ checkout-changes
|
|
|
|
|= [=ford=args:ford:fusion changes=(map path (each page lobe))]
|
|
|
|
=/ cans=(list [=path change=(each page lobe)]) ~(tap by changes)
|
|
|
|
|- ^- [(map path [=lobe =cage]) ford-cache]
|
|
|
|
?~ cans
|
|
|
|
[~ ford-cache.ford-args]
|
|
|
|
=^ cage ford-cache.ford-args
|
2020-05-14 05:28:04 +03:00
|
|
|
:: ~> %slog.[0 leaf+"clay: validating {(spud path.i.cans)}"]
|
2020-04-23 06:07:41 +03:00
|
|
|
%- wrap:fusion
|
|
|
|
(get-value:(ford:fusion ford-args) path.i.cans)
|
|
|
|
=/ =lobe
|
|
|
|
?- -.change.i.cans
|
|
|
|
%| p.change.i.cans
|
2020-04-29 08:34:48 +03:00
|
|
|
:: Don't use p.change.i.cans because that's before casting to
|
|
|
|
:: the correct mark.
|
|
|
|
::
|
2020-05-12 10:37:04 +03:00
|
|
|
%& (page-to-lobe [p q.q]:cage)
|
2020-04-23 06:07:41 +03:00
|
|
|
==
|
|
|
|
=^ so-far ford-cache.ford-args $(cans t.cans)
|
|
|
|
[(~(put by so-far) path.i.cans lobe cage) ford-cache.ford-args]
|
|
|
|
::
|
2020-04-17 06:18:02 +03:00
|
|
|
:: Update ankh
|
|
|
|
::
|
|
|
|
++ checkout-ankh
|
|
|
|
|= $: =ford=args:ford:fusion
|
|
|
|
deletes=(set path)
|
2020-04-23 06:07:41 +03:00
|
|
|
changes=(map path [lobe cage])
|
2020-04-17 06:18:02 +03:00
|
|
|
=ankh
|
|
|
|
==
|
|
|
|
^+ [ankh ford-cache.ford-args]
|
|
|
|
:: Delete
|
|
|
|
::
|
|
|
|
=. ankh
|
|
|
|
=/ dels ~(tap in deletes)
|
|
|
|
|- ^- ^ankh
|
|
|
|
=* outer-loop $
|
|
|
|
?~ dels
|
|
|
|
ankh
|
|
|
|
=. ankh
|
|
|
|
|- ^- ^ankh
|
|
|
|
=* inner-loop $
|
|
|
|
?~ i.dels
|
|
|
|
ankh(fil ~)
|
|
|
|
%= ankh
|
|
|
|
dir
|
|
|
|
%+ ~(put by dir.ankh) i.i.dels
|
|
|
|
%= inner-loop
|
|
|
|
i.dels t.i.dels
|
|
|
|
ankh (~(gut by dir.ankh) i.i.dels *^ankh)
|
|
|
|
==
|
|
|
|
==
|
|
|
|
outer-loop(dels t.dels)
|
|
|
|
:: Add/change
|
|
|
|
::
|
2020-04-23 06:07:41 +03:00
|
|
|
=/ cans=(list [=path =lobe =cage]) ~(tap by changes)
|
2020-04-17 06:18:02 +03:00
|
|
|
|- ^+ [ankh ford-cache.ford-args]
|
|
|
|
=* outer-loop $
|
|
|
|
?~ cans
|
|
|
|
[ankh ford-cache.ford-args]
|
2020-04-18 04:04:51 +03:00
|
|
|
=^ new-ankh ford-cache.ford-args
|
2020-04-17 06:18:02 +03:00
|
|
|
|- ^+ [ankh ford-cache.ford-args]
|
|
|
|
=* inner-loop $
|
2020-04-18 04:04:51 +03:00
|
|
|
?^ path.i.cans
|
|
|
|
=^ child-ankh ford-cache.ford-args
|
|
|
|
%= inner-loop
|
|
|
|
path.i.cans t.path.i.cans
|
|
|
|
ankh (~(gut by dir.ankh) i.path.i.cans *^ankh)
|
2020-04-17 06:18:02 +03:00
|
|
|
==
|
2020-04-29 06:33:12 +03:00
|
|
|
:- ankh(dir (~(put by dir.ankh) i.path.i.cans child-ankh))
|
2020-04-18 04:04:51 +03:00
|
|
|
ford-cache.ford-args
|
2020-04-23 06:07:41 +03:00
|
|
|
[ankh(fil `[lobe.i.cans cage.i.cans]) ford-cache.ford-args]
|
2020-04-18 04:04:51 +03:00
|
|
|
=. ankh new-ankh
|
2020-04-17 06:18:02 +03:00
|
|
|
outer-loop(cans t.cans)
|
|
|
|
::
|
2020-04-17 00:05:19 +03:00
|
|
|
:: Print notification to console
|
|
|
|
::
|
2020-03-25 03:24:19 +03:00
|
|
|
++ print
|
2020-08-26 04:00:31 +03:00
|
|
|
|= [old=(map path lobe) new=(map path lobe)]
|
2020-04-17 00:05:19 +03:00
|
|
|
^- (list move)
|
2020-08-26 04:00:31 +03:00
|
|
|
=/ [deletes=(set path) upserts=(map path (each page lobe))]
|
|
|
|
(get-changes old (~(run by new) |=(=lobe |+lobe)))
|
|
|
|
=/ upsert-set ~(key by upserts)
|
|
|
|
=/ old-set ~(key by old)
|
|
|
|
=/ changes=(set path) (~(int in upsert-set) old-set)
|
|
|
|
=/ additions=(set path) (~(dif in upsert-set) old-set)
|
2020-03-25 03:24:19 +03:00
|
|
|
?~ hun
|
2020-04-17 00:05:19 +03:00
|
|
|
~
|
2020-04-29 04:13:30 +03:00
|
|
|
?: =(0 let.dom)
|
|
|
|
~
|
2020-06-09 00:24:23 +03:00
|
|
|
|^
|
|
|
|
;: weld
|
|
|
|
(paths-to-notes '-' deletes)
|
|
|
|
(paths-to-notes ':' changes)
|
|
|
|
(paths-to-notes '+' additions)
|
|
|
|
==
|
|
|
|
::
|
|
|
|
++ paths-to-notes
|
|
|
|
|= [prefix=@tD paths=(set path)]
|
|
|
|
%+ turn ~(tap in paths)
|
2020-04-17 00:05:19 +03:00
|
|
|
|= =path
|
2020-06-09 00:24:23 +03:00
|
|
|
[u.hun %give %note prefix (path-to-tank path)]
|
2020-04-17 00:05:19 +03:00
|
|
|
::
|
|
|
|
++ path-to-tank
|
|
|
|
|= =path
|
2020-04-29 04:13:30 +03:00
|
|
|
=/ pre=^path ~[(scot %p our) syd (scot %ud +(let.dom))]
|
2020-03-25 03:24:19 +03:00
|
|
|
:+ %rose ["/" "/" ~]
|
|
|
|
%+ turn (weld pre path)
|
|
|
|
|= a=cord
|
|
|
|
^- tank
|
|
|
|
?: ((sane %ta) a)
|
|
|
|
[%leaf (trip a)]
|
|
|
|
[%leaf (dash:us (trip a) '\'' ~)]
|
2020-04-17 00:05:19 +03:00
|
|
|
--
|
2020-04-25 03:44:29 +03:00
|
|
|
::
|
|
|
|
:: Check sanity
|
|
|
|
::
|
|
|
|
++ sane-changes
|
|
|
|
|= $: changes=(map path (each page lobe))
|
|
|
|
change-cages=(map path [lobe cage])
|
|
|
|
==
|
2020-04-29 08:34:48 +03:00
|
|
|
^- (unit [(map path [lobe cage]) args:ford:fusion])
|
2020-04-30 00:50:30 +03:00
|
|
|
?. check-sane
|
|
|
|
~
|
2020-04-29 08:34:48 +03:00
|
|
|
=/ tak=(unit tako) (~(get by hit.dom) let.dom)
|
|
|
|
?~ tak
|
|
|
|
~
|
|
|
|
=/ =yaki (~(got by hut.ran) u.tak)
|
|
|
|
:: Assert all blobs hash to their lobe
|
|
|
|
::
|
|
|
|
=/ foo
|
|
|
|
%- ~(urn by lat.ran)
|
|
|
|
|= [=lobe =blob]
|
|
|
|
?: ?=(%delta -.blob)
|
|
|
|
~
|
|
|
|
=/ actual-lobe=^lobe `@uv`(page-to-lobe q.blob)
|
|
|
|
~| [lobe p.blob actual-lobe]
|
|
|
|
?> &(=(lobe p.blob) =(lobe actual-lobe))
|
|
|
|
~
|
|
|
|
:: Assert we calculated the same change-cages w/o cache
|
|
|
|
::
|
|
|
|
:: XX remove deletes
|
2020-04-25 03:44:29 +03:00
|
|
|
::
|
|
|
|
=/ all-changes=(map path (each page lobe))
|
|
|
|
=/ original=(map path (each page lobe))
|
|
|
|
(~(run by q.yaki) |=(=lobe |+lobe))
|
|
|
|
(~(uni by original) changes)
|
|
|
|
=/ =args:ford:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
[zuse:(need fer.dom) *ankh ~ all-changes lat.ran *ford-cache]
|
2020-04-25 03:44:29 +03:00
|
|
|
=^ all-change-cages ford-cache.args
|
|
|
|
(checkout-changes args all-changes)
|
|
|
|
=/ ccs=(list [=path =lobe =cage]) ~(tap by change-cages)
|
|
|
|
|- ^+ *sane-changes
|
|
|
|
?^ ccs
|
2020-04-29 08:34:48 +03:00
|
|
|
?. =(`[lobe cage]:i.ccs (~(get by all-change-cages) path.i.ccs))
|
|
|
|
~| not-same-cages+path.i.ccs
|
2020-04-25 03:44:29 +03:00
|
|
|
!!
|
|
|
|
$(ccs t.ccs)
|
2020-04-29 08:34:48 +03:00
|
|
|
`[all-change-cages args]
|
2020-04-25 03:44:29 +03:00
|
|
|
::
|
|
|
|
++ sane-ankh
|
2020-04-29 08:34:48 +03:00
|
|
|
|= $: $= cont
|
|
|
|
(unit [all-changes=(map path [lobe cage]) =ford=args:ford:fusion])
|
2020-04-25 03:44:29 +03:00
|
|
|
=test=ankh
|
|
|
|
==
|
2020-04-30 00:50:30 +03:00
|
|
|
?. check-sane
|
|
|
|
~
|
|
|
|
:: Assert all new lobes are reachable.
|
|
|
|
::
|
|
|
|
:: Needs to run after dome is updated
|
|
|
|
::
|
|
|
|
=/ tak=(unit tako) (~(get by hit.dom) let.dom)
|
|
|
|
?~ tak
|
|
|
|
~
|
|
|
|
=/ =yaki (~(got by hut.ran) u.tak)
|
|
|
|
=/ files=(list [=path =lobe]) ~(tap by q.yaki)
|
|
|
|
|- ^+ *sane-ankh
|
|
|
|
?^ files
|
|
|
|
?. (~(has by lat.ran) lobe.i.files)
|
|
|
|
~| missing-lobe=[path lobe]
|
|
|
|
!!
|
|
|
|
$(files t.files)
|
|
|
|
::
|
|
|
|
:: Assert we can rebuild the ankh
|
|
|
|
::
|
2020-04-29 08:34:48 +03:00
|
|
|
?~ cont
|
|
|
|
~
|
|
|
|
=+ u.cont
|
2020-04-25 03:44:29 +03:00
|
|
|
=^ ankh ford-cache.ford-args
|
2020-04-29 08:34:48 +03:00
|
|
|
(checkout-ankh ford-args ~ all-changes *ankh)
|
|
|
|
=| =path
|
|
|
|
|- ^- ~
|
|
|
|
=* loop $
|
|
|
|
=/ fil (bind fil.ankh |=([=lobe =cage] [lobe p.cage q.q.cage]))
|
|
|
|
=/ test (bind fil.ankh |=([=lobe =cage] [lobe p.cage q.q.cage]))
|
|
|
|
?. =(fil test)
|
|
|
|
~| [%not-same-file path ?=(~ fil.ankh) ?=(~ fil.test-ankh)]
|
|
|
|
~| ?~(fil.ankh ~ [[p p.q]:u.fil.ankh `@uv`(page-to-lobe [p q.q]:q.u.fil.ankh)])
|
|
|
|
~| ?~(fil.test-ankh ~ [[p p.q]:u.fil.test-ankh `@uv`(page-to-lobe [p q.q]:q.u.fil.test-ankh)])
|
2020-04-25 03:44:29 +03:00
|
|
|
!!
|
2020-04-29 08:34:48 +03:00
|
|
|
?. =(~(key by dir.ankh) ~(key by dir.test-ankh))
|
|
|
|
~| [%not-same-children path ~(key by dir.ankh) ~(key by dir.test-ankh)]
|
|
|
|
!!
|
|
|
|
=< ~
|
|
|
|
%+ turn ~(tap by dir.ankh)
|
|
|
|
|= [=@ta =child=^ankh]
|
|
|
|
~| sane-ankh=[path ta]
|
|
|
|
%= loop
|
|
|
|
path (snoc path ta)
|
|
|
|
ankh child-ankh
|
|
|
|
test-ankh (~(got by dir.test-ankh) ta)
|
|
|
|
==
|
2020-04-25 03:44:29 +03:00
|
|
|
::
|
2020-05-09 15:09:26 +03:00
|
|
|
:: Find /sys changes; does not reload on first commit
|
2020-04-25 03:44:29 +03:00
|
|
|
::
|
|
|
|
++ need-sys-update
|
|
|
|
|= changes=(map path (each page lobe))
|
|
|
|
^- (map path (each page lobe))
|
|
|
|
~+
|
2020-05-09 15:09:26 +03:00
|
|
|
?: =(0 let.dom)
|
|
|
|
~
|
2020-04-25 03:44:29 +03:00
|
|
|
%- malt
|
|
|
|
%+ skim ~(tap by changes)
|
|
|
|
|= [=path *]
|
|
|
|
?| =(/sys/hoon/hoon path)
|
|
|
|
=(/sys/arvo/hoon path)
|
|
|
|
=(/sys/zuse/hoon path)
|
|
|
|
==
|
|
|
|
::
|
2020-06-02 06:52:20 +03:00
|
|
|
++ need-vane-update
|
2020-05-08 13:03:29 +03:00
|
|
|
|= changes=(map path (each page lobe))
|
2020-06-02 06:52:20 +03:00
|
|
|
^- (map path (each page lobe))
|
2020-05-08 13:03:29 +03:00
|
|
|
~+
|
2020-06-02 06:52:20 +03:00
|
|
|
?: =(0 let.dom)
|
|
|
|
~
|
|
|
|
%- malt
|
|
|
|
%+ skim ~(tap by changes)
|
|
|
|
|= [=path *]
|
|
|
|
=(/sys/vane (scag 2 path))
|
2020-05-08 13:03:29 +03:00
|
|
|
::
|
2020-04-25 03:44:29 +03:00
|
|
|
:: Delay current update until sys update is complete
|
|
|
|
::
|
|
|
|
++ sys-update
|
2020-06-02 06:52:20 +03:00
|
|
|
|= $: =yoki
|
|
|
|
data=(map path (each page lobe))
|
|
|
|
changes=(map path (each page lobe))
|
|
|
|
==
|
2020-04-25 03:44:29 +03:00
|
|
|
^+ ..park
|
2020-06-02 06:52:20 +03:00
|
|
|
=/ updates
|
|
|
|
%- ~(uni by (need-sys-update changes))
|
|
|
|
(need-vane-update changes)
|
2020-04-25 03:44:29 +03:00
|
|
|
?> =(~ pud)
|
2020-04-30 03:38:24 +03:00
|
|
|
=. pud `[syd yoki]
|
2020-05-13 04:26:11 +03:00
|
|
|
|^ %. [hen %slip %c %pork ~]
|
|
|
|
=< emit
|
|
|
|
?: (~(has by updates) /sys/hoon/hoon)
|
2020-05-09 15:09:26 +03:00
|
|
|
(reset &)
|
2020-04-25 03:44:29 +03:00
|
|
|
?: (~(has by updates) /sys/arvo/hoon)
|
2020-05-09 15:09:26 +03:00
|
|
|
(reset |)
|
2020-04-25 03:44:29 +03:00
|
|
|
?: (~(has by updates) /sys/zuse/hoon)
|
|
|
|
reboot
|
2020-05-13 04:26:11 +03:00
|
|
|
=/ vanes=(list [=path *]) ~(tap by updates)
|
|
|
|
|- ^+ ..park
|
|
|
|
?~ vanes
|
|
|
|
..park
|
|
|
|
?. ?=([%sys %vane * %hoon ~] path.i.vanes)
|
|
|
|
~& [%strange-sys-update path.i.vanes]
|
|
|
|
$(vanes t.vanes)
|
|
|
|
=. ..park (reload i.t.t.path.i.vanes)
|
|
|
|
$(vanes t.vanes)
|
2020-04-25 03:44:29 +03:00
|
|
|
::
|
|
|
|
++ reset
|
2020-05-09 15:09:26 +03:00
|
|
|
|= new-hoon=?
|
|
|
|
^+ ..park
|
|
|
|
?. new-hoon
|
2020-06-02 06:52:20 +03:00
|
|
|
=/ arvo=@t (path-to-cord data /sys/arvo/hoon)
|
2020-05-09 15:09:26 +03:00
|
|
|
=. ..park (pass-lyra hoon=~ arvo)
|
|
|
|
reboot
|
2020-06-02 06:52:20 +03:00
|
|
|
=/ hoon=@t (path-to-cord data /sys/hoon/hoon)
|
|
|
|
=/ arvo=@t (path-to-cord data /sys/arvo/hoon)
|
2020-05-09 15:09:26 +03:00
|
|
|
=. ..park (pass-lyra `hoon arvo)
|
2020-04-25 03:44:29 +03:00
|
|
|
reboot
|
|
|
|
::
|
2020-05-09 15:09:26 +03:00
|
|
|
++ pass-lyra
|
|
|
|
|= [hoon=(unit @t) arvo=@t]
|
|
|
|
^+ ..park
|
|
|
|
(emit hen %pass /reset %d %flog %lyra hoon arvo)
|
|
|
|
::
|
2020-04-25 03:44:29 +03:00
|
|
|
++ reboot
|
2020-06-02 06:52:20 +03:00
|
|
|
=/ zuse=@t (path-to-cord data /sys/zuse/hoon)
|
2020-04-25 03:44:29 +03:00
|
|
|
=. ..park
|
|
|
|
%- emit
|
2020-06-02 06:52:20 +03:00
|
|
|
[hen %pass /reboot %d %flog %veer %$ /sys/zuse/hoon zuse]
|
2020-04-25 03:44:29 +03:00
|
|
|
reload-all
|
|
|
|
::
|
|
|
|
++ reload-all
|
|
|
|
=/ vanes=(list term)
|
2020-05-14 09:26:52 +03:00
|
|
|
~[%ames %behn %clay %dill %eyre %gall %iris %jael]
|
2020-04-25 03:44:29 +03:00
|
|
|
|- ^+ ..park
|
|
|
|
?~ vanes
|
2020-05-13 04:26:11 +03:00
|
|
|
..park
|
2020-04-25 03:44:29 +03:00
|
|
|
=. ..park (reload i.vanes)
|
|
|
|
$(vanes t.vanes)
|
|
|
|
::
|
|
|
|
++ reload
|
|
|
|
|= =term
|
2020-06-02 06:52:20 +03:00
|
|
|
=/ vane=@t (path-to-cord data /sys/vane/[term]/hoon)
|
2020-04-25 03:44:29 +03:00
|
|
|
%- emit
|
|
|
|
=/ tip (end 3 1 term)
|
|
|
|
=/ =path /sys/vane/[term]/hoon
|
2020-06-02 06:52:20 +03:00
|
|
|
[hen %pass /reload %d %flog %veer tip path vane]
|
2020-04-25 03:44:29 +03:00
|
|
|
--
|
2020-03-21 01:30:52 +03:00
|
|
|
--
|
|
|
|
::
|
2020-05-12 10:01:46 +03:00
|
|
|
:: We always say we're merging from 'ali' to 'bob'. The basic steps,
|
|
|
|
:: not all of which are always needed, are:
|
|
|
|
::
|
|
|
|
:: -- fetch ali's desk, async in case it's remote
|
|
|
|
:: -- diff ali's desk against the mergebase
|
|
|
|
:: -- diff bob's desk against the mergebase
|
|
|
|
:: -- merge the diffs
|
|
|
|
:: -- commit
|
|
|
|
::
|
|
|
|
++ start-merge
|
|
|
|
|= [=ali=ship =ali=desk =case =germ]
|
|
|
|
^+ ..start-merge
|
|
|
|
=/ =wire /merge/[syd]/(scot %p ali-ship)/[ali-desk]/[germ]
|
|
|
|
(emit hen %pass wire %c %warp ali-ship ali-desk `[%sing %v case /])
|
|
|
|
::
|
|
|
|
++ merge
|
|
|
|
|= [=ali=ship =ali=desk =germ =riot]
|
|
|
|
^+ ..merge
|
|
|
|
|^
|
|
|
|
?~ riot
|
|
|
|
(done %| %ali-unavailable >[ali-ship ali-desk germ]< ~)
|
|
|
|
=/ ali-dome=dome:clay !<(dome:clay q.r.u.riot)
|
|
|
|
=/ ali-yaki=yaki (~(got by hut.ran) (~(got by hit.ali-dome) let.ali-dome))
|
|
|
|
=/ bob-yaki=(unit yaki)
|
|
|
|
?~ let.dom
|
|
|
|
~
|
|
|
|
(~(get by hut.ran) (~(got by hit.dom) let.dom))
|
|
|
|
=/ merge-result (merge-by-germ ali-yaki bob-yaki)
|
|
|
|
?: ?=(%| -.merge-result)
|
|
|
|
(done %| p.merge-result)
|
|
|
|
?~ p.merge-result
|
|
|
|
(done %& ~)
|
|
|
|
=. ..merge (done %& conflicts.u.p.merge-result)
|
|
|
|
(park | new.u.p.merge-result ~ lat.u.p.merge-result)
|
|
|
|
::
|
|
|
|
++ done
|
|
|
|
|= result=(each (set path) (pair term tang))
|
|
|
|
^+ ..merge
|
|
|
|
(emit hen %give %mere result)
|
|
|
|
::
|
|
|
|
+$ merge-result [conflicts=(set path) new=yoki lat=(map lobe blob)]
|
|
|
|
++ merge-by-germ
|
|
|
|
|= [=ali=yaki bob-yaki=(unit yaki)]
|
|
|
|
^- (each (unit merge-result) [term tang])
|
|
|
|
::
|
|
|
|
:: If this is an %init merge, we set the ali's commit to be
|
|
|
|
:: bob's.
|
|
|
|
::
|
|
|
|
?: ?=(%init germ)
|
2020-07-23 07:57:44 +03:00
|
|
|
?> ?=(~ bob-yaki)
|
2020-05-12 10:01:46 +03:00
|
|
|
&+`[conflicts=~ new=|+ali-yaki lat=~]
|
|
|
|
::
|
|
|
|
=/ bob-yaki (need bob-yaki)
|
|
|
|
|^
|
|
|
|
^- (each (unit merge-result) [term tang])
|
|
|
|
?- germ
|
|
|
|
::
|
2020-08-28 10:24:25 +03:00
|
|
|
:: If this is a %only-this merge, we check to see if ali's and bob's
|
2020-05-12 10:01:46 +03:00
|
|
|
:: commits are the same, in which case we're done. Otherwise, we
|
|
|
|
:: check to see if ali's commit is in the ancestry of bob's, in
|
|
|
|
:: which case we're done. Otherwise, we create a new commit with
|
|
|
|
:: bob's data plus ali and bob as parents.
|
|
|
|
::
|
2020-08-28 10:24:25 +03:00
|
|
|
%only-this
|
2020-05-12 10:01:46 +03:00
|
|
|
?: =(r.ali-yaki r.bob-yaki)
|
|
|
|
&+~
|
2020-05-12 10:37:04 +03:00
|
|
|
?: (~(has in (reachable-takos:ze r.bob-yaki)) r.ali-yaki)
|
2020-05-12 10:01:46 +03:00
|
|
|
&+~
|
|
|
|
:* %& ~
|
|
|
|
conflicts=~
|
|
|
|
new=&+[[r.bob-yaki r.ali-yaki ~] (to-yuki q.bob-yaki)]
|
|
|
|
lat=~
|
|
|
|
==
|
|
|
|
::
|
2020-08-28 10:24:25 +03:00
|
|
|
:: If this is a %only-that merge, we check to see if ali's and bob's
|
2020-05-12 10:01:46 +03:00
|
|
|
:: commits are the same, in which case we're done. Otherwise, we
|
|
|
|
:: create a new commit with ali's data plus ali and bob as
|
|
|
|
:: parents.
|
|
|
|
::
|
2020-08-28 10:24:25 +03:00
|
|
|
%only-that
|
2020-05-12 10:01:46 +03:00
|
|
|
?: =(r.ali-yaki r.bob-yaki)
|
|
|
|
&+~
|
|
|
|
:* %& ~
|
|
|
|
conflicts=~
|
|
|
|
new=&+[[r.bob-yaki r.ali-yaki ~] (to-yuki q.ali-yaki)]
|
|
|
|
lat=~
|
|
|
|
==
|
|
|
|
::
|
2020-08-28 10:24:25 +03:00
|
|
|
:: Create a merge commit with exactly the contents of the
|
|
|
|
:: destination desk except take any files from the source commit
|
|
|
|
:: which are not in the destination desk.
|
|
|
|
::
|
|
|
|
%take-this
|
|
|
|
?: =(r.ali-yaki r.bob-yaki)
|
|
|
|
&+~
|
|
|
|
?: (~(has in (reachable-takos:ze r.bob-yaki)) r.ali-yaki)
|
|
|
|
&+~
|
|
|
|
=/ new-data (~(uni by q.ali-yaki) q.bob-yaki)
|
|
|
|
:* %& ~
|
|
|
|
conflicts=~
|
|
|
|
new=&+[[r.bob-yaki r.ali-yaki ~] (to-yuki new-data)]
|
|
|
|
lat=~
|
|
|
|
==
|
|
|
|
::
|
|
|
|
:: Create a merge commit with exactly the contents of the source
|
|
|
|
:: commit except preserve any files from the destination desk
|
|
|
|
:: which are not in the source commit.
|
|
|
|
::
|
|
|
|
%take-that
|
|
|
|
?: =(r.ali-yaki r.bob-yaki)
|
|
|
|
&+~
|
|
|
|
=/ new-data (~(uni by q.bob-yaki) q.ali-yaki)
|
|
|
|
:* %& ~
|
|
|
|
conflicts=~
|
|
|
|
new=&+[[r.bob-yaki r.ali-yaki ~] (to-yuki new-data)]
|
|
|
|
lat=~
|
|
|
|
==
|
|
|
|
::
|
2020-05-12 10:01:46 +03:00
|
|
|
:: If this is a %fine merge, we check to see if ali's and bob's
|
|
|
|
:: commits are the same, in which case we're done. Otherwise, we
|
|
|
|
:: check to see if ali's commit is in the ancestry of bob's, in
|
|
|
|
:: which case we're done. Otherwise, we check to see if bob's
|
|
|
|
:: commit is in the ancestry of ali's. If not, this is not a
|
|
|
|
:: fast-forward merge, so we error out. If it is, we add ali's
|
|
|
|
:: commit to bob's desk and checkout.
|
|
|
|
::
|
|
|
|
%fine
|
|
|
|
?: =(r.ali-yaki r.bob-yaki)
|
|
|
|
&+~
|
2020-05-12 10:37:04 +03:00
|
|
|
?: (~(has in (reachable-takos:ze r.bob-yaki)) r.ali-yaki)
|
2020-05-12 10:01:46 +03:00
|
|
|
&+~
|
2020-05-12 10:37:04 +03:00
|
|
|
?. (~(has in (reachable-takos:ze r.ali-yaki)) r.bob-yaki)
|
2020-05-12 10:01:46 +03:00
|
|
|
:~ %| %bad-fine-merge
|
|
|
|
leaf+"tried fast-forward but is not ancestor or descendant"
|
|
|
|
==
|
|
|
|
&+`[conflicts=~ new=|+ali-yaki lat=~]
|
|
|
|
::
|
2020-08-28 10:24:25 +03:00
|
|
|
?(%meet %mate %meld %meet-this %meet-that)
|
2020-05-12 10:01:46 +03:00
|
|
|
?: =(r.ali-yaki r.bob-yaki)
|
|
|
|
&+~
|
2020-05-12 10:37:04 +03:00
|
|
|
?: (~(has in (reachable-takos:ze r.bob-yaki)) r.ali-yaki)
|
2020-05-12 10:01:46 +03:00
|
|
|
&+~
|
2020-05-12 10:37:04 +03:00
|
|
|
?: (~(has in (reachable-takos:ze r.ali-yaki)) r.bob-yaki)
|
2020-05-12 10:01:46 +03:00
|
|
|
$(germ %fine)
|
2020-08-26 06:25:39 +03:00
|
|
|
=/ merge-points (find-merge-points ali-yaki bob-yaki)
|
2020-05-12 10:01:46 +03:00
|
|
|
?~ merge-points
|
|
|
|
:~ %| %merge-no-merge-base
|
|
|
|
leaf+"consider a %this or %that merge to get a mergebase"
|
|
|
|
==
|
|
|
|
=/ merge-point=yaki n.merge-points
|
2020-08-28 10:24:25 +03:00
|
|
|
?: ?=(?(%mate %meld) germ)
|
2020-05-12 10:01:46 +03:00
|
|
|
=/ ali-diffs=cane (diff-base ali-yaki bob-yaki merge-point)
|
|
|
|
=/ bob-diffs=cane (diff-base bob-yaki ali-yaki merge-point)
|
|
|
|
=/ bof=(map path (unit cage))
|
|
|
|
(merge-conflicts can.ali-diffs can.bob-diffs)
|
2020-05-14 03:47:19 +03:00
|
|
|
(build ali-yaki bob-yaki merge-point ali-diffs bob-diffs bof)
|
2020-05-12 10:01:46 +03:00
|
|
|
=/ ali-diffs=cane (calc-diffs ali-yaki merge-point)
|
|
|
|
=/ bob-diffs=cane (calc-diffs bob-yaki merge-point)
|
|
|
|
=/ both-diffs=(map path *)
|
|
|
|
%- %~ int by
|
|
|
|
%- ~(uni by `(map path *)`new.ali-diffs)
|
|
|
|
%- ~(uni by `(map path *)`cal.ali-diffs)
|
|
|
|
%- ~(uni by `(map path *)`can.ali-diffs)
|
|
|
|
`(map path *)`old.ali-diffs
|
|
|
|
%- ~(uni by `(map path *)`new.bob-diffs)
|
|
|
|
%- ~(uni by `(map path *)`cal.bob-diffs)
|
|
|
|
%- ~(uni by `(map path *)`can.bob-diffs)
|
|
|
|
`(map path *)`old.bob-diffs
|
2020-08-28 10:24:25 +03:00
|
|
|
?: &(?=(%meet germ) !=(~ both-diffs))
|
2020-05-12 10:01:46 +03:00
|
|
|
:~ %| %meet-conflict
|
|
|
|
>~(key by both-diffs)<
|
|
|
|
leaf+"consider a %mate merge"
|
|
|
|
==
|
2020-08-28 10:24:25 +03:00
|
|
|
=/ both-done=(map path lobe)
|
|
|
|
|^
|
|
|
|
?- germ
|
|
|
|
%meet ~
|
|
|
|
%meet-this (resolve (~(uni by new.bob-diffs) cal.bob-diffs))
|
|
|
|
%meet-that (resolve (~(uni by new.ali-diffs) cal.ali-diffs))
|
|
|
|
==
|
|
|
|
++ resolve
|
|
|
|
|= news=(map path lobe)
|
|
|
|
%- malt ^- (list [path lobe])
|
|
|
|
%+ murn ~(tap by both-diffs)
|
|
|
|
|= [=path *]
|
|
|
|
^- (unit [^path lobe])
|
|
|
|
=/ new (~(get by news) path)
|
|
|
|
?~ new
|
|
|
|
~
|
|
|
|
`[path u.new]
|
|
|
|
--
|
|
|
|
::
|
|
|
|
=/ deleted
|
|
|
|
%- ~(dif by (~(uni by old.ali-diffs) old.bob-diffs))
|
|
|
|
(~(run by both-done) |=(* ~))
|
2020-05-12 10:01:46 +03:00
|
|
|
=/ not-deleted=(map path lobe)
|
2020-08-28 10:24:25 +03:00
|
|
|
%+ roll ~(tap by deleted)
|
2020-05-12 10:01:46 +03:00
|
|
|
=< .(not-deleted q.merge-point)
|
|
|
|
|= [[pax=path ~] not-deleted=(map path lobe)]
|
|
|
|
(~(del by not-deleted) pax)
|
|
|
|
=/ hat=(map path lobe)
|
|
|
|
%- ~(uni by not-deleted)
|
|
|
|
%- ~(uni by new.ali-diffs)
|
|
|
|
%- ~(uni by new.bob-diffs)
|
|
|
|
%- ~(uni by cal.ali-diffs)
|
|
|
|
cal.bob-diffs
|
|
|
|
:* %& ~
|
|
|
|
conflicts=~
|
|
|
|
new=&+[[r.bob-yaki r.ali-yaki ~] (to-yuki hat)]
|
|
|
|
lat=~
|
|
|
|
==
|
|
|
|
==
|
|
|
|
::
|
|
|
|
++ to-yuki
|
|
|
|
|= m=(map path lobe)
|
|
|
|
^- (map path (each page lobe))
|
|
|
|
(~(run by m) |=(=lobe |+lobe))
|
|
|
|
::
|
|
|
|
:: The set of changes between the mergebase and one of the desks
|
|
|
|
:: being merged
|
|
|
|
::
|
|
|
|
:: -- `new` is the set of files in the new desk and not in the
|
|
|
|
:: mergebase.
|
|
|
|
:: -- `cal` is the set of changes in the new desk from the
|
|
|
|
:: mergebase except for any that are also in the other new desk.
|
|
|
|
:: -- `can` is the set of changes in the new desk from the
|
|
|
|
:: mergebase that are also in the other new desk (potential
|
|
|
|
:: conflicts).
|
|
|
|
:: -- `old` is the set of files in the mergebase and not in the
|
|
|
|
:: new desk.
|
|
|
|
::
|
|
|
|
+$ cane
|
|
|
|
$: new=(map path lobe)
|
|
|
|
cal=(map path lobe)
|
|
|
|
can=(map path cage)
|
|
|
|
old=(map path ~)
|
|
|
|
==
|
|
|
|
::
|
|
|
|
:: Calculate cane knowing there are no files changed by both
|
|
|
|
:: desks
|
|
|
|
::
|
|
|
|
++ calc-diffs
|
|
|
|
|= [hed=yaki bas=yaki]
|
|
|
|
^- cane
|
|
|
|
:* %- molt
|
|
|
|
%+ skip ~(tap by q.hed)
|
|
|
|
|= [pax=path lob=lobe]
|
|
|
|
(~(has by q.bas) pax)
|
|
|
|
::
|
|
|
|
%- molt
|
|
|
|
%+ skip ~(tap by q.hed)
|
|
|
|
|= [pax=path lob=lobe]
|
|
|
|
=+ (~(get by q.bas) pax)
|
|
|
|
|(=(~ -) =([~ lob] -))
|
|
|
|
::
|
|
|
|
~
|
|
|
|
::
|
|
|
|
%- malt ^- (list [path ~])
|
|
|
|
%+ murn ~(tap by q.bas)
|
|
|
|
|= [pax=path lob=lobe]
|
|
|
|
^- (unit (pair path ~))
|
|
|
|
?. =(~ (~(get by q.hed) pax))
|
|
|
|
~
|
|
|
|
`[pax ~]
|
|
|
|
==
|
|
|
|
::
|
|
|
|
:: Diff yak against bas where different from yuk
|
|
|
|
::
|
|
|
|
++ diff-base
|
|
|
|
|= [yak=yaki yuk=yaki bas=yaki]
|
|
|
|
^- cane
|
|
|
|
=/ new=(map path lobe)
|
|
|
|
%- malt
|
|
|
|
%+ skip ~(tap by q.yak)
|
|
|
|
|= [=path =lobe]
|
|
|
|
(~(has by q.bas) path)
|
|
|
|
::
|
|
|
|
=/ cal=(map path lobe)
|
|
|
|
%- malt ^- (list [path lobe])
|
|
|
|
%+ murn ~(tap by q.bas)
|
|
|
|
|= [pax=path lob=lobe]
|
|
|
|
^- (unit (pair path lobe))
|
|
|
|
=+ a=(~(get by q.yak) pax)
|
|
|
|
=+ b=(~(get by q.yuk) pax)
|
|
|
|
?. ?& ?=(^ a)
|
|
|
|
!=([~ lob] a)
|
|
|
|
=([~ lob] b)
|
|
|
|
==
|
|
|
|
~
|
|
|
|
`[pax +.a]
|
|
|
|
::
|
|
|
|
=/ can=(map path cage)
|
|
|
|
%- malt
|
|
|
|
%+ murn ~(tap by q.bas)
|
|
|
|
|= [=path =lobe]
|
|
|
|
^- (unit [^path cage])
|
|
|
|
=/ in-yak (~(get by q.yak) path)
|
|
|
|
?~ in-yak
|
|
|
|
~
|
|
|
|
?: =(lobe u.in-yak)
|
|
|
|
~
|
|
|
|
=/ in-yuk (~(get by q.yuk) path)
|
|
|
|
?~ in-yuk
|
|
|
|
~
|
|
|
|
?: =(lobe u.in-yuk)
|
|
|
|
~
|
|
|
|
?: =(u.in-yak u.in-yuk)
|
|
|
|
~
|
|
|
|
`[path (diff-lobes lobe u.in-yak)]
|
|
|
|
::
|
|
|
|
=/ old=(map path ~)
|
|
|
|
%- malt ^- (list [path ~])
|
|
|
|
%+ murn ~(tap by q.bas)
|
|
|
|
|= [pax=path lob=lobe]
|
|
|
|
?. =(~ (~(get by q.yak) pax))
|
|
|
|
~
|
|
|
|
(some pax ~)
|
|
|
|
::
|
|
|
|
[new cal can old]
|
|
|
|
::
|
|
|
|
:: These can/should save their caches
|
|
|
|
::
|
|
|
|
++ lobe-to-cage
|
|
|
|
|= =lobe
|
|
|
|
^- cage
|
|
|
|
=^ =page fod.dom
|
|
|
|
%- wrap:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
(lobe-to-page:(ford:fusion static-ford-args) lobe)
|
2020-05-12 10:01:46 +03:00
|
|
|
=^ =cage fod.dom
|
|
|
|
%- wrap:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
(page-to-cage:(ford:fusion static-ford-args) page)
|
2020-05-12 10:01:46 +03:00
|
|
|
cage
|
|
|
|
::
|
|
|
|
++ get-dais
|
|
|
|
|= =mark
|
|
|
|
^- dais
|
|
|
|
=^ =dais fod.dom
|
|
|
|
%- wrap:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
(get-mark:(ford:fusion static-ford-args) mark)
|
2020-05-12 10:01:46 +03:00
|
|
|
dais
|
|
|
|
::
|
|
|
|
:: Diff two files on bob-desk
|
|
|
|
::
|
|
|
|
++ diff-lobes
|
|
|
|
|= [=a=lobe =b=lobe]
|
|
|
|
^- cage
|
|
|
|
=/ a-cage (lobe-to-cage a-lobe)
|
|
|
|
=/ b-cage (lobe-to-cage b-lobe)
|
|
|
|
?> =(p.a-cage p.b-cage)
|
|
|
|
=/ =dais (get-dais p.a-cage)
|
|
|
|
[form:dais (~(diff dais q.a-cage) q.b-cage)]
|
|
|
|
::
|
|
|
|
:: Merge diffs that are on the same file.
|
|
|
|
::
|
|
|
|
++ merge-conflicts
|
|
|
|
|= [ali-conflicts=(map path cage) bob-conflicts=(map path cage)]
|
|
|
|
^- (map path (unit cage))
|
|
|
|
%- ~(urn by (~(int by ali-conflicts) bob-conflicts))
|
|
|
|
|= [=path *]
|
|
|
|
^- (unit cage)
|
|
|
|
=/ cal=cage (~(got by ali-conflicts) path)
|
|
|
|
=/ cob=cage (~(got by bob-conflicts) path)
|
|
|
|
=/ =mark
|
|
|
|
=+ (slag (dec (lent path)) path)
|
|
|
|
?~(- %$ i.-)
|
|
|
|
=/ =dais (get-dais mark)
|
|
|
|
=/ res=(unit (unit vase)) (~(join dais bunt:dais) q.cal q.cob)
|
|
|
|
?~ res
|
2020-05-21 11:11:16 +03:00
|
|
|
`[form:dais q.cob]
|
2020-05-12 10:01:46 +03:00
|
|
|
?~ u.res
|
|
|
|
~
|
|
|
|
`[form:dais u.u.res]
|
|
|
|
::
|
|
|
|
:: Apply the patches in bof to get the new merged content.
|
|
|
|
::
|
|
|
|
:: Gather all the changes between ali's and bob's commits and the
|
|
|
|
:: mergebase. This is similar to the %meet of ++merge, except
|
|
|
|
:: where they touch the same file, we use the merged versions.
|
|
|
|
::
|
|
|
|
++ build
|
|
|
|
|= $: ali=yaki
|
|
|
|
bob=yaki
|
|
|
|
bas=yaki
|
|
|
|
dal=cane
|
|
|
|
dob=cane
|
|
|
|
bof=(map path (unit cage))
|
|
|
|
==
|
2020-05-14 03:47:19 +03:00
|
|
|
^- (each (unit merge-result) [term tang])
|
2020-05-12 10:01:46 +03:00
|
|
|
=/ both-patched=(map path cage)
|
|
|
|
%- malt
|
|
|
|
%+ murn ~(tap by bof)
|
|
|
|
|= [=path cay=(unit cage)]
|
|
|
|
^- (unit [^path cage])
|
|
|
|
?~ cay
|
|
|
|
~
|
|
|
|
:+ ~ path
|
|
|
|
=+ (~(get by q.bas) path)
|
|
|
|
?~ -
|
|
|
|
~| %mate-strange-diff-no-base
|
|
|
|
!!
|
|
|
|
=/ =cage (lobe-to-cage u.-)
|
|
|
|
=/ =dais (get-dais p.cage)
|
|
|
|
?> =(p.u.cay form.dais)
|
|
|
|
:- p.cage
|
|
|
|
(~(pact dais q.cage) q.u.cay)
|
|
|
|
=/ con=(map path *) :: 2-change conflict
|
|
|
|
%- molt
|
|
|
|
%+ skim ~(tap by bof)
|
|
|
|
|=([pax=path cay=(unit cage)] ?=(~ cay))
|
|
|
|
=/ cab=(map path lobe) :: conflict base
|
|
|
|
%- ~(urn by con)
|
|
|
|
|= [pax=path *]
|
|
|
|
(~(got by q.bas) pax)
|
|
|
|
=. con :: change+del conflict
|
|
|
|
%- ~(uni by con)
|
|
|
|
%- malt ^- (list [path *])
|
|
|
|
%+ skim ~(tap by old.dal)
|
|
|
|
|= [pax=path ~]
|
|
|
|
?: (~(has by new.dob) pax)
|
|
|
|
~| %strange-add-and-del
|
|
|
|
!!
|
|
|
|
(~(has by can.dob) pax)
|
|
|
|
=. con :: change+del conflict
|
|
|
|
%- ~(uni by con)
|
|
|
|
%- malt ^- (list [path *])
|
|
|
|
%+ skim ~(tap by old.dob)
|
|
|
|
|= [pax=path ~]
|
|
|
|
?: (~(has by new.dal) pax)
|
|
|
|
~| %strange-del-and-add
|
|
|
|
!!
|
|
|
|
(~(has by can.dal) pax)
|
|
|
|
=. con :: add+add conflict
|
|
|
|
%- ~(uni by con)
|
|
|
|
%- malt ^- (list [path *])
|
|
|
|
%+ skip ~(tap by (~(int by new.dal) new.dob))
|
|
|
|
|= [pax=path *]
|
|
|
|
=((~(got by new.dal) pax) (~(got by new.dob) pax))
|
2020-05-14 03:47:19 +03:00
|
|
|
?: &(?=(%mate germ) ?=(^ con))
|
2020-07-01 01:24:42 +03:00
|
|
|
=+ (turn ~(tap by `(map path *)`con) |=([path *] >[+<-]<))
|
|
|
|
[%| %mate-conflict -]
|
2020-05-12 10:01:46 +03:00
|
|
|
=/ old=(map path lobe) :: oldies but goodies
|
|
|
|
%+ roll ~(tap by (~(uni by old.dal) old.dob))
|
2020-09-04 00:34:30 +03:00
|
|
|
=< .(old q.bob)
|
2020-05-12 10:01:46 +03:00
|
|
|
|= [[pax=path ~] old=(map path lobe)]
|
|
|
|
(~(del by old) pax)
|
|
|
|
=/ [hot=(map path lobe) lat=(map lobe blob)] :: new content
|
|
|
|
%+ roll ~(tap by both-patched)
|
|
|
|
|= [[pax=path cay=cage] hat=(map path lobe) lat=(map lobe blob)]
|
|
|
|
=/ =blob [%direct (page-to-lobe [p q.q]:cay) [p q.q]:cay]
|
|
|
|
:- (~(put by hat) pax p.blob)
|
|
|
|
?: (~(has by lat) p.blob)
|
|
|
|
lat
|
|
|
|
(~(put by lat) p.blob blob)
|
|
|
|
=/ hat=(map path lobe) :: all the content
|
|
|
|
%- ~(uni by old)
|
|
|
|
%- ~(uni by new.dal)
|
|
|
|
%- ~(uni by new.dob)
|
|
|
|
%- ~(uni by cal.dal)
|
|
|
|
%- ~(uni by cal.dob)
|
|
|
|
%- ~(uni by hot)
|
|
|
|
cab
|
|
|
|
=/ del=(map path ?)
|
|
|
|
(~(run by (~(uni by old.dal) old.dob)) |=(~ %|))
|
|
|
|
=/ new &+[[r.bob r.ali ~] (~(run by hat) |=(=lobe |+lobe))]
|
2020-05-14 03:47:19 +03:00
|
|
|
:* %& ~
|
|
|
|
(silt (turn ~(tap by con) head))
|
2020-05-12 10:01:46 +03:00
|
|
|
new
|
|
|
|
lat
|
|
|
|
==
|
|
|
|
--
|
|
|
|
--
|
|
|
|
::
|
2020-08-26 06:25:39 +03:00
|
|
|
:: Find the most recent common ancestor(s).
|
|
|
|
::
|
2020-08-27 03:11:26 +03:00
|
|
|
:: For performance, this depends on +reachable-takos being
|
|
|
|
:: memoized.
|
|
|
|
::
|
2020-08-26 06:25:39 +03:00
|
|
|
++ find-merge-points
|
|
|
|
|= [=ali=yaki =bob=yaki]
|
|
|
|
^- (set yaki)
|
2020-08-26 08:49:27 +03:00
|
|
|
:: Loop through ancestors breadth-first, lazily generating ancestry
|
|
|
|
::
|
|
|
|
=/ ali-takos (reachable-takos:ze r.ali-yaki)
|
2020-08-27 03:11:26 +03:00
|
|
|
:: Tako worklist
|
|
|
|
::
|
2020-10-16 21:02:56 +03:00
|
|
|
=/ takos=(qeu tako) [r.bob-yaki ~ ~]
|
2020-08-27 03:11:26 +03:00
|
|
|
:: Mergebase candidates. Have proven they're common ancestors, but
|
|
|
|
:: not that they're a most recent
|
|
|
|
::
|
|
|
|
=| bases=(set tako)
|
|
|
|
:: Takos we've already checked or are in our worklist
|
|
|
|
::
|
|
|
|
=| done=(set tako)
|
2020-08-26 06:25:39 +03:00
|
|
|
|- ^- (set yaki)
|
2020-08-26 08:49:27 +03:00
|
|
|
=* outer-loop $
|
2020-08-27 03:11:26 +03:00
|
|
|
:: If we've finished our worklist, convert to yakis and return
|
|
|
|
::
|
2020-10-16 21:02:56 +03:00
|
|
|
?: =(~ takos)
|
2020-08-26 08:49:27 +03:00
|
|
|
(silt (turn ~(tap in bases) ~(got by hut.ran)))
|
2020-10-16 21:02:56 +03:00
|
|
|
=^ =tako takos ~(get to takos)
|
|
|
|
=. done (~(put in done) tako)
|
2020-08-27 03:11:26 +03:00
|
|
|
:: If this is a common ancestor, stop recursing through our
|
|
|
|
:: parentage. Check if it's comparable to any existing candidate.
|
|
|
|
::
|
2020-10-16 21:02:56 +03:00
|
|
|
?: (~(has in ali-takos) tako)
|
2020-08-26 08:49:27 +03:00
|
|
|
=/ base-list ~(tap in bases)
|
|
|
|
|- ^- (set yaki)
|
|
|
|
=* bases-loop $
|
|
|
|
?~ base-list
|
2020-08-27 03:11:26 +03:00
|
|
|
:: Proven it's not an ancestor of any previous candidate.
|
|
|
|
:: Remove all ancestors of new candidate and add it to the
|
|
|
|
:: candidate list.
|
2020-08-26 08:49:27 +03:00
|
|
|
::
|
|
|
|
=. bases
|
2020-10-16 21:02:56 +03:00
|
|
|
=/ new-reachable (reachable-takos:ze tako)
|
|
|
|
(~(put in (~(dif in bases) new-reachable)) tako)
|
|
|
|
outer-loop
|
2020-08-27 03:11:26 +03:00
|
|
|
:: If it's an ancestor of another candidate, this is not most
|
|
|
|
:: recent, so skip and try next in worklist.
|
2020-08-26 08:49:27 +03:00
|
|
|
::
|
2020-08-27 03:11:26 +03:00
|
|
|
=/ base-reachable (reachable-takos:ze i.base-list)
|
2020-10-16 21:02:56 +03:00
|
|
|
?: (~(has in base-reachable) tako)
|
|
|
|
outer-loop
|
2020-08-26 08:49:27 +03:00
|
|
|
bases-loop(base-list t.base-list)
|
|
|
|
:: Append parents to list and recurse
|
|
|
|
::
|
2020-10-16 21:02:56 +03:00
|
|
|
=/ bob-yaki (~(got by hut.ran) tako)
|
|
|
|
=/ new-candidates (skip p.bob-yaki ~(has in done))
|
|
|
|
%_ outer-loop
|
|
|
|
done (~(gas in done) new-candidates)
|
|
|
|
takos (~(gas to takos) new-candidates)
|
|
|
|
==
|
2020-08-26 06:25:39 +03:00
|
|
|
::
|
2020-05-12 11:27:19 +03:00
|
|
|
:: Update mime cache
|
|
|
|
::
|
|
|
|
++ checkout-mime
|
|
|
|
|= $: =ford=args:ford:fusion
|
|
|
|
deletes=(set path)
|
|
|
|
changes=(set path)
|
|
|
|
==
|
|
|
|
^- [(map path (unit mime)) ford-cache]
|
|
|
|
=/ mim=(map path (unit mime))
|
|
|
|
=/ dels=(list path) ~(tap by deletes)
|
|
|
|
|- ^- (map path (unit mime))
|
|
|
|
?~ dels
|
|
|
|
~
|
|
|
|
(~(put by $(dels t.dels)) i.dels ~)
|
|
|
|
=/ cans=(list path) ~(tap by changes)
|
|
|
|
|- ^- [(map path (unit mime)) ford-cache]
|
|
|
|
?~ cans
|
|
|
|
[mim ford-cache.ford-args]
|
|
|
|
=^ cage ford-cache.ford-args
|
|
|
|
~| mime-cast-fail+i.cans
|
|
|
|
(wrap:fusion (cast-path:(ford:fusion ford-args) i.cans %mime))
|
|
|
|
=^ mim ford-cache.ford-args $(cans t.cans)
|
|
|
|
[(~(put by mim) i.cans `!<(mime q.cage)) ford-cache.ford-args]
|
|
|
|
::
|
|
|
|
:: Add or remove entries to the mime cache
|
|
|
|
::
|
|
|
|
++ apply-changes-to-mim
|
|
|
|
|= [mim=(map path mime) changes=(map path (unit mime))]
|
|
|
|
^- (map path mime)
|
|
|
|
=/ changes-l=(list [pax=path change=(unit mime)])
|
|
|
|
~(tap by changes)
|
|
|
|
|- ^- (map path mime)
|
|
|
|
?~ changes-l
|
|
|
|
mim
|
|
|
|
?~ change.i.changes-l
|
|
|
|
$(changes-l t.changes-l, mim (~(del by mim) pax.i.changes-l))
|
|
|
|
$(changes-l t.changes-l, mim (~(put by mim) [pax u.change]:i.changes-l))
|
|
|
|
::
|
|
|
|
:: Emit update to unix sync
|
|
|
|
::
|
|
|
|
++ ergo
|
|
|
|
|= mim=(map path (unit mime))
|
|
|
|
^+ ..park
|
|
|
|
=/ must (must-ergo her syd mon (turn ~(tap by mim) head))
|
|
|
|
%- emil
|
|
|
|
%+ turn ~(tap by must)
|
|
|
|
|= [pot=term len=@ud pak=(set path)]
|
|
|
|
:* (need hez) %give %ergo pot
|
|
|
|
%+ turn ~(tap in pak)
|
|
|
|
|= pax=path
|
|
|
|
[(slag len pax) (~(got by mim) pax)]
|
|
|
|
==
|
|
|
|
::
|
|
|
|
:: Output is a map of mount points to {length-of-mounted-path set-of-paths}.
|
|
|
|
::
|
|
|
|
++ must-ergo
|
|
|
|
|= [our=ship syd=desk mon=(map term beam) can/(list path)]
|
|
|
|
^- (map term (pair @ud (set path)))
|
|
|
|
%- malt ^- (list (trel term @ud (set path)))
|
|
|
|
%+ murn ~(tap by mon)
|
|
|
|
|= {nam/term bem/beam}
|
|
|
|
^- (unit (trel term @ud (set path)))
|
|
|
|
=- ?~(- ~ `[nam (lent s.bem) (silt `(list path)`-)])
|
|
|
|
%+ skim can
|
|
|
|
|= pax/path
|
2020-11-24 04:20:36 +03:00
|
|
|
&(=(p.bem our) =(q.bem syd) =(s.bem (scag (lent s.bem) pax)))
|
2020-05-12 11:27:19 +03:00
|
|
|
::
|
|
|
|
:: Mount a beam to unix
|
|
|
|
::
|
|
|
|
++ mount
|
|
|
|
|= [pot=term =case =spur]
|
|
|
|
^+ ..mount
|
|
|
|
=/ old-mon (~(get by mon) pot)
|
|
|
|
?^ old-mon
|
|
|
|
%- (slog >%already-mounted< >u.old-mon< ~)
|
|
|
|
..mount
|
|
|
|
=. mon (~(put by mon) pot [her syd case] spur)
|
|
|
|
=/ =yaki (~(got by hut.ran) (~(got by hit.dom) let.dom))
|
|
|
|
=/ changes (~(run by q.yaki) |=(=lobe |+lobe))
|
|
|
|
=/ =args:ford:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
[zuse:(need fer.dom) ank.dom ~ changes lat.ran fod.dom]
|
2020-05-12 11:27:19 +03:00
|
|
|
=^ mim ford-cache.args
|
|
|
|
(checkout-mime args ~ ~(key by changes))
|
|
|
|
=. mim.dom (apply-changes-to-mim mim.dom mim)
|
|
|
|
=. fod.dom ford-cache.args
|
|
|
|
(ergo mim)
|
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Set permissions for a node.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ perm
|
|
|
|
|= {pax/path rit/rite}
|
|
|
|
^+ +>
|
|
|
|
=/ mis/(set @ta)
|
|
|
|
%+ roll
|
|
|
|
=- ~(tap in -)
|
|
|
|
?- -.rit
|
|
|
|
$r who:(fall red.rit *rule)
|
|
|
|
$w who:(fall wit.rit *rule)
|
|
|
|
$rw (~(uni in who:(fall red.rit *rule)) who:(fall wit.rit *rule))
|
|
|
|
==
|
|
|
|
|= {w/whom s/(set @ta)}
|
|
|
|
?: |(?=(%& -.w) (~(has by cez) p.w)) s
|
|
|
|
(~(put in s) p.w)
|
|
|
|
?^ mis
|
2019-07-16 02:11:22 +03:00
|
|
|
:: TODO remove this nasty hack
|
|
|
|
::
|
|
|
|
?. ?=([[%a *] *] hen)
|
|
|
|
+>.$
|
2019-06-29 02:43:52 +03:00
|
|
|
=- (emit hen %give %done `[%perm-fail [%leaf "No such group(s): {-}"]~])
|
2019-05-03 04:50:20 +03:00
|
|
|
%+ roll ~(tap in `(set @ta)`mis)
|
|
|
|
|= {g/@ta t/tape}
|
|
|
|
?~ t (trip g)
|
|
|
|
:(weld t ", " (trip g))
|
2019-07-16 02:11:22 +03:00
|
|
|
:: TODO remove this nasty hack
|
|
|
|
::
|
|
|
|
=< ?. ?=([[%a *] *] hen)
|
|
|
|
.
|
|
|
|
(emit hen %give %done ~)
|
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
?- -.rit
|
|
|
|
$r wake(per (put-perm per pax red.rit))
|
|
|
|
$w wake(pew (put-perm pew pax wit.rit))
|
|
|
|
$rw wake(per (put-perm per pax red.rit), pew (put-perm pew pax wit.rit))
|
|
|
|
==
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ put-perm
|
|
|
|
|= {pes/regs pax/path new/(unit rule)}
|
|
|
|
?~ new (~(del by pes) pax)
|
|
|
|
(~(put by pes) pax u.new)
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Remove a group from all rules.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ forget-crew
|
|
|
|
|= nom/@ta
|
|
|
|
%= +>
|
|
|
|
per (forget-crew-in nom per)
|
|
|
|
pew (forget-crew-in nom pew)
|
|
|
|
==
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ forget-crew-in
|
|
|
|
|= {nom/@ta pes/regs}
|
|
|
|
%- ~(run by pes)
|
|
|
|
|= r/rule
|
|
|
|
r(who (~(del in who.r) |+nom))
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Cancel a request.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: For local requests, we just remove it from `qyx`. For foreign requests,
|
|
|
|
:: we remove it from `ref` and tell the foreign ship to cancel as well.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ cancel-request :: release request
|
2020-10-09 05:34:33 +03:00
|
|
|
^+ ..cancel-request
|
2019-05-03 04:50:20 +03:00
|
|
|
=^ wos/(list wove) qyx
|
|
|
|
:_ (~(run by qyx) |=(a/(set duct) (~(del in a) hen)))
|
|
|
|
%- ~(rep by qyx)
|
|
|
|
|= {{a/wove b/(set duct)} c/(list wove)}
|
|
|
|
?.((~(has in b) hen) c [a c])
|
2020-10-09 05:34:33 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
?~ ref
|
2020-10-09 05:34:33 +03:00
|
|
|
=> .(ref `(unit rind)`ref) :: XX TMI
|
|
|
|
?: =(~ wos) ..cancel-request :: XX handle?
|
|
|
|
|- ^+ ..cancel-request
|
|
|
|
?~ wos ..cancel-request
|
|
|
|
=. ..cancel-request (run-if-future rove.i.wos |=(@da (best hen +<)))
|
|
|
|
$(wos t.wos)
|
|
|
|
::
|
|
|
|
?~ nux=(~(get by fod.u.ref) hen)
|
|
|
|
..cancel-request(ref `(unit rind)`ref) :: XX TMI
|
2019-05-03 04:50:20 +03:00
|
|
|
=: fod.u.ref (~(del by fod.u.ref) hen)
|
|
|
|
bom.u.ref (~(del by bom.u.ref) u.nux)
|
|
|
|
==
|
2020-10-09 05:34:33 +03:00
|
|
|
%. [hen her u.nux [syd ~]]
|
|
|
|
send-over-ames(ref `(unit rind)`ref) :: XX TMI
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: Handles a request.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
:: `%sing` requests are handled by ++aver. `%next` requests are handled by
|
|
|
|
:: running ++aver at the given case, and then subsequent cases until we find
|
|
|
|
:: a case where the two results aren't equivalent. If it hasn't happened
|
|
|
|
:: yet, we wait. `%many` requests are handled by producing as much as we can
|
|
|
|
:: and then waiting if the subscription range extends into the future.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-03 04:50:20 +03:00
|
|
|
++ start-request
|
2020-07-23 07:57:44 +03:00
|
|
|
|= [for=(unit [ship @ud]) rav=rave]
|
2019-05-23 00:39:12 +03:00
|
|
|
^+ ..start-request
|
2020-04-19 11:58:12 +03:00
|
|
|
=^ [new-sub=(unit rove) sub-results=(list sub-result)] fod.dom
|
|
|
|
(try-fill-sub for (rave-to-rove rav))
|
2019-05-23 00:39:12 +03:00
|
|
|
=. ..start-request (send-sub-results sub-results [hen ~ ~])
|
|
|
|
?~ new-sub
|
|
|
|
..start-request
|
|
|
|
(duce for u.new-sub)
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-17 03:24:10 +03:00
|
|
|
:: Called when a foreign ship answers one of our requests.
|
|
|
|
::
|
2020-05-13 08:53:23 +03:00
|
|
|
:: If it's a `%many` request, process in +take-foreign-update
|
2019-05-17 03:24:10 +03:00
|
|
|
::
|
|
|
|
:: After updating ref (our request manager), we handle %x, %w, and %y
|
|
|
|
:: responses. For %x, we call ++validate-x to validate the type of
|
|
|
|
:: the response. For %y, we coerce the result to an arch.
|
|
|
|
::
|
|
|
|
++ take-foreign-answer :: external change
|
|
|
|
|= [inx=@ud rut=(unit rand)]
|
|
|
|
^+ +>
|
|
|
|
?> ?=(^ ref)
|
|
|
|
=+ ruv=(~(get by bom.u.ref) inx)
|
|
|
|
?~ ruv +>.$
|
2020-07-23 11:36:38 +03:00
|
|
|
=/ rav=rave rave.u.ruv
|
2019-05-17 03:24:10 +03:00
|
|
|
?: ?=(%many -.rav)
|
2020-07-23 11:36:38 +03:00
|
|
|
abet:(apex:(foreign-update inx) rut)
|
2019-05-17 03:24:10 +03:00
|
|
|
?~ rut
|
|
|
|
:: nothing here, so cache that
|
|
|
|
::
|
|
|
|
%_ wake
|
|
|
|
haw.u.ref
|
|
|
|
?. ?=($sing -.rav) haw.u.ref
|
2019-05-23 00:39:12 +03:00
|
|
|
(~(put by haw.u.ref) mood.rav ~)
|
2019-05-17 03:24:10 +03:00
|
|
|
==
|
2020-05-13 06:22:25 +03:00
|
|
|
|^
|
|
|
|
=/ result=(unit cage) (validate u.rut)
|
|
|
|
=/ =mood [p.p q.p q]:u.rut
|
|
|
|
=: haw.u.ref (~(put by haw.u.ref) mood result)
|
|
|
|
bom.u.ref (~(del by bom.u.ref) inx)
|
|
|
|
fod.u.ref (~(del by fod.u.ref) hen)
|
|
|
|
==
|
|
|
|
wake
|
|
|
|
:: something here, so validate
|
2019-05-17 03:24:10 +03:00
|
|
|
::
|
2020-05-13 06:22:25 +03:00
|
|
|
++ validate
|
|
|
|
|= =rand
|
|
|
|
^- (unit cage)
|
|
|
|
?- p.p.rand
|
|
|
|
$a ~| %no-big-ford-builds-across-network-for-now !!
|
|
|
|
$b ~| %i-guess-you-ought-to-build-your-own-marks !!
|
|
|
|
$c ~| %casts-should-be-compiled-on-your-own-ship !!
|
|
|
|
$d ~| %totally-temporary-error-please-replace-me !!
|
|
|
|
$p ~| %requesting-foreign-permissions-is-invalid !!
|
2020-05-14 05:28:04 +03:00
|
|
|
$r ~| %no-cages-please-they-are-just-way-too-big !!
|
2020-05-13 06:22:25 +03:00
|
|
|
$s ~| %please-dont-get-your-takos-over-a-network !!
|
|
|
|
$t ~| %requesting-foreign-directory-is-vaporware !!
|
|
|
|
$u ~| %prolly-poor-idea-to-get-rang-over-network !!
|
|
|
|
$v ~| %weird-shouldnt-get-v-request-from-network !!
|
2020-05-23 00:32:32 +03:00
|
|
|
$z `(validate-z r.rand)
|
2020-05-13 06:22:25 +03:00
|
|
|
$w `(validate-w r.rand)
|
|
|
|
$x (validate-x [p.p q.p q r]:rand)
|
|
|
|
$y `[p.r.rand !>(;;(arch q.r.rand))]
|
|
|
|
==
|
|
|
|
::
|
|
|
|
:: Make sure the incoming data is a %w response
|
|
|
|
::
|
|
|
|
++ validate-w
|
|
|
|
|= =page
|
|
|
|
^- cage
|
|
|
|
:- p.page
|
|
|
|
?+ p.page ~| %strange-w-over-nextwork !!
|
|
|
|
$cass !>(;;(cass q.page))
|
|
|
|
$null [[%atom %n ~] ~]
|
|
|
|
$nako !>(~|([%molding [&1 &2 &3]:q.page] ;;(nako q.page)))
|
|
|
|
==
|
|
|
|
::
|
|
|
|
:: Make sure that incoming data is of the mark it claims to be.
|
|
|
|
::
|
|
|
|
++ validate-x
|
|
|
|
|= [car=care cas=case pax=path peg=page]
|
|
|
|
^- (unit cage)
|
|
|
|
=/ vale-result
|
|
|
|
%- mule |.
|
|
|
|
%- wrap:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
(page-to-cage:(ford:fusion static-ford-args) peg)
|
2020-05-13 06:22:25 +03:00
|
|
|
?: ?=(%| -.vale-result)
|
|
|
|
%- (slog >%validate-x-failed< p.vale-result)
|
|
|
|
~
|
|
|
|
`-.p.vale-result
|
2020-05-23 00:32:32 +03:00
|
|
|
::
|
|
|
|
:: Make sure the incoming data is a %z response
|
|
|
|
::
|
|
|
|
++ validate-z
|
|
|
|
|= =page
|
|
|
|
^- cage
|
|
|
|
?> ?=(%uvi p.page)
|
|
|
|
:- p.page
|
|
|
|
!>(;;(@uvI q.page))
|
2020-05-13 06:22:25 +03:00
|
|
|
--
|
2019-05-17 03:24:10 +03:00
|
|
|
::
|
2020-07-23 11:36:38 +03:00
|
|
|
:: Respond to backfill request
|
2019-05-17 03:24:10 +03:00
|
|
|
::
|
2020-07-23 11:36:38 +03:00
|
|
|
:: Maybe should verify the requester is allowed to access this blob?
|
|
|
|
::
|
|
|
|
++ give-backfill
|
|
|
|
|= =lobe
|
|
|
|
^+ ..give-backfill
|
|
|
|
(emit hen %give %boon (~(got by lat.ran) lobe))
|
|
|
|
::
|
|
|
|
:: Ingest foreign update, requesting missing blobs if necessary
|
|
|
|
::
|
|
|
|
++ foreign-update
|
|
|
|
|= inx=@ud
|
2019-05-17 03:24:10 +03:00
|
|
|
?> ?=(^ ref)
|
2020-07-23 11:36:38 +03:00
|
|
|
=/ [sat=update-state lost=?]
|
|
|
|
=/ ruv (~(get by bom.u.ref) inx)
|
|
|
|
?~ ruv
|
|
|
|
~& [%clay-foreign-update-lost her syd inx]
|
|
|
|
[*update-state &]
|
|
|
|
[u.ruv |]
|
|
|
|
=/ done=? |
|
|
|
|
=. hen duct.sat
|
|
|
|
|%
|
|
|
|
++ abet
|
|
|
|
^+ ..foreign-update
|
|
|
|
?: lost
|
|
|
|
..foreign-update
|
|
|
|
?: done
|
|
|
|
=: bom.u.ref (~(del by bom.u.ref) inx)
|
|
|
|
fod.u.ref (~(del by fod.u.ref) hen)
|
|
|
|
==
|
|
|
|
=<(?>(?=(^ ref) .) wake)
|
|
|
|
=. bom.u.ref (~(put by bom.u.ref) inx sat)
|
|
|
|
..foreign-update
|
|
|
|
::
|
|
|
|
++ apex
|
|
|
|
|= rut=(unit rand)
|
|
|
|
^+ ..abet
|
|
|
|
?: lost ..abet
|
|
|
|
?~ rut
|
|
|
|
=. nako.sat (~(put to nako.sat) ~)
|
|
|
|
work
|
|
|
|
?> ?=(%nako p.r.u.rut)
|
|
|
|
=/ nako ;;(nako q.r.u.rut)
|
|
|
|
=/ missing (missing-blobs nako)
|
|
|
|
=. need.sat `(list lobe)`(welp need.sat ~(tap in missing))
|
|
|
|
=. nako.sat (~(put to nako.sat) ~ nako)
|
|
|
|
work
|
2020-05-13 08:53:23 +03:00
|
|
|
::
|
2020-07-23 07:57:44 +03:00
|
|
|
++ missing-blobs
|
|
|
|
|= =nako
|
2020-07-23 11:36:38 +03:00
|
|
|
^- (set lobe)
|
2020-07-23 07:57:44 +03:00
|
|
|
=/ yakis ~(tap in lar.nako)
|
2020-07-23 11:36:38 +03:00
|
|
|
|- ^- (set lobe)
|
2020-07-23 07:57:44 +03:00
|
|
|
=* yaki-loop $
|
|
|
|
?~ yakis
|
|
|
|
~
|
|
|
|
=/ lobes=(list [=path =lobe]) ~(tap by q.i.yakis)
|
2020-07-23 11:36:38 +03:00
|
|
|
|- ^- (set lobe)
|
2020-07-23 07:57:44 +03:00
|
|
|
=* blob-loop $
|
|
|
|
?~ lobes
|
|
|
|
yaki-loop(yakis t.yakis)
|
|
|
|
?: (~(has by lat.ran) lobe.i.lobes)
|
|
|
|
blob-loop(lobes t.lobes)
|
2020-07-23 11:36:38 +03:00
|
|
|
(~(put in blob-loop(lobes t.lobes)) lobe.i.lobes)
|
|
|
|
::
|
|
|
|
:: Receive backfill response
|
|
|
|
::
|
|
|
|
++ take-backfill
|
|
|
|
|= =blob
|
|
|
|
^+ ..abet
|
|
|
|
?: lost ..abet
|
|
|
|
=? need.sat
|
|
|
|
?& ?=(%delta -.blob)
|
|
|
|
!(~(has by lat.ran) q.q.blob)
|
|
|
|
!(~(has by have.sat) q.q.blob)
|
|
|
|
==
|
|
|
|
[q.q.blob need.sat]
|
|
|
|
:: We can't put a blob in lat.ran if its parent isn't already
|
|
|
|
:: there. Unions are in reverse order so we don't overwrite
|
|
|
|
:: existing blobs.
|
|
|
|
::
|
|
|
|
=. ..abet
|
|
|
|
?: &(?=(%delta -.blob) !(~(has by lat.ran) q.q.blob))
|
|
|
|
..abet(have.sat (~(uni by (malt [p.blob `^blob`blob] ~)) have.sat))
|
|
|
|
..abet(lat.ran (~(uni by (malt [p.blob blob] ~)) lat.ran))
|
|
|
|
work(busy.sat |)
|
|
|
|
::
|
|
|
|
:: Fetch next blob
|
|
|
|
::
|
|
|
|
++ work
|
|
|
|
^+ ..abet
|
|
|
|
?: busy.sat
|
|
|
|
..abet
|
|
|
|
|- ^+ ..abet
|
|
|
|
?: =(~ need.sat)
|
|
|
|
:: NB: if you change to release nakos as we get enough blobs
|
|
|
|
:: for them instead of all at the end, you *must* store the
|
|
|
|
:: `lim` that should be applied after the nako is complete and
|
|
|
|
:: not use the one in the rave, since that will apply to the
|
|
|
|
:: end of subscription.
|
|
|
|
::
|
|
|
|
=. lat.ran (~(uni by have.sat) lat.ran)
|
|
|
|
|- ^+ ..abet
|
|
|
|
?: =(~ nako.sat)
|
|
|
|
..abet
|
|
|
|
=^ next=(unit nako) nako.sat ~(get to nako.sat)
|
|
|
|
?~ next
|
|
|
|
..abet(done &)
|
|
|
|
=. ..abet (apply-foreign-update u.next)
|
|
|
|
=. ..foreign-update =<(?>(?=(^ ref) .) wake)
|
|
|
|
$
|
|
|
|
?> ?=(^ need.sat)
|
|
|
|
:: This is what removes an item from `need`. This happens every
|
|
|
|
:: time we take a backfill response, but it could happen more than
|
|
|
|
:: once if we somehow got this data in the meantime (maybe from
|
|
|
|
:: another desk updating concurrently, or a previous update on this
|
|
|
|
:: same desk).
|
|
|
|
::
|
|
|
|
?: ?| (~(has by lat.ran) i.need.sat)
|
|
|
|
(~(has by have.sat) i.need.sat)
|
|
|
|
==
|
|
|
|
$(need.sat t.need.sat)
|
|
|
|
:: Otherwise, fetch the next blob
|
|
|
|
::
|
|
|
|
=/ =fill [syd i.need.sat]
|
|
|
|
=/ =wire /back-index/(scot %p her)/[syd]/(scot %ud inx)
|
|
|
|
=/ =path [%backfill syd (scot %ud inx) ~]
|
|
|
|
=. ..foreign-update
|
2020-07-23 07:57:44 +03:00
|
|
|
=< ?>(?=(^ ref) .)
|
2020-07-23 11:36:38 +03:00
|
|
|
(emit hen %pass wire %a %plea her %c path fill)
|
|
|
|
..abet(busy.sat &)
|
2020-05-13 08:53:23 +03:00
|
|
|
::
|
|
|
|
:: When we get a %w foreign update, store this in our state.
|
|
|
|
::
|
|
|
|
:: We get the commits and blobs from the nako and add them to our
|
|
|
|
:: object store, then we update the map of aeons to commits and the
|
|
|
|
:: latest aeon.
|
|
|
|
::
|
|
|
|
++ apply-foreign-update
|
|
|
|
|= =nako
|
2020-07-23 11:36:38 +03:00
|
|
|
^+ ..abet
|
2020-05-13 08:53:23 +03:00
|
|
|
:: hit: updated commit-hashes by @ud case
|
|
|
|
:: nut: new commit-hash/commit pairs
|
|
|
|
:: hut: updated commits by hash
|
|
|
|
:: nat: new blob-hash/blob pairs
|
|
|
|
:: lat: updated blobs by hash
|
|
|
|
::
|
|
|
|
=/ hit (~(uni by hit.dom) gar.nako)
|
|
|
|
=/ nut (turn ~(tap in lar.nako) |=(=yaki [r.yaki yaki]))
|
|
|
|
=/ hut (~(uni by (malt nut)) hut.ran)
|
|
|
|
=/ nat (turn ~(tap in bar.nako) |=(=blob [p.blob blob]))
|
|
|
|
=/ lat (~(uni by (malt nat)) lat.ran)
|
|
|
|
:: traverse updated state and sanity check
|
|
|
|
::
|
|
|
|
=+ ~| :* %bad-foreign-update
|
2020-06-29 23:25:10 +03:00
|
|
|
[gar=gar.nako let=let.nako nut=(turn nut head) nat=(turn nat head)]
|
2020-05-13 08:53:23 +03:00
|
|
|
[hitdom=hit.dom letdom=let.dom]
|
|
|
|
==
|
|
|
|
?: =(0 let.nako)
|
|
|
|
~
|
|
|
|
=/ =aeon 1
|
|
|
|
|- ^- ~
|
|
|
|
=/ =tako
|
|
|
|
~| [%missing-aeon aeon] (~(got by hit) aeon)
|
|
|
|
=/ =yaki
|
|
|
|
~| [%missing-tako tako] (~(got by hut) tako)
|
|
|
|
=+ %+ turn
|
|
|
|
~(tap by q.yaki)
|
|
|
|
|= [=path =lobe]
|
|
|
|
~| [%missing-blob path lobe]
|
|
|
|
?> (~(has by lat) lobe)
|
|
|
|
~
|
|
|
|
?: =(let.nako aeon)
|
|
|
|
~
|
|
|
|
$(aeon +(aeon))
|
|
|
|
:: produce updated state
|
|
|
|
::
|
2020-07-23 11:36:38 +03:00
|
|
|
=/ =rave rave:(~(got by bom.u.ref) inx)
|
|
|
|
?> ?=(%many -.rave)
|
2020-05-13 08:53:23 +03:00
|
|
|
=: let.dom (max let.nako let.dom)
|
|
|
|
hit.dom hit
|
|
|
|
hut.ran hut
|
|
|
|
lat.ran lat
|
2020-07-23 11:36:38 +03:00
|
|
|
:: Is this correct? Seeems like it should only go to `to` if
|
|
|
|
:: we've gotten all the way to the end. Leaving this
|
|
|
|
:: behavior unchanged for now, but I believe it's wrong.
|
|
|
|
::
|
|
|
|
lim ?.(?=(%da -.to.moat.rave) lim p.to.moat.rave)
|
2020-05-13 08:53:23 +03:00
|
|
|
==
|
2020-07-23 11:36:38 +03:00
|
|
|
..abet
|
2020-05-13 08:53:23 +03:00
|
|
|
--
|
2019-05-17 03:24:10 +03:00
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
:: fire function if request is in future
|
|
|
|
::
|
|
|
|
++ run-if-future
|
|
|
|
|= [rov=rove fun=$-(@da _.)]
|
2016-11-24 07:25:07 +03:00
|
|
|
^+ +>.$
|
|
|
|
%+ fall
|
|
|
|
%+ bind
|
|
|
|
^- (unit @da)
|
|
|
|
?- -.rov
|
2019-05-23 00:39:12 +03:00
|
|
|
%sing
|
|
|
|
?. ?=(%da -.case.mood.rov) ~
|
|
|
|
`p.case.mood.rov
|
2018-01-15 22:09:38 +03:00
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
%next ~
|
|
|
|
%mult ~
|
|
|
|
%many
|
2016-12-02 22:34:07 +03:00
|
|
|
%^ hunt lth
|
2019-05-23 03:01:02 +03:00
|
|
|
?. ?=(%da -.from.moat.rov) ~
|
|
|
|
?. (lth now p.from.moat.rov) ~
|
|
|
|
[~ p.from.moat.rov]
|
2019-05-23 00:39:12 +03:00
|
|
|
?. ?=(%da -.to.moat.rov) ~
|
2019-05-23 03:01:02 +03:00
|
|
|
`(max now p.to.moat.rov)
|
2016-11-24 07:25:07 +03:00
|
|
|
==
|
|
|
|
fun
|
|
|
|
+>.$
|
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
++ rave-to-rove
|
|
|
|
|= rav/rave
|
|
|
|
^- rove
|
|
|
|
?- -.rav
|
|
|
|
%sing rav
|
|
|
|
%next [- mood ~ ~]:rav
|
|
|
|
%mult [- mool ~ ~ ~]:rav
|
|
|
|
%many [- track moat ~]:rav
|
|
|
|
==
|
|
|
|
::
|
|
|
|
++ rove-to-rave
|
2016-11-24 07:25:07 +03:00
|
|
|
|= rov/rove
|
|
|
|
^- rave
|
|
|
|
?- -.rov
|
2019-05-23 00:39:12 +03:00
|
|
|
%sing rov
|
|
|
|
%next [- mood]:rov
|
|
|
|
%mult [- mool]:rov
|
|
|
|
%many [- track moat]:rov
|
2016-11-24 07:25:07 +03:00
|
|
|
==
|
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
++ send-sub-results
|
|
|
|
|= [sub-results=(list sub-result) ducts=(set duct)]
|
|
|
|
^+ ..wake
|
|
|
|
?~ sub-results
|
|
|
|
..wake
|
|
|
|
=. ..wake
|
|
|
|
?- -.i.sub-results
|
|
|
|
%blab (blab-all ducts +.i.sub-results)
|
|
|
|
%bleb (bleb-all ducts +.i.sub-results)
|
|
|
|
%balk (balk-all ducts +.i.sub-results)
|
|
|
|
%blas (blas-all ducts +.i.sub-results)
|
|
|
|
%blub (blub-all ducts +.i.sub-results)
|
|
|
|
==
|
|
|
|
$(sub-results t.sub-results)
|
|
|
|
::
|
2019-05-23 03:01:02 +03:00
|
|
|
:: Loop through open subscriptions and check if we can fill any of
|
|
|
|
:: them.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
++ wake
|
2016-11-24 07:25:07 +03:00
|
|
|
^+ .
|
2019-05-23 00:39:12 +03:00
|
|
|
=/ old-subs=(list [=wove ducts=(set duct)]) ~(tap by qyx)
|
2019-05-23 03:01:02 +03:00
|
|
|
=| new-subs=(list [=wove ducts=(set duct)])
|
2016-11-24 07:25:07 +03:00
|
|
|
|- ^+ ..wake
|
2019-05-23 00:39:12 +03:00
|
|
|
?~ old-subs
|
|
|
|
:: install new subs
|
|
|
|
::
|
|
|
|
..wake(qyx (~(gas by *cult) new-subs))
|
|
|
|
?: =(~ ducts.i.old-subs)
|
|
|
|
:: drop forgotten roves
|
|
|
|
::
|
2019-05-23 03:01:02 +03:00
|
|
|
$(old-subs t.old-subs)
|
2020-04-19 11:58:12 +03:00
|
|
|
=^ [new-sub=(unit rove) sub-results=(list sub-result)] fod.dom
|
|
|
|
(try-fill-sub wove.i.old-subs)
|
2019-05-23 00:39:12 +03:00
|
|
|
=. ..wake (send-sub-results sub-results ducts.i.old-subs)
|
|
|
|
=. new-subs
|
|
|
|
?~ new-sub
|
|
|
|
new-subs
|
|
|
|
[[[for.wove.i.old-subs u.new-sub] ducts.i.old-subs] new-subs]
|
|
|
|
$(old-subs t.old-subs)
|
|
|
|
::
|
|
|
|
:: Try to fill a subscription
|
|
|
|
::
|
|
|
|
++ try-fill-sub
|
2020-07-23 07:57:44 +03:00
|
|
|
|= [far=(unit [=ship ver=@ud]) rov=rove]
|
2020-04-19 11:58:12 +03:00
|
|
|
^- [[new-sub=(unit rove) (list sub-result)] ford-cache]
|
2020-07-23 07:57:44 +03:00
|
|
|
=/ for=(unit ship) ?~(far ~ `ship.u.far)
|
2018-02-07 03:34:09 +03:00
|
|
|
?- -.rov
|
2019-05-23 00:39:12 +03:00
|
|
|
%sing
|
|
|
|
=/ cache-value=(unit (unit cage))
|
|
|
|
?~(ref ~ (~(get by haw.u.ref) mood.rov))
|
|
|
|
?^ cache-value
|
|
|
|
:: if we have a result in our cache, produce it
|
|
|
|
::
|
2020-04-19 11:58:12 +03:00
|
|
|
:_ fod.dom
|
2019-05-23 00:39:12 +03:00
|
|
|
:- ~
|
|
|
|
?~ u.cache-value
|
|
|
|
[%blub ~]~
|
|
|
|
[%blab mood.rov %& u.u.cache-value]~
|
|
|
|
:: else, check to see if rove is for an aeon we know
|
|
|
|
::
|
|
|
|
=/ aeon=(unit aeon) (case-to-aeon case.mood.rov)
|
|
|
|
?~ aeon
|
2020-04-19 11:58:12 +03:00
|
|
|
[[`rov ~] fod.dom]
|
2019-05-23 00:39:12 +03:00
|
|
|
:: we have the appropriate aeon, so read in the data
|
|
|
|
::
|
2020-04-19 11:58:12 +03:00
|
|
|
=^ value=(unit (unit (each cage lobe))) fod.dom
|
2019-05-23 00:39:12 +03:00
|
|
|
(read-at-aeon:ze for u.aeon mood.rov)
|
|
|
|
?~ value
|
|
|
|
:: We don't have the data directly, which is potentially
|
|
|
|
:: problematical. How can we fetch the data?
|
|
|
|
::
|
|
|
|
?: =(0 u.aeon)
|
|
|
|
~& [%clay-sing-indirect-data-0 `path`[syd '0' path.mood.rov]]
|
2020-04-19 11:58:12 +03:00
|
|
|
[[~ ~] fod.dom]
|
2019-05-23 00:39:12 +03:00
|
|
|
~& [%clay-sing-indirect-data desk=syd mood=mood.rov aeon=u.aeon]
|
2020-04-19 11:58:12 +03:00
|
|
|
[[`rov ~] fod.dom]
|
2019-05-23 00:39:12 +03:00
|
|
|
:: we have the data, so we produce the results
|
|
|
|
::
|
2020-04-19 11:58:12 +03:00
|
|
|
[[~ [%balk u.value mood.rov]~] fod.dom]
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2018-01-19 03:54:41 +03:00
|
|
|
:: %next is just %mult with one path, so we pretend %next = %mult here.
|
2019-05-23 00:39:12 +03:00
|
|
|
::
|
|
|
|
?(%next %mult)
|
2018-01-18 01:55:12 +03:00
|
|
|
:: because %mult requests need to wait on multiple files for each
|
2019-05-23 00:39:12 +03:00
|
|
|
:: revision that needs to be checked for changes, we keep two
|
|
|
|
:: cache maps. {old} is the revision at {(dec aeon)}, {new} is
|
|
|
|
:: the revision at {aeon}. if we have no {aeon} yet, that means
|
|
|
|
:: it was still unknown last time we checked.
|
|
|
|
::
|
2018-02-07 03:34:09 +03:00
|
|
|
=* vor rov
|
2018-01-19 03:54:41 +03:00
|
|
|
|^
|
2019-05-23 00:39:12 +03:00
|
|
|
=/ rov=rove
|
|
|
|
?: ?=(%mult -.vor) vor
|
2018-01-19 03:54:41 +03:00
|
|
|
:* %mult
|
2019-05-23 00:39:12 +03:00
|
|
|
[case [[care path] ~ ~]]:mood.vor
|
|
|
|
aeon.vor
|
|
|
|
[[[care.mood.vor path.mood.vor] cach.vor] ~ ~]
|
2018-01-19 03:54:41 +03:00
|
|
|
~
|
|
|
|
==
|
2019-05-23 00:39:12 +03:00
|
|
|
?> ?=(%mult -.rov)
|
|
|
|
:: we will either respond or store the maybe updated request.
|
|
|
|
::
|
2020-04-19 11:58:12 +03:00
|
|
|
=; [res=(each (map mood (unit (each cage lobe))) rove) fod=ford-cache]
|
|
|
|
:_ fod
|
2018-05-04 03:59:10 +03:00
|
|
|
?: ?=(%& -.res)
|
2018-01-19 03:54:41 +03:00
|
|
|
(respond p.res)
|
|
|
|
(store p.res)
|
2019-05-23 00:39:12 +03:00
|
|
|
:: recurse here on next aeon if possible/needed.
|
|
|
|
::
|
2020-04-19 11:58:12 +03:00
|
|
|
|- ^- [(each (map mood (unit (each cage lobe))) rove) ford-cache]
|
2018-01-18 01:55:12 +03:00
|
|
|
:: if we don't have an aeon yet, see if we have one now.
|
2019-05-23 00:39:12 +03:00
|
|
|
::
|
|
|
|
?~ aeon.rov
|
|
|
|
=/ aeon=(unit aeon) (case-to-aeon case.mool.rov)
|
2018-01-18 01:55:12 +03:00
|
|
|
:: if we still don't, wait.
|
2019-05-23 00:39:12 +03:00
|
|
|
::
|
2020-04-19 11:58:12 +03:00
|
|
|
?~ aeon [|+rov fod.dom]
|
2018-01-18 01:55:12 +03:00
|
|
|
:: if we do, update the request and retry.
|
2019-05-23 00:39:12 +03:00
|
|
|
::
|
|
|
|
$(aeon.rov `+(u.aeon), old-cach.rov ~, new-cach.rov ~)
|
2018-01-22 18:01:00 +03:00
|
|
|
:: if old isn't complete, try filling in the gaps.
|
2019-05-23 00:39:12 +03:00
|
|
|
::
|
2020-04-19 11:58:12 +03:00
|
|
|
=^ o fod.dom
|
|
|
|
?: (complete old-cach.rov)
|
|
|
|
[old-cach.rov fod.dom]
|
2019-05-23 00:39:12 +03:00
|
|
|
(read-unknown mool.rov(case [%ud (dec u.aeon.rov)]) old-cach.rov)
|
2020-04-19 11:58:12 +03:00
|
|
|
=. old-cach.rov o
|
2018-01-18 01:55:12 +03:00
|
|
|
:: if the next aeon we want to compare is in the future, wait again.
|
2019-05-23 00:39:12 +03:00
|
|
|
::
|
|
|
|
=/ next-aeon=(unit aeon) (case-to-aeon [%ud u.aeon.rov])
|
2020-04-19 11:58:12 +03:00
|
|
|
?~ next-aeon [|+rov fod.dom]
|
2018-01-18 01:55:12 +03:00
|
|
|
:: if new isn't complete, try filling in the gaps.
|
2019-05-23 00:39:12 +03:00
|
|
|
::
|
2020-04-19 11:58:12 +03:00
|
|
|
=^ n fod.dom
|
|
|
|
?: (complete new-cach.rov)
|
|
|
|
[new-cach.rov fod.dom]
|
2019-05-23 00:39:12 +03:00
|
|
|
(read-unknown mool.rov(case [%ud u.aeon.rov]) new-cach.rov)
|
2020-04-19 11:58:12 +03:00
|
|
|
=. new-cach.rov n
|
2018-01-18 01:55:12 +03:00
|
|
|
:: if they're still not both complete, wait again.
|
2019-05-23 00:39:12 +03:00
|
|
|
::
|
|
|
|
?. ?& (complete old-cach.rov)
|
|
|
|
(complete new-cach.rov)
|
2018-01-18 01:55:12 +03:00
|
|
|
==
|
2020-04-19 11:58:12 +03:00
|
|
|
[|+rov fod.dom]
|
2019-05-23 00:39:12 +03:00
|
|
|
:: both complete, so check if anything has changed
|
|
|
|
::
|
2019-09-10 23:38:39 +03:00
|
|
|
=/ changes=(map mood (unit (each cage lobe)))
|
2019-05-23 00:39:12 +03:00
|
|
|
%+ roll ~(tap by old-cach.rov)
|
|
|
|
|= $: [[car=care pax=path] old-cach-value=cach]
|
2019-09-10 23:38:39 +03:00
|
|
|
changes=(map mood (unit (each cage lobe)))
|
2019-05-23 00:39:12 +03:00
|
|
|
==
|
|
|
|
=/ new-cach-value=cach (~(got by new-cach.rov) car pax)
|
|
|
|
?< |(?=(~ old-cach-value) ?=(~ new-cach-value))
|
2019-09-10 23:38:39 +03:00
|
|
|
=/ new-entry=(unit (pair mood (unit (each cage lobe))))
|
2019-05-23 00:39:12 +03:00
|
|
|
=/ =mood [car [%ud u.aeon.rov] pax]
|
|
|
|
?~ u.old-cach-value
|
|
|
|
?~ u.new-cach-value
|
|
|
|
:: not added
|
|
|
|
::
|
|
|
|
~
|
|
|
|
:: added
|
|
|
|
::
|
2019-09-10 23:38:39 +03:00
|
|
|
`[mood `u.u.new-cach-value]
|
2019-05-23 00:39:12 +03:00
|
|
|
?~ u.new-cach-value
|
|
|
|
:: deleted
|
|
|
|
::
|
2019-09-10 23:38:39 +03:00
|
|
|
`[mood ~]
|
2019-05-23 00:39:12 +03:00
|
|
|
?: (equivalent-data:ze u.u.new-cach-value u.u.old-cach-value)
|
|
|
|
:: unchanged
|
|
|
|
::
|
|
|
|
~
|
|
|
|
:: changed
|
|
|
|
::
|
2019-09-10 23:38:39 +03:00
|
|
|
`[mood `u.u.new-cach-value]
|
2019-05-23 00:39:12 +03:00
|
|
|
:: if changed, save the change
|
|
|
|
::
|
|
|
|
?~ new-entry
|
|
|
|
changes
|
|
|
|
(~(put by changes) u.new-entry)
|
|
|
|
:: if there are any changes, send response. if none, move on to
|
|
|
|
:: next aeon.
|
|
|
|
::
|
2020-04-19 11:58:12 +03:00
|
|
|
?^ changes [&+changes fod.dom]
|
2019-05-23 00:39:12 +03:00
|
|
|
$(u.aeon.rov +(u.aeon.rov), new-cach.rov ~)
|
|
|
|
::
|
|
|
|
:: check again later
|
2018-01-19 03:54:41 +03:00
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
++ store
|
|
|
|
|= rov=rove
|
|
|
|
^- [new-sub=(unit rove) (list sub-result)]
|
|
|
|
=/ new-rove=rove
|
|
|
|
?> ?=(%mult -.rov)
|
|
|
|
?: ?=(%mult -.vor) rov
|
|
|
|
?> ?=([* ~ ~] old-cach.rov)
|
|
|
|
=* one n.old-cach.rov
|
|
|
|
[%next [care.p.one case.mool.rov path.p.one] aeon.rov q.one]
|
|
|
|
[`new-rove ~]
|
2018-01-19 03:54:41 +03:00
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
:: send changes
|
|
|
|
::
|
|
|
|
++ respond
|
2019-09-10 23:38:39 +03:00
|
|
|
|= res=(map mood (unit (each cage lobe)))
|
2019-05-23 00:39:12 +03:00
|
|
|
^- [new-sub=(unit rove) (list sub-result)]
|
|
|
|
:- ~
|
|
|
|
?: ?=(%mult -.vor)
|
|
|
|
[%blas ~(key by res)]~
|
|
|
|
?> ?=([* ~ ~] res)
|
2019-09-10 23:38:39 +03:00
|
|
|
?~ q.n.res
|
|
|
|
[%blub ~]~
|
|
|
|
[%blab [p u.q]:n.res]~
|
2018-01-19 03:54:41 +03:00
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
:: no unknowns
|
|
|
|
::
|
|
|
|
++ complete
|
|
|
|
|= hav=(map (pair care path) cach)
|
2018-01-23 19:35:12 +03:00
|
|
|
?& ?=(^ hav)
|
|
|
|
(levy ~(tap by `(map (pair care path) cach)`hav) know)
|
|
|
|
==
|
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
:: know about file in cach
|
|
|
|
::
|
|
|
|
++ know |=({(pair care path) c/cach} ?=(^ c))
|
|
|
|
::
|
|
|
|
:: fill in the blanks
|
2018-01-19 03:54:41 +03:00
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
++ read-unknown
|
|
|
|
|= [=mool hav=(map (pair care path) cach)]
|
2020-04-19 11:58:12 +03:00
|
|
|
^- [_hav ford-cache]
|
2019-05-23 00:39:12 +03:00
|
|
|
=? hav ?=(~ hav)
|
|
|
|
%- malt ^- (list (pair (pair care path) cach))
|
|
|
|
%+ turn
|
|
|
|
~(tap in paths.mool)
|
|
|
|
|= [c=care p=path]
|
|
|
|
^- [[care path] cach]
|
|
|
|
[[c p] ~]
|
2020-04-19 11:58:12 +03:00
|
|
|
|- ^+ [hav fod.dom]
|
|
|
|
?~ hav [hav fod.dom]
|
|
|
|
=^ lef fod.dom $(hav l.hav)
|
|
|
|
=. l.hav lef
|
|
|
|
=^ rig fod.dom $(hav r.hav)
|
|
|
|
=. r.hav rig
|
|
|
|
=/ [[=care =path] =cach] n.hav
|
|
|
|
?^ cach
|
|
|
|
[hav fod.dom]
|
|
|
|
=^ q fod.dom (aver for care case.mool path)
|
|
|
|
=. q.n.hav q
|
|
|
|
[hav fod.dom]
|
2018-01-19 03:54:41 +03:00
|
|
|
--
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
%many
|
2020-04-19 11:58:12 +03:00
|
|
|
:_ fod.dom
|
2019-05-23 00:39:12 +03:00
|
|
|
=/ from-aeon (case-to-aeon from.moat.rov)
|
|
|
|
?~ from-aeon
|
|
|
|
:: haven't entered the relevant range, so do nothing
|
|
|
|
::
|
|
|
|
[`rov ~]
|
|
|
|
=/ to-aeon (case-to-aeon to.moat.rov)
|
2020-07-23 07:57:44 +03:00
|
|
|
=/ ver ?~(far %1 ver.u.far)
|
2019-05-23 00:39:12 +03:00
|
|
|
?~ to-aeon
|
|
|
|
:: we're in the middle of the range, so produce what we can,
|
|
|
|
:: but don't end the subscription
|
|
|
|
::
|
|
|
|
:: update "from" case to the aeon after now
|
|
|
|
::
|
|
|
|
=. from.moat.rov
|
|
|
|
[%ud +(let.dom)]
|
|
|
|
:- `rov
|
|
|
|
=/ new-lobes=(map path lobe)
|
|
|
|
(lobes-at-path:ze for let.dom path.moat.rov)
|
|
|
|
?: =(lobes.rov new-lobes)
|
|
|
|
:: if no changes, don't produce results
|
|
|
|
::
|
|
|
|
~
|
|
|
|
:: else changes, so produce them
|
|
|
|
::
|
2020-07-23 07:57:44 +03:00
|
|
|
[%bleb ver let.dom ?:(track.rov ~ `[u.from-aeon let.dom])]~
|
2019-05-23 00:39:12 +03:00
|
|
|
:: we're past the end of the range, so end subscription
|
|
|
|
::
|
|
|
|
:- ~
|
|
|
|
=/ new-lobes=(map path lobe)
|
|
|
|
(lobes-at-path:ze for u.to-aeon path.moat.rov)
|
|
|
|
:: if changed, give subscription result
|
|
|
|
::
|
|
|
|
=/ bleb=(list sub-result)
|
|
|
|
?: =(lobes.rov new-lobes)
|
|
|
|
~
|
2020-07-23 07:57:44 +03:00
|
|
|
[%bleb ver +(u.from-aeon) ?:(track.rov ~ `[u.from-aeon u.to-aeon])]~
|
2019-05-23 00:39:12 +03:00
|
|
|
:: end subscription
|
|
|
|
::
|
|
|
|
=/ blub=(list sub-result)
|
|
|
|
[%blub ~]~
|
|
|
|
(weld bleb blub)
|
2016-11-24 07:25:07 +03:00
|
|
|
==
|
2019-05-23 00:39:12 +03:00
|
|
|
::
|
2016-11-24 07:25:07 +03:00
|
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
|
|
::
|
|
|
|
:: This core has no additional state, and the distinction exists purely for
|
|
|
|
:: documentation. The overarching theme is that `++de` directly contains
|
|
|
|
:: logic for metadata about the desk, while `++ze` is composed primarily
|
|
|
|
:: of helper functions for manipulating the desk state (`++dome`) itself.
|
|
|
|
:: Functions include:
|
|
|
|
::
|
|
|
|
:: -- converting between cases, commit hashes, commits, content hashes,
|
|
|
|
:: and content
|
|
|
|
:: -- creating commits and content and adding them to the tree
|
|
|
|
:: -- finding which data needs to be sent over the network to keep the
|
2018-02-08 00:28:33 +03:00
|
|
|
:: other urbit up-to-date
|
2016-11-24 07:25:07 +03:00
|
|
|
:: -- reading from the file tree through different `++care` options
|
|
|
|
:: -- the `++me` core for merging.
|
|
|
|
::
|
|
|
|
:: The dome is composed of the following:
|
|
|
|
::
|
|
|
|
:: -- `ank` is the ankh, which is the file data itself. An ankh is both
|
|
|
|
:: a possible file and a possible directory. An ankh has both:
|
|
|
|
:: -- `fil`, a possible file, stored as both a cage and its hash
|
|
|
|
:: -- `dir`, a map of @ta to more ankhs.
|
|
|
|
:: -- `let` is the number of the most recent revision.
|
|
|
|
:: -- `hit` is a map of revision numbers to commit hashes.
|
|
|
|
:: -- `lab` is a map of labels to revision numbers.
|
|
|
|
::
|
|
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
2019-05-14 08:20:46 +03:00
|
|
|
::
|
|
|
|
::
|
|
|
|
:: Other utility functions
|
|
|
|
::
|
2016-11-24 07:25:07 +03:00
|
|
|
++ ze
|
|
|
|
|%
|
|
|
|
:: These convert between aeon (version number), tako (commit hash), yaki
|
|
|
|
:: (commit data structure), lobe (content hash), and blob (content).
|
2019-07-18 00:57:01 +03:00
|
|
|
::
|
|
|
|
:: XX the following are duplicated from the +state core
|
|
|
|
::
|
2016-11-24 07:25:07 +03:00
|
|
|
++ aeon-to-tako ~(got by hit.dom)
|
2019-07-18 00:57:01 +03:00
|
|
|
++ aeon-to-yaki |=(=aeon (tako-to-yaki (aeon-to-tako aeon)))
|
2016-11-24 07:25:07 +03:00
|
|
|
++ lobe-to-blob ~(got by lat.ran)
|
|
|
|
++ tako-to-yaki ~(got by hut.ran)
|
2020-05-12 10:37:04 +03:00
|
|
|
++ lobe-to-mark
|
|
|
|
|= a/lobe
|
|
|
|
=> (lobe-to-blob a)
|
|
|
|
?- -
|
|
|
|
$delta p.q
|
|
|
|
$direct p.q
|
|
|
|
==
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
:: Checks whether two pieces of data (either cages or lobes) are the same.
|
|
|
|
::
|
|
|
|
++ equivalent-data
|
|
|
|
|= {one/(each cage lobe) two/(each cage lobe)}
|
|
|
|
^- ?
|
2018-03-19 06:54:47 +03:00
|
|
|
?: ?=(%& -.one)
|
|
|
|
?: ?=(%& -.two)
|
2016-11-24 07:25:07 +03:00
|
|
|
=([p q.q]:p.one [p q.q]:p.two)
|
|
|
|
=(p.two (page-to-lobe [p q.q]:p.one))
|
2018-03-19 06:54:47 +03:00
|
|
|
?: ?=(%& -.two)
|
2016-11-24 07:25:07 +03:00
|
|
|
=(p.one (page-to-lobe [p q.q]:p.two))
|
|
|
|
=(p.one p.two)
|
|
|
|
::
|
|
|
|
:: Gets a map of the data at the given path and all children of it.
|
|
|
|
::
|
|
|
|
++ lobes-at-path
|
2018-02-07 03:34:09 +03:00
|
|
|
|= {for/(unit ship) yon/aeon pax/path}
|
2016-11-24 07:25:07 +03:00
|
|
|
^- (map path lobe)
|
|
|
|
?: =(0 yon) ~
|
2018-02-09 15:00:12 +03:00
|
|
|
:: we use %z for the check because it looks at all child paths.
|
2019-05-23 04:15:57 +03:00
|
|
|
?. |(?=(~ for) (may-read u.for %z yon pax)) ~
|
2016-11-24 07:25:07 +03:00
|
|
|
%- malt
|
|
|
|
%+ skim
|
2018-04-04 21:15:10 +03:00
|
|
|
%~ tap by
|
2018-04-04 21:07:05 +03:00
|
|
|
=< q
|
|
|
|
%- aeon-to-yaki
|
|
|
|
yon
|
2016-11-24 07:25:07 +03:00
|
|
|
|= {p/path q/lobe}
|
2018-03-19 07:18:20 +03:00
|
|
|
?| ?=(~ pax)
|
|
|
|
?& !?=(~ p)
|
2016-11-24 07:25:07 +03:00
|
|
|
=(-.pax -.p)
|
|
|
|
$(p +.p, pax +.pax)
|
|
|
|
== ==
|
|
|
|
::
|
|
|
|
:: Creates a nako of all the changes between a and b.
|
|
|
|
::
|
|
|
|
++ make-nako
|
2020-07-23 07:57:44 +03:00
|
|
|
|= [ver=@ud a=aeon b=aeon]
|
2016-11-24 07:25:07 +03:00
|
|
|
^- nako
|
|
|
|
:+ ?> (lte b let.dom)
|
|
|
|
|-
|
|
|
|
?: =(b let.dom)
|
|
|
|
hit.dom
|
|
|
|
$(hit.dom (~(del by hit.dom) let.dom), let.dom (dec let.dom))
|
|
|
|
b
|
|
|
|
?: =(0 b)
|
|
|
|
[~ ~]
|
2020-07-23 07:57:44 +03:00
|
|
|
(data-twixt-takos =(0 ver) (~(get by hit.dom) a) (aeon-to-tako b))
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2020-05-12 10:37:04 +03:00
|
|
|
:: Traverse parentage and find all ancestor hashes
|
|
|
|
::
|
|
|
|
++ reachable-takos :: reachable
|
|
|
|
|= p/tako
|
|
|
|
^- (set tako)
|
2020-08-26 08:49:27 +03:00
|
|
|
~+
|
2020-06-19 04:56:31 +03:00
|
|
|
=| s=(set tako)
|
|
|
|
|- ^- (set tako)
|
|
|
|
=. s (~(put in s) p)
|
2020-05-12 10:37:04 +03:00
|
|
|
=+ y=(tako-to-yaki p)
|
2020-06-19 04:56:31 +03:00
|
|
|
|- ^- (set tako)
|
|
|
|
?~ p.y
|
|
|
|
s
|
|
|
|
?: (~(has in s) i.p.y)
|
|
|
|
$(p.y t.p.y)
|
|
|
|
=. s ^$(p i.p.y)
|
|
|
|
$(p.y t.p.y)
|
2020-05-12 10:37:04 +03:00
|
|
|
::
|
2016-11-24 07:25:07 +03:00
|
|
|
:: Gets the data between two commit hashes, assuming the first is an
|
|
|
|
:: ancestor of the second.
|
|
|
|
::
|
|
|
|
:: Get all the takos before `a`, then get all takos before `b` except the
|
|
|
|
:: ones we found before `a`. Then convert the takos to yakis and also get
|
|
|
|
:: all the data in all the yakis.
|
|
|
|
::
|
2020-07-23 07:57:44 +03:00
|
|
|
:: What happens if you run an %init merge on a desk that already
|
|
|
|
:: had a commit?
|
|
|
|
::
|
2016-11-24 07:25:07 +03:00
|
|
|
++ data-twixt-takos
|
2020-07-23 07:57:44 +03:00
|
|
|
|= [plops=? a=(unit tako) b=tako]
|
|
|
|
^- [(set yaki) (set plop)]
|
2020-05-12 10:37:04 +03:00
|
|
|
=+ old=?~(a ~ (reachable-takos u.a))
|
2020-07-23 07:57:44 +03:00
|
|
|
=/ yal=(set tako)
|
2016-11-24 07:25:07 +03:00
|
|
|
%- silt
|
|
|
|
%+ skip
|
2020-05-12 10:37:04 +03:00
|
|
|
~(tap in (reachable-takos b))
|
2020-07-23 07:57:44 +03:00
|
|
|
|=(tak=tako (~(has in old) tak))
|
2017-02-13 22:58:49 +03:00
|
|
|
:- (silt (turn ~(tap in yal) tako-to-yaki))
|
2020-07-23 07:57:44 +03:00
|
|
|
?. plops
|
|
|
|
~
|
2017-02-13 22:58:49 +03:00
|
|
|
(silt (turn ~(tap in (new-lobes (new-lobes ~ old) yal)) lobe-to-blob))
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
:: Get all the lobes that are referenced in `a` except those that are
|
|
|
|
:: already in `b`.
|
|
|
|
::
|
|
|
|
++ new-lobes :: object hash set
|
|
|
|
|= {b/(set lobe) a/(set tako)} :: that aren't in b
|
|
|
|
^- (set lobe)
|
2017-02-13 22:58:49 +03:00
|
|
|
%+ roll ~(tap in a)
|
2016-11-24 07:25:07 +03:00
|
|
|
|= {tak/tako bar/(set lobe)}
|
|
|
|
^- (set lobe)
|
|
|
|
=+ yak=(tako-to-yaki tak)
|
2017-02-13 23:43:18 +03:00
|
|
|
%+ roll ~(tap by q.yak)
|
2016-11-24 07:25:07 +03:00
|
|
|
=< .(far bar)
|
|
|
|
|= {{path lob/lobe} far/(set lobe)}
|
|
|
|
^- (set lobe)
|
|
|
|
?~ (~(has in b) lob) :: don't need
|
|
|
|
far
|
|
|
|
=+ gar=(lobe-to-blob lob)
|
|
|
|
?- -.gar
|
|
|
|
$direct (~(put in far) lob)
|
|
|
|
$delta (~(put in $(lob q.q.gar)) lob)
|
|
|
|
==
|
|
|
|
::
|
2020-04-16 05:10:22 +03:00
|
|
|
:: Probably can get rid of the cache checks because they happen in
|
|
|
|
:: ford
|
|
|
|
::
|
2020-04-16 03:47:45 +03:00
|
|
|
++ read-a
|
2020-06-20 10:45:53 +03:00
|
|
|
!.
|
2020-04-16 03:47:45 +03:00
|
|
|
|= [=aeon =path]
|
2020-04-19 11:58:12 +03:00
|
|
|
^- [(unit (unit (each cage lobe))) ford-cache]
|
2020-04-16 03:47:45 +03:00
|
|
|
?. =(aeon let.dom)
|
2020-04-19 11:58:12 +03:00
|
|
|
[~ fod.dom]
|
2020-04-16 05:10:22 +03:00
|
|
|
=/ cached=(unit [=vase *]) (~(get by vases.fod.dom) path)
|
|
|
|
?^ cached
|
2020-04-19 11:58:12 +03:00
|
|
|
:_(fod.dom [~ ~ %& %vase !>(vase.u.cached)])
|
2020-04-16 05:10:22 +03:00
|
|
|
=/ x (read-x aeon path)
|
|
|
|
?~ x
|
2020-04-19 11:58:12 +03:00
|
|
|
[~ fod.dom]
|
2020-04-16 05:10:22 +03:00
|
|
|
?~ u.x
|
2020-04-19 11:58:12 +03:00
|
|
|
[[~ ~] fod.dom]
|
2020-04-16 05:10:22 +03:00
|
|
|
:: should never happen at current aeon
|
|
|
|
?: ?=(%| -.u.u.x)
|
2020-04-19 11:58:12 +03:00
|
|
|
[~ fod.dom]
|
|
|
|
=^ =vase fod.dom
|
|
|
|
%- wrap:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
(build-file:(ford:fusion static-ford-args) path)
|
2020-04-19 11:58:12 +03:00
|
|
|
:_(fod.dom [~ ~ %& %vase !>(vase)])
|
2020-04-16 03:47:45 +03:00
|
|
|
::
|
|
|
|
++ read-b
|
2020-06-20 10:45:53 +03:00
|
|
|
!.
|
2020-04-16 03:47:45 +03:00
|
|
|
|= [=aeon =path]
|
2020-04-19 11:58:12 +03:00
|
|
|
^- [(unit (unit (each cage lobe))) ford-cache]
|
2020-04-16 03:47:45 +03:00
|
|
|
?. =(aeon let.dom)
|
2020-04-19 11:58:12 +03:00
|
|
|
[~ fod.dom]
|
2020-04-16 03:47:45 +03:00
|
|
|
?. ?=([@ ~] path)
|
2020-04-19 11:58:12 +03:00
|
|
|
[[~ ~] fod.dom]
|
2020-04-16 05:10:22 +03:00
|
|
|
=/ cached=(unit [=dais *]) (~(get by marks.fod.dom) i.path)
|
|
|
|
?^ cached
|
2020-04-19 11:58:12 +03:00
|
|
|
:_(fod.dom [~ ~ %& %dais !>(dais.u.cached)])
|
|
|
|
=^ =dais fod.dom
|
|
|
|
%- wrap:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
(get-mark:(ford:fusion static-ford-args) i.path)
|
2020-04-19 11:58:12 +03:00
|
|
|
:_(fod.dom [~ ~ %& %dais !>(dais)])
|
2020-04-16 03:47:45 +03:00
|
|
|
::
|
|
|
|
++ read-c
|
2020-06-20 10:45:53 +03:00
|
|
|
!.
|
2020-04-16 03:47:45 +03:00
|
|
|
|= [=aeon =path]
|
2020-04-19 11:58:12 +03:00
|
|
|
^- [(unit (unit (each cage lobe))) ford-cache]
|
2020-04-16 03:47:45 +03:00
|
|
|
?. =(aeon let.dom)
|
2020-04-19 11:58:12 +03:00
|
|
|
[~ fod.dom]
|
2020-04-16 03:47:45 +03:00
|
|
|
?. ?=([@ @ ~] path)
|
2020-04-19 11:58:12 +03:00
|
|
|
[[~ ~] fod.dom]
|
2020-04-16 05:10:22 +03:00
|
|
|
=/ cached=(unit [=tube *]) (~(get by casts.fod.dom) [i i.t]:path)
|
2020-04-16 22:00:03 +03:00
|
|
|
?^ cached
|
2020-04-19 11:58:12 +03:00
|
|
|
:_(fod.dom [~ ~ %& %tube !>(tube.u.cached)])
|
|
|
|
=^ =tube fod.dom
|
|
|
|
%- wrap:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
(get-cast:(ford:fusion static-ford-args) [i i.t]:path)
|
2020-04-19 11:58:12 +03:00
|
|
|
:_(fod.dom [~ ~ %& %tube !>(tube)])
|
2020-04-16 03:47:45 +03:00
|
|
|
::
|
2018-02-07 23:11:25 +03:00
|
|
|
:: Gets the permissions that apply to a particular node.
|
|
|
|
::
|
|
|
|
:: If the node has no permissions of its own, we use its parent's.
|
|
|
|
:: If no permissions have been set for the entire tree above the node,
|
|
|
|
:: we default to fully private (empty whitelist).
|
|
|
|
::
|
|
|
|
++ read-p
|
|
|
|
|= pax/path
|
|
|
|
^- (unit (unit (each cage lobe)))
|
|
|
|
=- [~ ~ %& %noun !>(-)]
|
|
|
|
:- (read-p-in pax per.red)
|
|
|
|
(read-p-in pax pew.red)
|
|
|
|
::
|
|
|
|
++ read-p-in
|
2018-02-12 19:56:48 +03:00
|
|
|
|= {pax/path pes/regs}
|
2018-02-07 23:11:25 +03:00
|
|
|
^- dict
|
2018-06-20 20:12:26 +03:00
|
|
|
=/ rul/(unit rule) (~(get by pes) pax)
|
2018-06-19 02:10:11 +03:00
|
|
|
?^ rul
|
|
|
|
:+ pax mod.u.rul
|
|
|
|
%- ~(rep in who.u.rul)
|
2018-06-20 01:27:16 +03:00
|
|
|
|= {w/whom out/(pair (set ship) (map @ta crew))}
|
2018-08-16 02:48:37 +03:00
|
|
|
?: ?=({%& @p} w)
|
2018-06-20 00:43:16 +03:00
|
|
|
[(~(put in p.out) +.w) q.out]
|
2018-06-20 20:12:26 +03:00
|
|
|
=/ cru/(unit crew) (~(get by cez.ruf) +.w)
|
2018-06-19 02:10:11 +03:00
|
|
|
?~ cru out
|
2018-06-20 00:43:16 +03:00
|
|
|
[p.out (~(put by q.out) +.w u.cru)]
|
|
|
|
?~ pax [/ %white ~ ~]
|
2018-02-13 21:45:24 +03:00
|
|
|
$(pax (scag (dec (lent pax)) `path`pax))
|
2018-02-07 23:04:07 +03:00
|
|
|
::
|
|
|
|
++ may-read
|
|
|
|
|= {who/ship car/care yon/aeon pax/path}
|
|
|
|
^- ?
|
|
|
|
?+ car
|
|
|
|
(allowed-by who pax per.red)
|
2018-02-07 23:11:25 +03:00
|
|
|
::
|
|
|
|
$p
|
|
|
|
=(who our)
|
2018-02-07 23:04:07 +03:00
|
|
|
::
|
|
|
|
?($y $z)
|
|
|
|
=+ tak=(~(get by hit.dom) yon)
|
|
|
|
?~ tak |
|
|
|
|
=+ yak=(tako-to-yaki u.tak)
|
|
|
|
=+ len=(lent pax)
|
2018-02-09 02:35:42 +03:00
|
|
|
=- (levy ~(tap in -) |=(p/path (allowed-by who p per.red)))
|
|
|
|
%+ roll ~(tap in (~(del in ~(key by q.yak)) pax))
|
|
|
|
|= {p/path s/(set path)}
|
|
|
|
?. =(pax (scag len p)) s
|
|
|
|
%- ~(put in s)
|
|
|
|
?: ?=($z car) p
|
|
|
|
(scag +(len) p)
|
2018-02-07 23:04:07 +03:00
|
|
|
==
|
|
|
|
::
|
|
|
|
++ may-write
|
|
|
|
|= {w/ship p/path}
|
|
|
|
(allowed-by w p pew.red)
|
|
|
|
::
|
|
|
|
++ allowed-by
|
2018-02-12 19:56:48 +03:00
|
|
|
|= {who/ship pax/path pes/regs}
|
2018-02-07 23:04:07 +03:00
|
|
|
^- ?
|
2018-06-20 20:12:26 +03:00
|
|
|
=/ rul/real rul:(read-p-in pax pes)
|
|
|
|
=/ in-list/?
|
2018-06-20 00:43:16 +03:00
|
|
|
?| (~(has in p.who.rul) who)
|
2018-06-20 01:27:16 +03:00
|
|
|
::
|
2018-06-20 00:43:16 +03:00
|
|
|
%- ~(rep by q.who.rul)
|
2018-06-20 20:12:26 +03:00
|
|
|
|= {{@ta cru/crew} out/_|}
|
2018-06-20 00:43:16 +03:00
|
|
|
?: out &
|
|
|
|
(~(has in cru) who)
|
|
|
|
==
|
2018-06-19 02:10:11 +03:00
|
|
|
?: =(%black mod.rul)
|
|
|
|
!in-list
|
|
|
|
in-list
|
2020-03-28 06:37:22 +03:00
|
|
|
:: +content-hash: get hash of contents (%cz hash)
|
|
|
|
::
|
|
|
|
++ content-hash
|
|
|
|
|= [=yaki pax=path]
|
|
|
|
^- @uvI
|
|
|
|
=+ len=(lent pax)
|
|
|
|
=/ descendants/(list (pair path lobe))
|
|
|
|
%+ turn
|
|
|
|
%+ skim ~(tap by (~(del by q.yaki) pax))
|
|
|
|
|= {paf/path lob/lobe}
|
|
|
|
=(pax (scag len paf))
|
|
|
|
|= {paf/path lob/lobe}
|
|
|
|
[(slag len paf) lob]
|
|
|
|
=+ us=(~(get by q.yaki) pax)
|
|
|
|
?: &(?=(~ descendants) ?=(~ us))
|
|
|
|
*@uvI
|
|
|
|
%+ roll
|
|
|
|
^- (list (pair path lobe))
|
|
|
|
[[~ ?~(us *lobe u.us)] descendants]
|
|
|
|
|=({{path lobe} @uvI} (shax (jam +<)))
|
2020-05-14 05:28:04 +03:00
|
|
|
:: +read-r: %x wrapped in a vase
|
|
|
|
::
|
|
|
|
++ read-r
|
|
|
|
|= [yon=aeon pax=path]
|
|
|
|
^- (unit (unit cage))
|
|
|
|
=/ x (read-x yon pax)
|
|
|
|
?~ x ~
|
|
|
|
?~ u.x [~ ~]
|
|
|
|
?> ?=(%& -.u.u.x)
|
|
|
|
``[p.p.u.u.x !>(q.p.u.u.x)]
|
2020-03-26 06:12:05 +03:00
|
|
|
:: +read-s: produce yaki or blob for given tako or lobe
|
2020-03-21 01:30:52 +03:00
|
|
|
::
|
|
|
|
++ read-s
|
|
|
|
|= [yon=aeon pax=path]
|
2020-03-28 06:37:22 +03:00
|
|
|
^- (unit (unit cage))
|
2020-08-26 06:25:39 +03:00
|
|
|
?. ?=([?(%yaki %blob %hash %cage %open %late %base) * *] pax)
|
2020-03-21 01:30:52 +03:00
|
|
|
`~
|
2020-03-28 06:37:22 +03:00
|
|
|
?- i.pax
|
|
|
|
%yaki
|
2020-03-26 06:12:05 +03:00
|
|
|
=/ yak=(unit yaki) (~(get by hut.ran) (slav %uv i.t.pax))
|
|
|
|
?~ yak
|
|
|
|
~
|
|
|
|
``yaki+[-:!>(*yaki) u.yak]
|
2020-03-28 06:37:22 +03:00
|
|
|
::
|
|
|
|
%blob
|
|
|
|
=/ bol=(unit blob) (~(get by lat.ran) (slav %uv i.t.pax))
|
|
|
|
?~ bol
|
|
|
|
~
|
|
|
|
``blob+[-:!>(*blob) u.bol]
|
|
|
|
::
|
|
|
|
%hash
|
|
|
|
=/ yak=(unit yaki) (~(get by hut.ran) (slav %uv i.t.pax))
|
|
|
|
?~ yak
|
|
|
|
~
|
|
|
|
``uvi+[-:!>(*@uvI) (content-hash u.yak /)]
|
2020-05-01 05:32:48 +03:00
|
|
|
::
|
|
|
|
%cage
|
|
|
|
:: should save ford cache
|
|
|
|
::
|
|
|
|
=/ =lobe (slav %uv i.t.pax)
|
|
|
|
=^ =page fod.dom
|
|
|
|
%- wrap:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
(lobe-to-page:(ford:fusion static-ford-args) lobe)
|
2020-05-01 05:32:48 +03:00
|
|
|
=^ =cage fod.dom
|
|
|
|
%- wrap:fusion
|
2020-06-02 06:52:20 +03:00
|
|
|
(page-to-cage:(ford:fusion static-ford-args) page)
|
2020-05-01 05:32:48 +03:00
|
|
|
``cage+[-:!>(*^cage) cage]
|
2020-05-14 09:26:52 +03:00
|
|
|
::
|
|
|
|
%open
|
2020-06-02 06:52:20 +03:00
|
|
|
``open+!>(prelude:(ford:fusion static-ford-args))
|
2020-05-23 00:32:32 +03:00
|
|
|
::
|
2020-07-21 22:03:30 +03:00
|
|
|
%late !! :: handled in +aver
|
2020-08-26 06:25:39 +03:00
|
|
|
%base
|
|
|
|
?> ?=(^ t.t.pax)
|
|
|
|
:^ ~ ~ %uvs !>
|
|
|
|
^- (list @uv)
|
|
|
|
=/ him (slav %p i.t.pax)
|
|
|
|
=/ other dom:((de our now ski hen ruf) him i.t.t.pax)
|
|
|
|
?: =(0 let.other)
|
|
|
|
~
|
|
|
|
=/ our-yaki (~(got by hut.ran) (~(got by hit.dom) yon))
|
|
|
|
=/ other-yaki (~(got by hut.ran) (~(got by hit.other) let.other))
|
|
|
|
%+ turn ~(tap in (find-merge-points other-yaki our-yaki))
|
|
|
|
|= =yaki
|
|
|
|
r.yaki
|
2020-03-28 06:37:22 +03:00
|
|
|
==
|
2018-08-22 22:56:46 +03:00
|
|
|
:: +read-t: produce the list of paths within a yaki with :pax as prefix
|
|
|
|
::
|
|
|
|
++ read-t
|
|
|
|
|= [yon=aeon pax=path]
|
|
|
|
^- (unit (unit [%file-list (hypo (list path))]))
|
|
|
|
:: if asked for version 0, produce an empty list of files
|
|
|
|
::
|
|
|
|
?: =(0 yon)
|
|
|
|
``[%file-list -:!>(*(list path)) *(list path)]
|
|
|
|
:: if asked for a future version, we don't have an answer
|
|
|
|
::
|
|
|
|
?~ tak=(~(get by hit.dom) yon)
|
|
|
|
~
|
|
|
|
:: look up the yaki snapshot based on the version
|
|
|
|
::
|
|
|
|
=/ yak=yaki (tako-to-yaki u.tak)
|
|
|
|
:: calculate the path length once outside the loop
|
|
|
|
::
|
|
|
|
=/ path-length (lent pax)
|
|
|
|
::
|
|
|
|
:^ ~ ~ %file-list
|
|
|
|
:- -:!>(*(list path))
|
|
|
|
^- (list path)
|
|
|
|
:: sort the matching paths alphabetically
|
|
|
|
::
|
|
|
|
=- (sort - aor)
|
|
|
|
:: traverse the filesystem, filtering for paths with :pax as prefix
|
|
|
|
::
|
|
|
|
%+ skim ~(tap in ~(key by q.yak))
|
|
|
|
|=(paf=path =(pax (scag path-length paf)))
|
2018-02-07 23:04:07 +03:00
|
|
|
::
|
2016-11-24 07:25:07 +03:00
|
|
|
:: Checks for existence of a node at an aeon.
|
|
|
|
::
|
|
|
|
:: This checks for existence of content at the node, and does *not* look
|
|
|
|
:: at any of its children.
|
|
|
|
::
|
|
|
|
++ read-u
|
2019-12-18 19:00:02 +03:00
|
|
|
|= [yon=aeon pax=path]
|
|
|
|
^- (unit (unit (each [%flag (hypo ?)] lobe)))
|
|
|
|
:: if asked for a future version, we don't have an answer
|
|
|
|
::
|
|
|
|
?~ tak=(~(get by hit.dom) yon)
|
2016-11-24 07:25:07 +03:00
|
|
|
~
|
2019-12-18 19:00:02 +03:00
|
|
|
:: look up the yaki snapshot based on the version
|
|
|
|
::
|
|
|
|
=/ yak=yaki (tako-to-yaki u.tak)
|
|
|
|
:: produce the result based on whether or not there's a file at :pax
|
|
|
|
::
|
|
|
|
``[%& %flag -:!>(*?) (~(has by q.yak) pax)]
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
:: Gets the dome (desk state) at a particular aeon.
|
|
|
|
::
|
|
|
|
:: For past aeons, we don't give an actual ankh in the dome, but the rest
|
2018-10-04 21:37:42 +03:00
|
|
|
:: of the data is legit. We also never send the mime cache over the wire.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
++ read-v
|
|
|
|
|= {yon/aeon pax/path}
|
2018-10-04 21:37:42 +03:00
|
|
|
^- (unit (unit {$dome (hypo dome:clay)}))
|
2016-11-24 07:25:07 +03:00
|
|
|
?: (lth yon let.dom)
|
2020-06-25 07:13:31 +03:00
|
|
|
:* ~ ~ %dome -:!>(*dome:clay)
|
2018-10-04 21:37:42 +03:00
|
|
|
^- dome:clay
|
|
|
|
:* ank=`[[%ank-in-old-v-not-implemented *ankh] ~ ~]
|
|
|
|
let=yon
|
|
|
|
hit=(molt (skim ~(tap by hit.dom) |=({p/@ud *} (lte p yon))))
|
|
|
|
lab=(molt (skim ~(tap by lab.dom) |=({* p/@ud} (lte p yon))))
|
|
|
|
== ==
|
2016-11-24 07:25:07 +03:00
|
|
|
?: (gth yon let.dom)
|
|
|
|
~
|
2018-10-04 21:37:42 +03:00
|
|
|
``[%dome -:!>(*dome:clay) [ank let hit lab]:dom]
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2018-05-03 00:37:03 +03:00
|
|
|
:: Gets all cases refering to the same revision as the given case.
|
|
|
|
::
|
|
|
|
:: For the %da case, we give just the canonical timestamp of the revision.
|
|
|
|
::
|
|
|
|
++ read-w
|
|
|
|
|= cas/case
|
|
|
|
^- (unit (unit (each cage lobe)))
|
2019-05-04 05:24:24 +03:00
|
|
|
=+ aey=(case-to-aeon cas)
|
2018-05-03 00:37:03 +03:00
|
|
|
?~ aey ~
|
|
|
|
=- [~ ~ %& %cass !>(-)]
|
|
|
|
^- cass
|
|
|
|
:- u.aey
|
|
|
|
?: =(0 u.aey) `@da`0
|
|
|
|
t:(aeon-to-yaki u.aey)
|
|
|
|
::
|
2020-05-12 10:37:04 +03:00
|
|
|
:: Get the data at a node.
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2020-05-12 10:37:04 +03:00
|
|
|
:: If it's in our ankh (current state cache), we can just produce
|
|
|
|
:: the result. Otherwise, we've got to look up the node at the
|
|
|
|
:: aeon to get the content hash, use that to find the blob, and use
|
|
|
|
:: the blob to get the data. We also special-case the hoon mark
|
|
|
|
:: for bootstrapping purposes.
|
|
|
|
::
|
|
|
|
++ read-x
|
|
|
|
|= [yon=aeon pax=path]
|
|
|
|
^- (unit (unit (each cage lobe)))
|
|
|
|
?: =(0 yon)
|
|
|
|
[~ ~]
|
|
|
|
=+ tak=(~(get by hit.dom) yon)
|
|
|
|
?~ tak
|
|
|
|
~
|
|
|
|
?: &(?=(~ ref) =(yon let.dom))
|
|
|
|
:- ~
|
|
|
|
%+ bind
|
|
|
|
fil.ank:(descend-path:(zu ank.dom) pax)
|
|
|
|
|=(a/{p/lobe q/cage} [%& q.a])
|
|
|
|
=+ yak=(tako-to-yaki u.tak)
|
|
|
|
=+ lob=(~(get by q.yak) pax)
|
|
|
|
?~ lob
|
|
|
|
[~ ~]
|
|
|
|
=+ mar=(lobe-to-mark u.lob)
|
|
|
|
:: should convert any lobe to cage
|
|
|
|
::
|
|
|
|
?. ?=($hoon mar)
|
|
|
|
[~ ~ %| u.lob]
|
|
|
|
:^ ~ ~ %&
|
|
|
|
:+ mar [%atom %t ~]
|
|
|
|
|- ^- @t :: (urge cord) would be faster
|
|
|
|
=+ bol=(lobe-to-blob u.lob)
|
|
|
|
?: ?=($direct -.bol)
|
|
|
|
;;(@t q.q.bol)
|
|
|
|
?> ?=($delta -.bol)
|
|
|
|
=+ txt=$(u.lob q.q.bol)
|
|
|
|
?> ?=($txt-diff p.r.bol)
|
|
|
|
=+ dif=;;((urge cord) q.r.bol)
|
|
|
|
=, format
|
|
|
|
=+ pac=(of-wain (lurk:differ (to-wain (cat 3 txt '\0a')) dif))
|
2020-06-03 07:50:20 +03:00
|
|
|
?~ pac
|
|
|
|
''
|
2020-05-12 10:37:04 +03:00
|
|
|
(end 3 (dec (met 3 pac)) pac)
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
:: Gets an arch (directory listing) at a node.
|
|
|
|
::
|
|
|
|
++ read-y
|
|
|
|
|= {yon/aeon pax/path}
|
|
|
|
^- (unit (unit {$arch (hypo arch)}))
|
|
|
|
?: =(0 yon)
|
|
|
|
``[%arch -:!>(*arch) *arch]
|
|
|
|
=+ tak=(~(get by hit.dom) yon)
|
|
|
|
?~ tak
|
|
|
|
~
|
|
|
|
=+ yak=(tako-to-yaki u.tak)
|
|
|
|
=+ len=(lent pax)
|
|
|
|
:^ ~ ~ %arch
|
|
|
|
:: ~& cy+pax
|
|
|
|
:- -:!>(*arch)
|
|
|
|
^- arch
|
|
|
|
:- (~(get by q.yak) pax)
|
2018-03-19 07:18:20 +03:00
|
|
|
^- (map knot ~)
|
|
|
|
%- molt ^- (list (pair knot ~))
|
2016-11-24 07:25:07 +03:00
|
|
|
%+ turn
|
|
|
|
^- (list (pair path lobe))
|
2017-02-13 23:43:18 +03:00
|
|
|
%+ skim ~(tap by (~(del by q.yak) pax))
|
2016-11-24 07:25:07 +03:00
|
|
|
|= {paf/path lob/lobe}
|
|
|
|
=(pax (scag len paf))
|
|
|
|
|= {paf/path lob/lobe}
|
|
|
|
=+ pat=(slag len paf)
|
|
|
|
[?>(?=(^ pat) i.pat) ~]
|
|
|
|
::
|
|
|
|
:: Gets a recursive hash of a node and all its children.
|
|
|
|
::
|
|
|
|
++ read-z
|
|
|
|
|= {yon/aeon pax/path}
|
|
|
|
^- (unit (unit {$uvi (hypo @uvI)}))
|
|
|
|
?: =(0 yon)
|
|
|
|
``uvi+[-:!>(*@uvI) *@uvI]
|
|
|
|
=+ tak=(~(get by hit.dom) yon)
|
|
|
|
?~ tak
|
|
|
|
~
|
2020-03-28 06:37:22 +03:00
|
|
|
[~ ~ %uvi -:!>(*@uvI) (content-hash (tako-to-yaki u.tak) pax)]
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
:: Get a value at an aeon.
|
|
|
|
::
|
2019-05-23 00:39:12 +03:00
|
|
|
:: Value can be either null, meaning we don't have it yet, [null null],
|
|
|
|
:: meaning we know it doesn't exist, or [null null (each cage lobe)],
|
2016-11-24 07:25:07 +03:00
|
|
|
:: meaning we either have the value directly or a content hash of the
|
|
|
|
:: value.
|
|
|
|
::
|
|
|
|
++ read-at-aeon :: read-at-aeon:ze
|
2019-05-03 04:50:20 +03:00
|
|
|
|= [for=(unit ship) yon=aeon mun=mood] :: seek and read
|
2020-04-19 11:58:12 +03:00
|
|
|
^- [(unit (unit (each cage lobe))) ford-cache]
|
|
|
|
=* fod fod.dom
|
2019-05-23 00:39:12 +03:00
|
|
|
?. |(?=(~ for) (may-read u.for care.mun yon path.mun))
|
2020-04-19 11:58:12 +03:00
|
|
|
[~ fod]
|
2020-05-20 03:28:24 +03:00
|
|
|
:: virtualize to catch and produce deterministic failures
|
|
|
|
::
|
2020-06-20 10:45:53 +03:00
|
|
|
!.
|
2020-05-20 03:28:24 +03:00
|
|
|
=- ?:(?=(%& -<) p.- ((slog p.-) [[~ ~] fod]))
|
|
|
|
%- mule |.
|
2019-05-23 00:39:12 +03:00
|
|
|
?- care.mun
|
2019-05-03 04:50:20 +03:00
|
|
|
%d
|
2020-04-19 11:58:12 +03:00
|
|
|
:_ fod
|
2019-05-03 04:50:20 +03:00
|
|
|
:: XX this should only allow reads at the current date
|
2018-12-13 10:42:15 +03:00
|
|
|
::
|
|
|
|
?: !=(our her)
|
|
|
|
[~ ~]
|
2019-05-23 00:39:12 +03:00
|
|
|
?^ path.mun
|
2017-01-04 10:08:40 +03:00
|
|
|
~&(%no-cd-path [~ ~])
|
2018-12-13 10:42:15 +03:00
|
|
|
[~ ~ %& %noun !>(~(key by dos.rom.ruf))]
|
2018-05-03 00:40:21 +03:00
|
|
|
::
|
2020-04-16 03:47:45 +03:00
|
|
|
%a (read-a yon path.mun)
|
|
|
|
%b (read-b yon path.mun)
|
|
|
|
%c (read-c yon path.mun)
|
2020-04-19 11:58:12 +03:00
|
|
|
%p :_(fod (read-p path.mun))
|
2020-05-14 05:28:04 +03:00
|
|
|
%r :_(fod (bind (read-r yon path.mun) (lift |=(a=cage [%& a]))))
|
2020-04-19 11:58:12 +03:00
|
|
|
%s :_(fod (bind (read-s yon path.mun) (lift |=(a=cage [%& a]))))
|
|
|
|
%t :_(fod (bind (read-t yon path.mun) (lift |=(a=cage [%& a]))))
|
|
|
|
%u :_(fod (read-u yon path.mun))
|
|
|
|
%v :_(fod (bind (read-v yon path.mun) (lift |=(a/cage [%& a]))))
|
|
|
|
%w :_(fod (read-w case.mun))
|
|
|
|
%x :_(fod (read-x yon path.mun))
|
|
|
|
%y :_(fod (bind (read-y yon path.mun) (lift |=(a/cage [%& a]))))
|
|
|
|
%z :_(fod (bind (read-z yon path.mun) (lift |=(a/cage [%& a]))))
|
2018-05-03 00:40:21 +03:00
|
|
|
==
|
2020-05-12 10:37:04 +03:00
|
|
|
:: Traverse an ankh.
|
|
|
|
::
|
|
|
|
++ zu :: filesystem
|
|
|
|
|= ank/ankh :: filesystem state
|
|
|
|
=| ram/path :: reverse path into
|
|
|
|
|%
|
|
|
|
++ descend :: descend
|
|
|
|
|= lol/@ta
|
|
|
|
^+ +>
|
|
|
|
=+ you=(~(get by dir.ank) lol)
|
|
|
|
+>.$(ram [lol ram], ank ?~(you [~ ~] u.you))
|
|
|
|
::
|
|
|
|
++ descend-path :: descend recursively
|
|
|
|
|= way/path
|
|
|
|
^+ +>
|
|
|
|
?~(way +> $(way t.way, +> (descend i.way)))
|
|
|
|
--
|
2016-11-24 07:25:07 +03:00
|
|
|
--
|
|
|
|
--
|
|
|
|
--
|
|
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
|
|
:: section 4cA, filesystem vane
|
|
|
|
::
|
|
|
|
:: This is the arvo interface vane. Our formal state is a `++raft`, which
|
|
|
|
:: has five components:
|
|
|
|
::
|
2018-12-13 10:42:15 +03:00
|
|
|
:: -- `rom` is the state for all local desks.
|
2016-11-24 07:25:07 +03:00
|
|
|
:: -- `hoy` is the state for all foreign desks.
|
|
|
|
:: -- `ran` is the global, hash-addressed object store.
|
|
|
|
:: -- `mon` is the set of mount points in unix.
|
|
|
|
:: -- `hez` is the duct to the unix sync.
|
|
|
|
::
|
|
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
|
|
=| :: instrument state
|
2020-08-28 10:24:25 +03:00
|
|
|
$: ver=%5 :: vane version
|
2019-02-02 00:46:09 +03:00
|
|
|
ruf=raft :: revision tree
|
2016-11-24 07:25:07 +03:00
|
|
|
== ::
|
2018-12-06 00:41:21 +03:00
|
|
|
|= [our=ship now=@da eny=@uvJ ski=sley] :: current invocation
|
2016-11-24 07:25:07 +03:00
|
|
|
|% ::
|
|
|
|
++ call :: handle request
|
2018-12-04 00:22:39 +03:00
|
|
|
|= $: hen=duct
|
2020-02-11 01:03:03 +03:00
|
|
|
dud=(unit goof)
|
2018-12-04 00:22:39 +03:00
|
|
|
type=*
|
|
|
|
wrapped-task=(hobo task:able)
|
2016-11-24 07:25:07 +03:00
|
|
|
==
|
2019-05-11 00:51:37 +03:00
|
|
|
^- [(list move) _..^$]
|
2018-12-04 00:22:39 +03:00
|
|
|
::
|
2020-01-21 02:01:36 +03:00
|
|
|
=/ req=task:able ((harden task:able) wrapped-task)
|
2020-02-24 22:09:37 +03:00
|
|
|
::
|
|
|
|
:: error notifications "downcast" to %crud
|
|
|
|
::
|
|
|
|
=? req ?=(^ dud)
|
|
|
|
~| %crud-in-crud
|
|
|
|
?< ?=(%crud -.req)
|
|
|
|
[%crud -.req tang.u.dud]
|
|
|
|
::
|
2018-02-09 15:33:15 +03:00
|
|
|
?- -.req
|
2019-05-11 00:51:37 +03:00
|
|
|
%boat
|
2016-11-24 07:25:07 +03:00
|
|
|
:_ ..^$
|
2017-02-13 23:43:18 +03:00
|
|
|
[hen %give %hill (turn ~(tap by mon.ruf) head)]~
|
2019-07-25 01:54:45 +03:00
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%cred
|
2018-02-07 23:07:42 +03:00
|
|
|
=. cez.ruf
|
2018-02-09 15:33:15 +03:00
|
|
|
?~ cew.req (~(del by cez.ruf) nom.req)
|
|
|
|
(~(put by cez.ruf) nom.req cew.req)
|
2018-02-07 23:07:42 +03:00
|
|
|
:: wake all desks, a request may have been affected.
|
|
|
|
=| mos/(list move)
|
2018-12-13 10:42:15 +03:00
|
|
|
=/ des ~(tap in ~(key by dos.rom.ruf))
|
2018-02-07 23:07:42 +03:00
|
|
|
|-
|
2019-06-29 02:43:52 +03:00
|
|
|
?~ des [[[hen %give %done ~] mos] ..^^$]
|
2019-02-02 00:46:09 +03:00
|
|
|
=/ den ((de our now ski hen ruf) our i.des)
|
2018-02-12 18:02:32 +03:00
|
|
|
=^ mor ruf
|
|
|
|
=< abet:wake
|
|
|
|
?: ?=(^ cew.req) den
|
|
|
|
(forget-crew:den nom.req)
|
2018-02-07 23:07:42 +03:00
|
|
|
$(des t.des, mos (weld mos mor))
|
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%crew
|
2018-02-07 23:07:42 +03:00
|
|
|
[[hen %give %cruz cez.ruf]~ ..^$]
|
2018-02-12 19:57:59 +03:00
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%crow
|
2018-12-13 10:42:15 +03:00
|
|
|
=/ des ~(tap by dos.rom.ruf)
|
2018-02-12 19:57:59 +03:00
|
|
|
=| rus/(map desk {r/regs w/regs})
|
|
|
|
|^
|
|
|
|
?~ des [[hen %give %croz rus]~ ..^^$]
|
|
|
|
=+ per=(filter-rules per.q.i.des)
|
|
|
|
=+ pew=(filter-rules pew.q.i.des)
|
2018-02-13 21:47:44 +03:00
|
|
|
=? rus |(?=(^ per) ?=(^ pew))
|
|
|
|
(~(put by rus) p.i.des per pew)
|
|
|
|
$(des t.des)
|
2018-02-12 19:57:59 +03:00
|
|
|
::
|
|
|
|
++ filter-rules
|
|
|
|
|= pes/regs
|
|
|
|
^+ pes
|
|
|
|
=- (~(gas in *regs) -)
|
2018-02-13 21:47:44 +03:00
|
|
|
%+ skim ~(tap by pes)
|
2018-02-12 19:57:59 +03:00
|
|
|
|= {p/path r/rule}
|
2018-02-13 21:47:44 +03:00
|
|
|
(~(has in who.r) |+nom.req)
|
2018-02-12 19:57:59 +03:00
|
|
|
--
|
2018-11-23 20:19:23 +03:00
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%crud
|
2018-11-23 20:19:23 +03:00
|
|
|
[[[hen %slip %d %flog req] ~] ..^$]
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%drop
|
2020-05-12 12:09:41 +03:00
|
|
|
~& %clay-idle
|
|
|
|
[~ ..^$]
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%info
|
2020-05-12 05:26:22 +03:00
|
|
|
?: ?=(%| -.dit.req)
|
|
|
|
~| %labelling-not-implemented
|
|
|
|
!!
|
|
|
|
=/ [deletes=(set path) changes=(map path cage)]
|
|
|
|
=/ =soba p.dit.req
|
|
|
|
=| deletes=(set path)
|
|
|
|
=| changes=(map path cage)
|
|
|
|
|- ^+ [deletes changes]
|
|
|
|
?~ soba
|
|
|
|
[deletes changes]
|
|
|
|
?- -.q.i.soba
|
|
|
|
%del $(soba t.soba, deletes (~(put in deletes) p.i.soba))
|
|
|
|
%ins $(soba t.soba, changes (~(put by changes) [p p.q]:i.soba))
|
|
|
|
%mut $(soba t.soba, changes (~(put by changes) [p p.q]:i.soba))
|
|
|
|
%dif ~|(%dif-not-implemented !!)
|
|
|
|
==
|
2016-11-24 07:25:07 +03:00
|
|
|
=^ mos ruf
|
2019-05-11 00:51:37 +03:00
|
|
|
=/ den ((de our now ski hen ruf) our des.req)
|
2020-05-12 05:26:22 +03:00
|
|
|
abet:(info:den deletes changes)
|
2016-11-24 07:25:07 +03:00
|
|
|
[mos ..^$]
|
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%init
|
2018-12-13 10:42:15 +03:00
|
|
|
[~ ..^$(hun.rom.ruf hen)]
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%into
|
2016-11-24 07:25:07 +03:00
|
|
|
=. hez.ruf `hen
|
2018-02-09 16:48:08 +03:00
|
|
|
=+ bem=(~(get by mon.ruf) des.req)
|
2018-08-16 02:48:37 +03:00
|
|
|
?: &(?=(~ bem) !=(%$ des.req))
|
2018-02-09 16:48:08 +03:00
|
|
|
~|([%bad-mount-point-from-unix des.req] !!)
|
2019-12-18 03:48:08 +03:00
|
|
|
=/ bem/beam
|
2016-11-24 07:25:07 +03:00
|
|
|
?^ bem
|
|
|
|
u.bem
|
2020-05-22 09:05:42 +03:00
|
|
|
[[our %home %ud 1] ~]
|
2018-12-13 10:42:15 +03:00
|
|
|
=/ dos (~(get by dos.rom.ruf) q.bem)
|
2016-11-24 07:25:07 +03:00
|
|
|
?~ dos
|
2019-05-11 05:23:13 +03:00
|
|
|
!! :: fire next in queue
|
2020-04-24 03:12:23 +03:00
|
|
|
=^ mos ruf
|
2020-04-29 04:13:30 +03:00
|
|
|
=/ den ((de our now ski hen ruf) our q.bem)
|
2020-11-24 04:20:36 +03:00
|
|
|
abet:(into:den s.bem all.req fis.req)
|
2020-04-24 03:12:23 +03:00
|
|
|
[mos ..^$]
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%merg :: direct state up
|
2018-02-09 16:48:08 +03:00
|
|
|
?: =(%$ des.req)
|
2019-05-03 04:06:31 +03:00
|
|
|
~&(%merg-no-desk !!)
|
2016-11-24 07:25:07 +03:00
|
|
|
=^ mos ruf
|
2019-05-11 00:51:37 +03:00
|
|
|
=/ den ((de our now ski hen ruf) our des.req)
|
2020-05-12 10:01:46 +03:00
|
|
|
abet:(start-merge:den her.req dem.req cas.req how.req)
|
2016-11-24 07:25:07 +03:00
|
|
|
[mos ..^$]
|
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%mont
|
2016-11-24 07:25:07 +03:00
|
|
|
=. hez.ruf ?^(hez.ruf hez.ruf `[[%$ %sync ~] ~])
|
|
|
|
=^ mos ruf
|
2019-05-18 00:59:03 +03:00
|
|
|
=/ den ((de our now ski hen ruf) p.bem.req q.bem.req)
|
2020-05-12 11:27:19 +03:00
|
|
|
abet:(mount:den pot.req r.bem.req s.bem.req)
|
2016-11-24 07:25:07 +03:00
|
|
|
[mos ..^$]
|
2017-01-12 18:50:35 +03:00
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%dirk
|
2017-01-12 18:50:35 +03:00
|
|
|
?~ hez.ruf
|
|
|
|
~& %no-sync-duct
|
|
|
|
[~ ..^$]
|
2018-02-09 16:48:08 +03:00
|
|
|
?. (~(has by mon.ruf) des.req)
|
|
|
|
~& [%not-mounted des.req]
|
2017-01-12 18:50:35 +03:00
|
|
|
[~ ..^$]
|
2020-05-12 11:27:19 +03:00
|
|
|
[~[[u.hez.ruf %give %dirk des.req]] ..^$]
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%ogre
|
2016-11-24 07:25:07 +03:00
|
|
|
?~ hez.ruf
|
|
|
|
~& %no-sync-duct
|
|
|
|
[~ ..^$]
|
2018-02-09 16:48:08 +03:00
|
|
|
=* pot pot.req
|
|
|
|
?@ pot
|
|
|
|
?. (~(has by mon.ruf) pot)
|
|
|
|
~& [%not-mounted pot]
|
2016-11-24 07:25:07 +03:00
|
|
|
[~ ..^$]
|
2018-02-09 16:48:08 +03:00
|
|
|
:_ ..^$(mon.ruf (~(del by mon.ruf) pot))
|
|
|
|
[u.hez.ruf %give %ogre pot]~
|
2016-11-24 07:25:07 +03:00
|
|
|
:_ %_ ..^$
|
|
|
|
mon.ruf
|
|
|
|
%- molt
|
2017-02-13 23:43:18 +03:00
|
|
|
%+ skip ~(tap by mon.ruf)
|
2018-02-09 16:48:08 +03:00
|
|
|
(corl (cury test pot) tail)
|
2016-11-24 07:25:07 +03:00
|
|
|
==
|
|
|
|
%+ turn
|
2018-02-09 16:48:08 +03:00
|
|
|
(skim ~(tap by mon.ruf) (corl (cury test pot) tail))
|
|
|
|
|= {pon/term bem/beam}
|
|
|
|
[u.hez.ruf %give %ogre pon]
|
2020-03-21 01:30:52 +03:00
|
|
|
::
|
|
|
|
%park
|
|
|
|
=^ mos ruf
|
|
|
|
=/ den ((de our now ski hen ruf) our des.req)
|
2020-04-30 03:38:24 +03:00
|
|
|
abet:(park:den | [yok ran]:req)
|
2020-04-25 03:44:29 +03:00
|
|
|
[mos ..^$]
|
|
|
|
::
|
|
|
|
%pork
|
2020-04-30 03:38:24 +03:00
|
|
|
=/ [syd=desk =yoki] (need pud.ruf)
|
2020-04-25 03:44:29 +03:00
|
|
|
=. pud.ruf ~
|
|
|
|
=^ mos ruf
|
|
|
|
=/ den ((de our now ski hen ruf) our syd)
|
2020-04-30 03:38:24 +03:00
|
|
|
abet:(park:den & yoki *rang)
|
2020-03-21 01:30:52 +03:00
|
|
|
[mos ..^$]
|
2018-02-07 00:18:25 +03:00
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%perm
|
2018-02-07 00:18:25 +03:00
|
|
|
=^ mos ruf
|
2019-02-02 00:46:09 +03:00
|
|
|
=/ den ((de our now ski hen ruf) our des.req)
|
2018-02-09 15:33:15 +03:00
|
|
|
abet:(perm:den pax.req rit.req)
|
2018-02-07 00:18:25 +03:00
|
|
|
[mos ..^$]
|
2019-09-27 23:00:37 +03:00
|
|
|
::
|
|
|
|
%trim [~ ..^$]
|
2019-02-01 10:37:00 +03:00
|
|
|
::
|
2020-06-12 05:41:22 +03:00
|
|
|
%vega
|
|
|
|
:: wake all desks, then send pending notifications
|
|
|
|
::
|
|
|
|
=^ wake-moves ..^$
|
|
|
|
=/ desks=(list [=ship =desk])
|
|
|
|
%+ welp
|
|
|
|
(turn ~(tap by dos.rom.ruf) |=([=desk *] [our desk]))
|
|
|
|
%- zing
|
|
|
|
%+ turn ~(tap by hoy.ruf)
|
|
|
|
|= [=ship =rung]
|
|
|
|
%+ turn ~(tap by rus.rung)
|
|
|
|
|= [=desk *]
|
|
|
|
[ship desk]
|
|
|
|
|- ^+ [*(list move) ..^^$]
|
|
|
|
?~ desks
|
|
|
|
[~ ..^^$]
|
|
|
|
=^ moves-1 ..^^$ $(desks t.desks)
|
|
|
|
=^ moves-2 ruf abet:wake:((de our now ski hen ruf) [ship desk]:i.desks)
|
|
|
|
[(weld moves-1 moves-2) ..^^$]
|
|
|
|
[(welp wake-moves pun.ruf) ..^$(pun.ruf ~)]
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
?(%warp %werp)
|
2018-12-13 21:23:26 +03:00
|
|
|
:: capture whether this read is on behalf of another ship
|
|
|
|
:: for permissions enforcement
|
|
|
|
::
|
2018-02-09 15:33:15 +03:00
|
|
|
=^ for req
|
2019-05-11 00:51:37 +03:00
|
|
|
?: ?=(%warp -.req)
|
2018-02-09 15:33:15 +03:00
|
|
|
[~ req]
|
2020-07-23 07:57:44 +03:00
|
|
|
:: ?: =(our who.req)
|
|
|
|
:: [~ [%warp wer.req rif.req]]
|
|
|
|
=^ ver rif.req
|
|
|
|
?@ -.rif.req
|
|
|
|
[%0 rif.req]
|
|
|
|
[-<.rif.req +.rif.req]
|
|
|
|
?> ?=(@ -.rif.req)
|
|
|
|
:- ?:(=(our who.req) ~ `[who.req ver])
|
2018-12-13 21:23:26 +03:00
|
|
|
[%warp wer.req rif.req]
|
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
?> ?=(%warp -.req)
|
2018-02-09 16:48:08 +03:00
|
|
|
=* rif rif.req
|
2016-11-24 07:25:07 +03:00
|
|
|
=^ mos ruf
|
2019-02-02 00:46:09 +03:00
|
|
|
=/ den ((de our now ski hen ruf) wer.req p.rif)
|
2016-11-24 07:25:07 +03:00
|
|
|
=< abet
|
2018-02-09 15:25:46 +03:00
|
|
|
?~ q.rif
|
2016-11-24 07:25:07 +03:00
|
|
|
cancel-request:den
|
2018-02-09 15:25:46 +03:00
|
|
|
(start-request:den for u.q.rif)
|
2016-11-24 07:25:07 +03:00
|
|
|
[mos ..^$]
|
|
|
|
::
|
2019-07-29 09:37:49 +03:00
|
|
|
%plea
|
2019-06-29 02:43:52 +03:00
|
|
|
=* her ship.req
|
2019-07-29 09:37:49 +03:00
|
|
|
=* pax path.plea.req
|
|
|
|
=* res payload.plea.req
|
2019-06-29 02:43:52 +03:00
|
|
|
::
|
2020-07-23 11:36:38 +03:00
|
|
|
?: ?=([%backfill *] pax)
|
2020-07-23 07:57:44 +03:00
|
|
|
=+ ;;(=fill res)
|
|
|
|
=^ mos ruf
|
|
|
|
=/ den ((de our now ski hen ruf) our desk.fill)
|
|
|
|
abet:(give-backfill:den +.fill)
|
|
|
|
[[[hen %give %done ~] mos] ..^$]
|
|
|
|
?> ?=([%question *] pax)
|
|
|
|
=+ ryf=;;(riff-any res)
|
2019-06-29 02:43:52 +03:00
|
|
|
:_ ..^$
|
|
|
|
:~ [hen %give %done ~]
|
|
|
|
=/ =wire
|
|
|
|
[%foreign-warp (scot %p her) t.pax]
|
|
|
|
[hen %pass wire %c %werp her our ryf]
|
|
|
|
==
|
2016-11-24 07:25:07 +03:00
|
|
|
==
|
|
|
|
::
|
|
|
|
++ load
|
2020-11-25 18:22:20 +03:00
|
|
|
|= old=[%5 raft]
|
|
|
|
..^$(ruf +.old)
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
|
|
|
++ scry :: inspect
|
|
|
|
|= {fur/(unit (set monk)) ren/@tas why/shop syd/desk lot/coin tyl/path}
|
|
|
|
^- (unit (unit cage))
|
2018-03-19 06:54:47 +03:00
|
|
|
?. ?=(%& -.why) ~
|
2016-11-24 07:25:07 +03:00
|
|
|
=* his p.why
|
2020-05-07 11:51:08 +03:00
|
|
|
?: &(=(ren %$) =(tyl /whey))
|
|
|
|
``mass+!>(whey)
|
2016-11-24 07:25:07 +03:00
|
|
|
:: ~& scry+[ren `path`[(scot %p his) syd ~(rent co lot) tyl]]
|
|
|
|
:: =- ~& %scry-done -
|
2018-08-16 02:48:37 +03:00
|
|
|
=+ luk=?.(?=(%$ -.lot) ~ ((soft case) p.lot))
|
2016-11-24 07:25:07 +03:00
|
|
|
?~ luk [~ ~]
|
|
|
|
?: =(%$ ren)
|
|
|
|
[~ ~]
|
|
|
|
=+ run=((soft care) ren)
|
|
|
|
?~ run [~ ~]
|
2018-02-06 23:57:38 +03:00
|
|
|
::TODO if it ever gets filled properly, pass in the full fur.
|
|
|
|
=/ for/(unit ship)
|
|
|
|
%- ~(rep in (fall fur ~))
|
|
|
|
|= {m/monk s/(unit ship)}
|
|
|
|
?^ s s
|
2018-05-04 03:59:10 +03:00
|
|
|
?: ?=(%| -.m) ~
|
2018-02-06 23:57:38 +03:00
|
|
|
?: =(p.m his) ~
|
|
|
|
`p.m
|
2019-02-02 00:46:09 +03:00
|
|
|
=/ den ((de our now ski [/scryduct ~] ruf) his syd)
|
2020-05-01 09:14:16 +03:00
|
|
|
=/ result (mule |.(-:(aver:den for u.run u.luk tyl)))
|
|
|
|
?: ?=(%| -.result)
|
|
|
|
%- (slog >%clay-scry-fail< p.result)
|
|
|
|
~
|
|
|
|
?~ p.result ~
|
|
|
|
?~ u.p.result [~ ~]
|
|
|
|
:: should convert %| case to cage
|
|
|
|
::
|
|
|
|
?: ?=(%& -.u.u.p.result) ``p.u.u.p.result
|
2016-11-24 07:25:07 +03:00
|
|
|
~
|
|
|
|
::
|
2020-05-16 15:22:39 +03:00
|
|
|
:: We clear the ford cache by replacing it with its bunt as a literal.
|
|
|
|
:: This nests within +ford-cache without reference to +type, +hoon, or
|
|
|
|
:: anything else in the sample of cache objects. Otherwise we would be
|
|
|
|
:: contravariant in the those types, which makes them harder to change.
|
|
|
|
::
|
|
|
|
++ stay
|
|
|
|
:- ver
|
|
|
|
%= ruf
|
|
|
|
dos.rom
|
|
|
|
%- ~(run by dos.rom.ruf)
|
|
|
|
|= =dojo
|
|
|
|
dojo(fod.dom [~ ~ ~])
|
|
|
|
::
|
|
|
|
hoy
|
|
|
|
%- ~(run by hoy.ruf)
|
|
|
|
|= =rung
|
|
|
|
%= rung
|
|
|
|
rus
|
|
|
|
%- ~(run by rus.rung)
|
|
|
|
|= =rede
|
|
|
|
rede(fod.dom [~ ~ ~])
|
|
|
|
==
|
|
|
|
==
|
|
|
|
::
|
2016-11-24 07:25:07 +03:00
|
|
|
++ take :: accept response
|
2020-02-11 01:03:03 +03:00
|
|
|
|= [tea=wire hen=duct dud=(unit goof) hin=(hypo sign)]
|
2018-12-01 22:31:54 +03:00
|
|
|
^+ [*(list move) ..^$]
|
2020-02-25 01:10:59 +03:00
|
|
|
?^ dud
|
|
|
|
~|(%clay-take-dud (mean tang.u.dud))
|
|
|
|
::
|
2020-05-12 10:01:46 +03:00
|
|
|
?: ?=([%merge @ @ @ @ ~] tea)
|
|
|
|
?> ?=(%writ +<.q.hin)
|
2019-05-02 04:21:32 +03:00
|
|
|
=* syd i.t.tea
|
2020-05-12 10:01:46 +03:00
|
|
|
=/ ali-ship (slav %p i.t.t.tea)
|
|
|
|
=* ali-desk i.t.t.t.tea
|
|
|
|
=/ germ (germ i.t.t.t.t.tea)
|
2019-05-02 04:21:32 +03:00
|
|
|
=^ mos ruf
|
2020-05-12 10:01:46 +03:00
|
|
|
=/ den ((de our now ski hen ruf) our i.t.tea)
|
|
|
|
abet:(merge:den ali-ship ali-desk germ p.q.hin)
|
2019-05-02 04:21:32 +03:00
|
|
|
[mos ..^$]
|
2019-05-17 03:24:10 +03:00
|
|
|
::
|
2019-06-29 02:43:52 +03:00
|
|
|
?: ?=([%foreign-warp *] tea)
|
|
|
|
?> ?=(%writ +<.q.hin)
|
|
|
|
:_ ..^$
|
2019-08-05 23:58:53 +03:00
|
|
|
[hen %give %boon `(unit rand)`(bind `riot`p.q.hin rant-to-rand)]~
|
2019-06-29 02:43:52 +03:00
|
|
|
::
|
|
|
|
?: ?=([%warp-index @ @ @ ~] tea)
|
2019-08-28 06:12:56 +03:00
|
|
|
?+ +<.q.hin ~| %clay-warp-index-strange !!
|
|
|
|
%done
|
2019-07-29 12:08:26 +03:00
|
|
|
?~ error.q.hin
|
|
|
|
[~ ..^$]
|
|
|
|
:: TODO better error handling
|
|
|
|
::
|
2019-08-05 23:58:53 +03:00
|
|
|
~& %clay-take-warp-index-error^our^tea^tag.u.error.q.hin
|
2019-07-29 12:08:26 +03:00
|
|
|
%- (slog tang.u.error.q.hin)
|
|
|
|
[~ ..^$]
|
|
|
|
::
|
2019-08-28 06:12:56 +03:00
|
|
|
%lost
|
|
|
|
~| %clay-take-lost^our
|
|
|
|
:: TODO better error handling
|
2019-08-05 23:58:53 +03:00
|
|
|
!!
|
2019-06-29 02:43:52 +03:00
|
|
|
::
|
2019-08-28 06:12:56 +03:00
|
|
|
%boon
|
|
|
|
=+ ;; res=(unit rand) payload.q.hin
|
|
|
|
::
|
|
|
|
=/ her=ship (slav %p i.t.tea)
|
|
|
|
=/ =desk (slav %tas i.t.t.tea)
|
|
|
|
=/ index=@ud (slav %ud i.t.t.t.tea)
|
|
|
|
::
|
|
|
|
=^ mos ruf
|
|
|
|
=/ den ((de our now ski hen ruf) her desk)
|
|
|
|
abet:(take-foreign-answer:den index res)
|
|
|
|
[mos ..^$]
|
|
|
|
==
|
2019-06-29 02:43:52 +03:00
|
|
|
::
|
2020-07-23 07:57:44 +03:00
|
|
|
?: ?=([%back-index @ @ @ ~] tea)
|
|
|
|
?+ +<.q.hin ~| %clay-backfill-index-strange !!
|
|
|
|
%done
|
|
|
|
?~ error.q.hin
|
|
|
|
[~ ..^$]
|
|
|
|
:: TODO better error handling
|
|
|
|
::
|
|
|
|
~& %clay-take-backfill-index-error^our^tea^tag.u.error.q.hin
|
|
|
|
%- (slog tang.u.error.q.hin)
|
|
|
|
[~ ..^$]
|
|
|
|
::
|
|
|
|
%lost
|
|
|
|
~| %clay-take-backfill-lost^our
|
|
|
|
:: TODO better error handling
|
|
|
|
!!
|
|
|
|
::
|
|
|
|
%boon
|
|
|
|
=+ ;; =blob payload.q.hin
|
|
|
|
::
|
|
|
|
=/ her=ship (slav %p i.t.tea)
|
|
|
|
=/ =desk (slav %tas i.t.t.tea)
|
|
|
|
=/ index=@ud (slav %ud i.t.t.t.tea)
|
|
|
|
::
|
|
|
|
=^ mos ruf
|
|
|
|
=/ den ((de our now ski hen ruf) her desk)
|
2020-07-23 11:36:38 +03:00
|
|
|
abet:abet:(take-backfill:(foreign-update:den index) blob)
|
2020-07-23 07:57:44 +03:00
|
|
|
[mos ..^$]
|
|
|
|
==
|
|
|
|
::
|
2019-07-27 06:43:07 +03:00
|
|
|
?: ?=([%sinks ~] tea)
|
|
|
|
?> ?=(%public-keys +<.q.hin)
|
jael: provide edge-triggered breach notification
Until now, clients of Jael have had to store the first-seen rift if they
want to reliably detect breaches. Otherwise, they would get a false
positive if they heard an old message about a breach (eg if you kick
azimuth-tracker). Clay and Gall did this correctly, but Ames did not.
Jael already maintains this state, so I added a notification to the
existing subscription that happens whenever it notices a breach (a diff
or full where the new rift is greater than the old one).
Because this is an issue on the live network, I wrote state adapters
for Gall and Clay. The Gall one just removes the rift from our state,
but the Clay one is much more involved because we have to upgrade
instances of the clad monad that are possibly in progress.
Specifically, since more input is possible than before, we must wrap any
in-progress instances of the monad in a function that handles the
potential new input from Jael. This temporarily preservers a copy of
the old kernel, but only until the current commit/merge/update has
completed.
The real solution for Clay is to factor out those IO-heavy instances to
userspace tapp/async/imp/threads, and if an upgrade happens in the
middle, you should simply restart them.
Fixes #1852
2019-10-24 07:26:38 +03:00
|
|
|
?. ?=(%breach -.public-keys-result.q.hin)
|
2019-07-27 06:43:07 +03:00
|
|
|
[~ ..^$]
|
|
|
|
=/ who who.public-keys-result.q.hin
|
|
|
|
?: =(our who)
|
|
|
|
[~ ..^$]
|
|
|
|
:: Cancel subscriptions
|
|
|
|
::
|
|
|
|
=/ foreign-desk=(unit rung)
|
|
|
|
(~(get by hoy.ruf) who)
|
|
|
|
?~ foreign-desk
|
|
|
|
[~ ..^$]
|
|
|
|
=/ cancel-ducts=(list duct)
|
|
|
|
%- zing ^- (list (list duct))
|
|
|
|
%+ turn ~(tap by rus.u.foreign-desk)
|
|
|
|
|= [=desk =rede]
|
|
|
|
^- (list duct) %- zing ^- (list (list duct))
|
|
|
|
%+ turn ~(tap by qyx.rede)
|
|
|
|
|= [=wove ducts=(set duct)]
|
|
|
|
:: ~& [%sunk-wove desk (print-wove wove) ducts]
|
|
|
|
~(tap in ducts)
|
|
|
|
=/ cancel-moves=(list move)
|
|
|
|
%+ turn cancel-ducts
|
2020-05-21 11:10:39 +03:00
|
|
|
|=(=duct [duct %slip %b %drip !>([%writ ~])])
|
2019-07-27 06:43:07 +03:00
|
|
|
:: delete local state of foreign desk
|
|
|
|
::
|
|
|
|
=. hoy.ruf (~(del by hoy.ruf) who)
|
2020-05-13 09:36:55 +03:00
|
|
|
[cancel-moves ..^$]
|
2019-07-27 06:43:07 +03:00
|
|
|
::
|
2016-11-24 07:25:07 +03:00
|
|
|
?- -.+.q.hin
|
2019-07-27 06:43:07 +03:00
|
|
|
%public-keys ~|([%public-keys-raw tea] !!)
|
2019-05-11 00:51:37 +03:00
|
|
|
%crud
|
2016-11-24 07:25:07 +03:00
|
|
|
[[[hen %slip %d %flog +.q.hin] ~] ..^$]
|
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%mere
|
2018-03-19 06:54:47 +03:00
|
|
|
?: ?=(%& -.p.+.q.hin)
|
2016-11-24 07:25:07 +03:00
|
|
|
~& 'initial merge succeeded'
|
|
|
|
[~ ..^$]
|
|
|
|
~> %slog.
|
|
|
|
:^ 0 %rose [" " "[" "]"]
|
|
|
|
:^ leaf+"initial merge failed"
|
|
|
|
leaf+"my most sincere apologies"
|
|
|
|
>p.p.p.+.q.hin<
|
|
|
|
q.p.p.+.q.hin
|
|
|
|
[~ ..^$]
|
|
|
|
::
|
2019-05-11 00:51:37 +03:00
|
|
|
%note [[hen %give +.q.hin]~ ..^$]
|
|
|
|
%wake
|
2019-04-10 06:15:37 +03:00
|
|
|
:: TODO: handle behn errors
|
|
|
|
::
|
|
|
|
?^ error.q.hin
|
|
|
|
[[hen %slip %d %flog %crud %wake u.error.q.hin]~ ..^$]
|
|
|
|
::
|
2020-05-12 12:09:41 +03:00
|
|
|
?. ?=([%tyme @ @ ~] tea)
|
|
|
|
~& [%clay-strange-timer tea]
|
|
|
|
[~ ..^$]
|
|
|
|
=/ her (slav %p i.t.tea)
|
|
|
|
=/ syd (slav %tas i.t.t.tea)
|
|
|
|
=^ mos ruf
|
|
|
|
=/ den ((de our now ski hen ruf) her syd)
|
|
|
|
abet:wake:den
|
|
|
|
[mos ..^$]
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-06-29 02:43:52 +03:00
|
|
|
:: handled in the wire dispatcher
|
|
|
|
::
|
2019-07-29 09:37:49 +03:00
|
|
|
%boon !!
|
2019-08-28 06:12:56 +03:00
|
|
|
%lost !!
|
2020-06-27 05:21:09 +03:00
|
|
|
%writ
|
|
|
|
%- (slog leaf+"clay: strange writ (expected on upgrade to Fusion)" ~)
|
|
|
|
[~ ..^$]
|
2016-11-24 07:25:07 +03:00
|
|
|
::
|
2019-06-29 02:43:52 +03:00
|
|
|
%done
|
|
|
|
?~ error=error.q.hin
|
2019-05-11 05:23:13 +03:00
|
|
|
[~ ..^$]
|
2019-10-30 23:23:37 +03:00
|
|
|
%- (slog >%clay-lost< >tag.u.error< tang.u.error)
|
2016-11-24 07:25:07 +03:00
|
|
|
[~ ..^$]
|
|
|
|
==
|
|
|
|
::
|
|
|
|
++ rant-to-rand
|
|
|
|
|= rant
|
|
|
|
^- rand
|
|
|
|
[p q [p q.q]:r]
|
2020-05-07 11:51:08 +03:00
|
|
|
:: +whey: produce memory usage report
|
|
|
|
::
|
|
|
|
++ whey
|
|
|
|
^- (list mass)
|
|
|
|
=/ domestic
|
|
|
|
%+ turn (sort ~(tap by dos.rom.ruf) aor)
|
|
|
|
|= [=desk =dojo]
|
|
|
|
:+ desk %|
|
|
|
|
:~ ankh+&+ank.dom.dojo
|
|
|
|
mime+&+mim.dom.dojo
|
2020-07-29 07:04:59 +03:00
|
|
|
ford-vases+&+vases.fod.dom.dojo
|
|
|
|
ford-marks+&+marks.fod.dom.dojo
|
|
|
|
ford-casts+&+casts.fod.dom.dojo
|
2020-05-07 11:51:08 +03:00
|
|
|
==
|
|
|
|
:~ domestic+|+domestic
|
|
|
|
foreign+&+hoy.ruf
|
|
|
|
:+ %object-store %|
|
|
|
|
:~ commits+&+hut.ran.ruf
|
|
|
|
blobs+&+lat.ran.ruf
|
|
|
|
==
|
|
|
|
==
|
2016-11-24 07:25:07 +03:00
|
|
|
--
|