ilyakooo0/urbit
1
0
Fork 0
mirror of https://github.com/ilyakooo0/urbit.git synced 2024-12-15 18:12:47 +03:00
Code Issues Packages Projects Releases Wiki Activity
91432cf75f
urbit/sys/vane/ford.hoon

6359 lines
208 KiB
Plaintext
Raw Blame History

:: ford: build system vane
::
:: Ford is a functional reactive build system.
::
:: A Ford build is a function of the Urbit namespace and a date that
:: produces marked, typed data or an error.
::
:: The function in the definition of a build is called a "schematic,"
:: and it's represented by a Hoon data structure with twenty-five sub-types.
:: A schematic is a (possibly trivial) DAG of sub-builds to be performed.
:: The different schematic sub-types transform the results of their
:: sub-builds in different ways.
::
:: We call the date in the definition of a build the "formal date" to
:: distinguish it from the time at which the build was performed.
:: Each build is referentially transparent with respect to its formal date:
:: ask to run that function on the namespace and a particular formal date,
:: and Ford will always produce the same result.
::
:: We can now say Ford is a functional build system, since each build is a
:: function. We have not yet explained how it's a functional reactive build
:: system. With Ford, you can subscribe to results of a build. Ford tracks
:: the result of a "live" build consisting of a static schematic and the
:: ever-changing current date. Whenever this live build's result changes,
:: Ford sends you the new result and the formal date of the build (the date
:: which would cause the same result if you asked Ford to build that
:: schematic again). This is a push-based FRP paradigm.
::
:: The implementation is event-driven, like the rest of Urbit. While
:: performing a build, Ford registers each namespace access as a dependency
:: and also notes whether the dependency is "live," meaning the path within
:: the namespace updates with time. For example a live Clay dependency would
:: update the +case within the +beam over time.
::
:: A request to perform a build without subscribing to its future changes is
:: called a "once build."
::
:: After finishing a build, Ford subscribes to updates on the build's
:: dependencies. For now, this just means it subscribes to Clay for file
:: changes. Whenever any of the files in the subscription have new contents,
:: Clay will notify Ford, which will then rerun any live builds that depend
:: on any of the changed files and send its subscribers the new results.
::
:: This matches the semantics of live builds defined above. If someone had
:: asked for a build of the schematic with a formal date d2 just before the
:: changed Clay files, Ford would respond with the result of the previous
:: build with formal date d1, which would still be an accurate
:: representation of the schematic's result at d2, since Ford knows none of
:: its dependencies changed between d1 and d2.
::
:: Note that Ford can only calculate dependencies after running a build,
:: not before. This is because Ford can be thought of as an interpreter for
:: schematics, rather than a compiler, in the sense that it can't have a
:: dependency-gathering step followed by a build step. The dependencies of
:: some schematics must be calculated based on results, e.g. the %alts
:: schematic, which tries a sequence of sub-builds until one succeeds. If
:: the first sub-build succeeds, the build depends only on that first
:: sub-build, but if the first fails and the second succeeds, the build
:: depends on both.
::
:: This dynamicity implies we don't know what we depend on until we depend
:: on it. Most build systems have this property, but this part of Ford's
:: job is easier than for most Unix-based build systems: Ford draws all
:: resources from an immutable namespace, and it can track every access of
:: that namespace.
::
:: Ford might produce a build's result asynchronously, in a subsequent Arvo
:: event. This happens when accessing the namespace doesn't complete
:: synchronously, such as when grabbing a file from another ship. Ford
:: guarantees it will respond with build results in chronological order
:: using the formal date, not the order in which the builds completed.
::
:: Ford does not guarantee it will notify a subscriber of a changed build
:: only once per change. In common usage it will not send duplicate
:: notifications, but it might if its cache was recently wiped.
::
:: Ford uses dependency tracking, caching, and results of previous builds
:: to eliminate excess work. When rerunning a live build, Ford "promotes"
:: previous results to the new time if the build's dependencies hvaen't
:: changed since the previous build's formal date. Ford does this check
:: for each build in a tree of sub-builds under the "root build," which
:: is the build that was requested directly.
::
:: In addition to the main %build +task sub-type, Ford also supports
:: four other commands:
::
:: %kill: cancel a build
::
:: A once build in progress will be canceled, including all of its
:: sub-builds that aren't part of any other builds.
::
:: A live build's subscriptions will be canceled, its completed results
:: will be deleted, and its dependency tracking information will be
:: deleted. If a rebuild is in progress, it will be canceled.
::
:: %keep: resize caches
::
:: Ford maintains two caches: a :compiler-cache that stores
:: content-addressed compiler operations, such as parsing, compiling,
:: and type inference; and a :build-cache that stores previously
:: completed build trees along with their results and dependency tracking.
::
:: The %keep command resets the maximum sizes of these caches, deleting
:: entries if necessary.
::
:: %wipe: decimate storage
::
:: The %wipe command removes build results from storage to free memory.
:: It deletes the specified percentage of build results, in LRU
:: (Least Recently Used) order. It also removes entries from the compiler
:: cache. It does not remove dependency tracking information.
::
:: %wegh: report memory usage
::
:: Like all vanes, Ford can also be asked to produce a human-readable
:: report of its memory usage. Nock cannot calculate its own memory use
:: directly, so instead we produce the nouns themselves, which the runtime
:: "weighs" based on its memory model.
::
:: For details on Ford's implementation, consult Ford's vane interface core
:: near the bottom of the file.
::
:: pit: a +vase of the hoon+zuse kernel, which is a deeply nested core
::
|= pit=vase
::
=, contain
=, ford
:: ford internal data structures
::
=> =~
|%
:: +move: arvo moves that ford can emit
::
+= move
::
$: :: duct: request identifier
::
=duct
:: card: move contents; either a +note or a +gift:able
::
card=(wind note gift:able)
==
:: +note: private request from ford to another vane
::
+= note
$% :: %c: to clay
::
$: %c
:: %warp: internal (intra-ship) file request
::
$% $: %warp
:: sock: pair of requesting ship, requestee ship
::
=sock
:: riff: clay request contents
::
riff=riff:clay
== == == ==
:: +sign: private response from another vane to ford
::
+= sign
$% :: %c: from clay
::
$: %c
:: %writ: internal (intra-ship) file response
::
$% $: %writ
:: riot: response contents
::
riot=riot:clay
==
:: %wris: response to %mult; many changed files
::
$: %wris
:: case: case of the new files
::
:: %wris can only return dates to us.
::
case=[%da p=@da]
:: care-paths: the +care:clay and +path of each file
::
care-paths=(set [care=care:clay =path])
== == == ==
--
|%
:: +axle: overall ford state
::
+= axle
$: :: date: date at which ford's state was updated to this data structure
::
date=%~2018.6.28
:: state-by-ship: storage for all the @p's this ford has been
::
:: Once the cc-release boot sequence lands, we can remove this
:: mapping, since an arvo will not change @p identities. until
:: then, we need to support a ship booting as a comet before
:: becoming its adult identity.
::
state-by-ship=(map ship ford-state)
==
:: +ford-state: all state that ford maintains for a @p ship identity
::
+= ford-state
$: :: builds: per-build state machine for all builds
::
:: Ford holds onto all in-progress builds that were either directly
:: requested by a duct (root builds) or that are dependencies
:: (sub-builds) of a directly requested build.
::
:: It also stores the last completed version of each live build tree
:: (root build and sub-builds), and any cached builds.
::
builds=(map build build-status)
:: ducts: per-duct state machine for all incoming ducts (build requests)
::
:: Ford tracks every duct that has requested a build until it has
:: finished dealing with that request.
::
:: For live ducts, we store the duct while we repeatedly run new
:: versions of the live build it requested until it is explicitly
:: canceled by the requester.
::
:: A once (non-live) duct, on the other hand, will be removed
:: as soon as the requested build has been completed.
::
ducts=(map duct duct-status)
:: builds-by-schematic: all attempted builds, sorted by time
::
:: For each schematic we've attempted to build at any time,
:: list the formal dates of all build attempts, sorted newest first.
::
builds-by-schematic=(map schematic (list @da))
:: pending-scrys: outgoing requests for static resources
::
pending-scrys=(request-tracker scry-request)
:: pending-subscriptions: outgoing subscriptions on live resources
::
pending-subscriptions=(request-tracker subscription)
:: build-cache: fifo queue of completed root builds
::
$= build-cache
$: :: next-anchor-id: incrementing identifier for cache anchors
::
next-anchor-id=@ud
:: queue: fifo queue of root builds identified by anchor id
::
queue=(capped-queue build-cache-key)
==
:: compiler-cache: clock based cache of build results
::
compiler-cache=(clock compiler-cache-key build-result)
==
:: +anchor: something which holds on to builds
::
:: An anchor is a reference which keeps builds. This is either a %duct, in
:: which case the build is live because a duct is waiting for a response, or
:: a %cache, in which case the anchor is a cached build.
::
:: When a duct would be removed from a build, the %duct anchor is replaced
:: with a %cache anchor. This %cache anchor refers to a FIFO queue of cached
:: builds.
::
+= anchor
$% :: %duct: this is anchored on a duct
::
[%duct =duct]
:: %cache: this is anchored to a cache entry
::
[%cache id=@ud]
==
:: +build-status: current data for a build, including construction status
::
:: +build-status stores the construction status of a build as a finite state
:: machine (:state). It stores links to dependent sub-builds in :subs, and
:: per-duct client builds in :clients.
::
+= build-status
$: :: requesters: ducts for whom this build is the root build
::
requesters=(set anchor)
:: clients: per duct information for this build
::
clients=(jug anchor build)
:: subs: sub-builds of this build, for whom this build is a client
::
subs=(map build build-relation)
:: state: a state machine for tracking the build's progress
::
$= state
$% $: :: %untried: build has not been started yet
::
%untried ~
==
$: :: %blocked: build blocked on either sub-builds or resource
::
:: If we're in this state and there are no blocks in :subs,
:: then we're blocked on a resource.
::
%blocked ~
==
$: :: %unblocked: we were blocked but now we aren't
::
%unblocked ~
==
$: :: %complete: build has finished running and has a result
::
%complete
:: build-record: the product of the build, possibly tombstoned
::
=build-record
== == ==
:: +duct-status: information relating a build to a duct
::
+= duct-status
$: :: live: whether this duct is being run live
::
$= live
$% [%once in-progress=@da]
$: %live
::
::
in-progress=(unit @da)
:: the last subscription we made
::
:: This can possibly have an empty set of resources, in which
:: we never sent a move.
::
:: NOTE: This implies that a single live build can only depend
:: on live resources from a single disc. We don't have a
:: working plan for fixing this and will need to think very
:: hard about the future.
::
last-sent=(unit [date=@da subscription=(unit subscription)])
== ==
:: root-schematic: the requested build for this duct
::
root-schematic=schematic
==
:: +build-relation: how do two builds relate to each other?
::
:: A +build-relation can be either :verified or not, and :blocked or not.
:: It is a symmetric relation between two builds, in the sense that both
:: the client and the sub will store the same relation, just pointing to
:: the other build.
::
:: If it's not :verified, then the relation is a guess based on previous
:: builds. These guesses are used to ensure that we hold onto builds we
:: expect to be used in future builds. Each time we run +make on a build,
:: it might produce new :verified sub-builds, which may have been unverified
:: until then. Once a build completes, any unverified sub-builds must be
:: cleaned up, since it turned out they weren't used by the build after all.
::
:: :blocked is used to note that a build can't be completed until that
:: sub-build has been completed. A relation can be :blocked but not :verified
:: if we're trying to promote a build, but we haven't run all its sub-builds
:: yet. In that case, we'll try to promote or run the sub-build in order to
:: determine whether we can promote the client. Until the sub-build has been
:: completed, the client is provisionally blocked on the sub-build.
::
+= build-relation
$: :: verified: do we know this relation is real, or is it only a guess?
::
verified=?
:: is this build blocked on this other build?
::
blocked=?
==
:: +build-record: information associated with the result of a completed +build
::
+= build-record
$% $: :: %tombstone: the build's result has been wiped
::
%tombstone ~
==
$: :: %value: we have the +build-result
::
%value
:: last-accessed: last time we looked at the result
::
:: This is used for LRU cache reclamation.
::
last-accessed=@da
:: build-result: the stored value of the build's product
::
=build-result
== ==
:: +build: a referentially transparent request for a build
::
:: Each unique +build will always produce the same +build-result
:: when run (if it completes). A live build consists of a sequence of
:: instances of +build with the same :schematic and increasing :date.
::
+= build
$: :: date: the formal date of this build; unrelated to time of execution
::
date=@da
:: schematic: the schematic that determines how to run this build
::
=schematic
==
:: +request-tracker: generic tracker and multiplexer for pending requests
::
++ request-tracker
|* request-type=mold
%+ map request-type
$: :: waiting: ducts blocked on this request
::
waiting=(set duct)
:: originator: the duct that kicked off the request
::
originator=duct
==
:: +subscription: a single subscription to changes on a set of resources
::
+= subscription
$: :: date: date this was made
::
date=@da
:: disc: ship and desk for all :resources
::
=disc
:: resources: we will be notified if any of these resources change
::
resources=(set resource)
==
:: +scry-request: parsed arguments to a scry operation
::
+= scry-request
$: :: vane: the vane from which to make the request
::
:: If we add other vanes in the future, this will become a fork type.
:: For now, though, Ford only knows how to make asynchronous scry
:: requests to Clay.
::
vane=%c
:: care: type of request
::
care=care:clay
:: beam: request path
::
=beam
==
:: +compiler-cache-key: content addressable build definitions
::
+= compiler-cache-key
$% [%call gate=vase sample=vase]
[%hood =beam txt=@t]
[%ride formula=hoon subject=vase]
[%slim subject-type=type formula=hoon]
[%slit gate=type sample=type]
==
:: +build-cache-key: key for the fifo cache of completed build trees
::
+= build-cache-key
$: :: id: incrementing identifier for an +anchor
::
id=@ud
:: root-build: the root build associated with this anchor
::
root-build=build
==
:: +build-receipt: result of running +make
::
:: A +build-receipt contains all information necessary to perform the
:: effects and state mutations indicated by a call to +make. If :build
:: succeeded, :result will be %build-result; otherwise, it will be %blocks.
::
:: After +make runs on a batch of builds, the resulting +build-receipt's are
:: applied one at a time.
::
+= build-receipt
$: :: build: the build we worked on
::
=build
:: result: the outcome of this build
::
$= result
$% :: %build-result: the build produced a result
::
$: %build-result
=build-result
==
:: %blocks: the build blocked on the following builds or resource
::
$: %blocks
:: builds: builds that :build blocked on
::
builds=(list build)
==
==
:: sub-builds: subbuilds of :build
::
:: While running +make on :build, we need to keep track of any
:: sub-builds that we try to access so we can keep track of
:: component linkages and cache access times.
::
sub-builds=(list build)
:: cache-access: if not ~, cache this result as :compiler-cache-key.
::
cache-access=(unit [=compiler-cache-key new=?])
==
--
=, format
|%
:: +tear: split a +term into segments delimited by `-`
::
:: Example:
:: ```
:: dojo> (tear 'foo-bar-baz')
:: ['foo' 'bar' 'baz']
:: ```
::
++ tear
|= a=term
^- (list term)
:: sym-no-heps: a parser for terms with no heps and a leading letter
::
=/ sym-no-heps (cook crip ;~(plug low (star ;~(pose low nud))))
::
(fall (rush a (most hep sym-no-heps)) /[a])
:: +segments: compute all paths from :path-part, replacing some `/`s with `-`s
::
:: For example, when passed a :path-part of 'foo-bar-baz',
:: the product will contain:
:: ```
:: dojo> (segments 'foo-bar-baz')
:: [/foo/bar/baz /foo/bar-baz /foo-bar/baz /foo-bar-baz]
:: ```
::
++ segments
|= path-part=@tas
^- (list path)
::
=/ join |=([a=@tas b=@tas] (crip "{(trip a)}-{(trip b)}"))
::
=/ torn=(list @tas) (tear path-part)
::
|- ^- (list (list @tas))
::
?< ?=(~ torn)
::
?: ?=([@ ~] torn)
~[torn]
::
%- zing
%+ turn $(torn t.torn)
|= s=(list @tas)
^- (list (list @tas))
::
?> ?=(^ s)
~[[i.torn s] [(join i.torn i.s) t.s]]
:: +build-to-tape: convert :build to a printable format
::
:: Builds often contain the standard library and large types, so
:: this function should always be called when trying to print a +build.
::
++ build-to-tape
|= =build
^- tape
~+
::
=/ enclose |=(tape "[{+<}]")
=/ date=@da date.build
=/ =schematic schematic.build
::
%- enclose
%+ welp (trip (scot %da date))
%+ welp " "
::
?+ -.schematic
:(welp "[" (trip -.schematic) " {<`@uvI`(mug schematic)>}]")
::
%$
"literal"
::
^
%- enclose
;:(welp $(build [date head.schematic]) " " $(build [date tail.schematic]))
::
%alts
;: welp
%+ roll choices.schematic
|= [choice=^schematic txt=_"[alts"]
:(welp txt " " ^$(schematic.build choice))
::
"]"
==
::
%core
:(welp "[core " (spud (en-beam (rail-to-beam source-path.schematic))) "]")
::
%hood
:(welp "[hood " (spud (en-beam (rail-to-beam source-path.schematic))) "]")
::
%plan
;: welp
"[plan "
(spud (en-beam (rail-to-beam path-to-render.schematic)))
"]"
==
::
%scry
(spud (en-beam (extract-beam resource.schematic ~)))
::
:: %slim
:: "slim {<subject-type.schematic>} {<formula.schematic>}"
::
%vale
;: welp
"[vale ["
(trip (scot %p ship.disc.schematic))
" "
(trip desk.disc.schematic)
"] "
(trip mark.schematic)
"]"
==
==
:: +rail-to-beam: convert :rail to a +beam, filling in the case with `[%ud 0]`
::
++ rail-to-beam
|= =rail
^- beam
[[ship.disc.rail desk.disc.rail [%ud 0]] spur.rail]
:: +rail-to-path: pretty-printable rail
::
++ rail-to-path
|= =rail
^- path
(en-beam (rail-to-beam rail))
:: +unify-jugs: make a new jug, unifying sets for all keys
::
:: Example:
:: ```
:: dojo> %+ unify-jugs
:: (~(gas by *(jug @tas @ud)) ~[[%a (sy 1 2 ~)] [%b (sy 4 5 ~)]])
:: (~(gas by *(jug @tas @ud)) ~[[%b (sy 5 6 ~)] [%c (sy 7 8 ~)]])
::
:: {[p=%a q={1 2 3}] [p=%b q={4 5 6}] [p=%c q={7 8}]}
:: ```
::
++ unify-jugs
|* [a=(jug) b=(jug)]
^+ a
::
=/ tapped ~(tap by b)
::
|- ^+ a
?~ tapped a
::
=/ key p.i.tapped
=/ vals ~(tap in q.i.tapped)
::
=. a
|- ^+ a
?~ vals a
::
$(vals t.vals, a (~(put ju a) key i.vals))
::
$(tapped t.tapped)
:: +path-to-resource: decode a +resource from a +wire
::
++ path-to-resource
|= =path
^- (unit resource)
::
=/ scry-request=(unit scry-request) (path-to-scry-request path)
?~ scry-request
~
=+ [vane care bem]=u.scry-request
=/ =beam bem
=/ =rail [disc=[p.beam q.beam] spur=s.beam]
`[vane care rail]
:: +scry-request-to-path: encode a +scry-request in a +wire
::
:: Example:
:: ```
:: dojo> %- scry-request-to-path
:: [%c %x [[~zod %home [%da ~2018.1.1]] /hoon/bar]])
::
:: /cx/~zod/home/~2018.1.1/bar/hoon
:: ```
::
++ scry-request-to-path
|= =scry-request
^- path
=/ =term (cat 3 [vane care]:scry-request)
[term (en-beam beam.scry-request)]
:: +path-to-scry-request: parse :path's components into :vane, :care, and :rail
::
++ path-to-scry-request
|= =path
^- (unit scry-request)
::
?~ path
~
?~ vane=((soft ,%c) (end 3 1 i.path))
~
?~ care=((soft care:clay) (rsh 3 1 i.path))
~
?~ beam=(de-beam t.path)
~
?. ?=(%da -.r.u.beam)
~
`[u.vane u.care u.beam]
:: +scry-request-to-build: convert a +scry-request to a %scry build
::
++ scry-request-to-build
|= =scry-request
^- build
:: we only operate on dates, not other kinds of +case:clay
::
?> ?=(%da -.r.beam.scry-request)
::
=, scry-request
[p.r.beam [%scry [vane care `rail`[[p q] s]:beam]]]
:: +extract-beam: obtain a +beam from a +resource
::
:: Fills case with [%ud 0] for live resources if :date is `~`.
:: For once resources, ignore :date.
::
++ extract-beam
|= [=resource date=(unit @da)] ^- beam
::
=/ =case ?~(date [%ud 0] [%da u.date])
::
=, rail.resource
[[ship.disc desk.disc case] spur]
:: +extract-disc: obtain a +disc from a +resource
::
++ extract-disc
|= =resource ^- disc
disc.rail.resource
:: +get-sub-schematics: find any schematics contained within :schematic
::
++ get-sub-schematics
|= =schematic
^- (list ^schematic)
?- -.schematic
^ ~[head.schematic tail.schematic]
%$ ~
%pin ~[schematic.schematic]
%alts choices.schematic
%bake ~
%bunt ~
%call ~[gate.schematic sample.schematic]
%cast ~[input.schematic]
%core ~
%diff ~[start.schematic end.schematic]
%dude ~[attempt.schematic]
%hood ~
%join ~[first.schematic second.schematic]
%list schematics.schematic
%mash ~[schematic.first.schematic schematic.second.schematic]
%mute [subject.schematic (turn mutations.schematic tail)]
%pact ~[start.schematic diff.schematic]
%path ~
%plan ~
%reef ~
%ride ~[subject.schematic]
%same ~[schematic.schematic]
%scry ~
%slim ~
%slit ~
%vale ~
%volt ~
%walk ~
==
:: +by-schematic: door for manipulating :by-schematic.builds.ford-state
::
:: The :dates list for each key in :builds is sorted in reverse
:: chronological order. These operations access and mutate keys and values
:: of :builds and maintain that sort order.
::
++ by-schematic
|_ builds=(map schematic (list @da))
:: +put: add a +build to :builds
::
:: If :build already exists in :builds, this is a no-op.
:: Otherwise, replace the value at the key :schematic.build
:: with a new :dates list that contains :date.build.
::
++ put
|= =build
^+ builds
%+ ~(put by builds) schematic.build
::
=/ dates (fall (~(get by builds) schematic.build) ~)
?^ (find [date.build]~ dates)
dates
(sort [date.build dates] gte)
:: +del: remove a +build from :builds
::
:: Removes :build from :builds by replacing the value at
:: the key :schematic.build with a new :dates list with
:: :date.build omitted. If the resulting :dates list is
:: empty, then remove the key-value pair from :builds.
::
++ del
|= =build
^+ builds
=. builds
%+ ~(jab by builds) schematic.build
|= dates=(list @da)
~| build+build
=/ date-index (need (find [date.build]~ dates))
(oust [date-index 1] dates)
:: if :builds has an empty entry for :build, delete it
::
=? builds
=(~ (~(got by builds) schematic.build))
(~(del by builds) schematic.build)
::
builds
:: +find-previous: find the most recent older build with :schematic.build
::
++ find-previous
|= =build
^- (unit ^build)
::
=/ dates=(list @da) (fall (~(get by builds) schematic.build) ~)
::
|- ^- (unit ^build)
?~ dates ~
::
?: (lth i.dates date.build)
`[i.dates schematic.build]
$(dates t.dates)
:: +find-next: find the earliest build of :schematic.build later than :build
::
++ find-next
|= =build
^- (unit ^build)
::
=/ dates=(list @da) (flop (fall (~(get by builds) schematic.build) ~))
::
|- ^- (unit ^build)
?~ dates ~
::
?: (gth i.dates date.build)
`[i.dates schematic.build]
$(dates t.dates)
--
:: +get-request-ducts: all ducts waiting on this request
::
++ get-request-ducts
|* [tracker=(request-tracker) request=*]
^- (list duct)
::
~(tap in waiting:(~(got by tracker) request))
:: +put-request: associates a +duct with a request
::
++ put-request
|* [tracker=(request-tracker) request=* =duct]
::
%+ ~(put by tracker) request
?~ existing=(~(get by tracker) request)
[(sy duct ~) duct]
u.existing(waiting (~(put in waiting.u.existing) duct))
:: +del-request: remove a duct and produce the originating duct if empty
::
++ del-request
|* [tracker=(request-tracker) request=* =duct]
^- [(unit ^duct) _tracker]
:: remove :duct from the existing :record of this :request
::
=/ record (~(got by tracker) request)
=. waiting.record (~(del in waiting.record) duct)
:: if no more ducts wait on :request, delete it
::
?^ waiting.record
[~ (~(put by tracker) request record)]
[`originator.record (~(del by tracker) request)]
:: +parse-scaffold: produces a parser for a hoon file with +crane instances
::
:: Ford parses a superset of hoon which contains additional runes to
:: represent +crane s. This parses to a +scaffold.
::
:: src-beam: +beam of the source file we're parsing
::
++ parse-scaffold
|= src-beam=beam
::
=/ hoon-parser (vang & (en-beam src-beam))
|^ ::
%+ cook
|= a=[@ud (list ^cable) (list ^cable) (list ^crane) (list hoon)]
^- scaffold
[[[p q] s]:src-beam a]
::
%+ ifix [gay gay]
;~ plug
:: parses the zuse version, eg "/? 309"
::
;~ pose
(ifix [;~(plug net wut gap) gap] dem)
(easy zuse)
==
:: pareses the structures, eg "/- types"
::
;~ pose
(ifix [;~(plug net hep gap) gap] (most ;~(plug com gaw) cable))
(easy ~)
==
:: parses the libraries, eg "/+ lib1, lib2"
::
;~ pose
(ifix [;~(plug net lus gap) gap] (most ;~(plug com gaw) cable))
(easy ~)
==
::
(star ;~(sfix crane gap))
::
(most gap tall:hoon-parser)
==
:: +beam: parses a hood path and converts it to a beam
::
++ beam
%+ sear de-beam
;~ pfix
net
(sear plex (stag %clsg poor)):hoon-parser
==
:: +cable: parses a +^cable, a reference to something on the filesystem
::
:: This parses:
::
:: `library` -> wraps `library` around the library `library`
:: `face=library` -> wraps `face` around the library `library`
:: `*library` -> exposes `library` directly to the subject
::
++ cable
%+ cook |=(a=^cable a)
;~ pose
(stag ~ ;~(pfix tar sym))
(cook |=([face=term tis=@ file=term] [`face file]) ;~(plug sym tis sym))
(cook |=(a=term [`a a]) sym)
==
:: +crane: all runes that start with / which aren't /?, /-, /+ or //.
::
++ crane
=< apex
:: whether we allow tall form
=| allow-tall-form=?
::
|%
++ apex
%+ knee *^crane |. ~+
;~ pfix net
;~ pose
:: `/~` hoon literal
::
(stag %fssg ;~(pfix sig hoon))
:: `/$` process query string
::
(stag %fsbc ;~(pfix bus hoon))
:: `/|` first of many options that succeeds
::
(stag %fsbr ;~(pfix bar parse-alts))
:: `/=` wrap a face around a crane
::
(stag %fsts ;~(pfix tis parse-face))
:: `/.` null terminated list
::
(stag %fsdt ;~(pfix dot parse-list))
:: `/,` switch by path
::
(stag %fscm ;~(pfix com parse-switch))
:: `/&` pass through a series of mark
::
(stag %fspm ;~(pfix pad parse-pipe))
:: `/_` run a crane on each file in the current directory
::
(stag %fscb ;~(pfix cab subcrane))
:: `/;` passes date through a gate
::
(stag %fssm ;~(pfix mic parse-gate))
:: `/:` evaluate at path
::
(stag %fscl ;~(pfix col parse-at-path))
:: `/^` cast
::
(stag %fskt ;~(pfix ket parse-cast))
:: `/*` run a crane on each file with current path as prefix
::
(stag %fstr ;~(pfix tar subcrane))
:: `/!mark/ evaluate as hoon, then pass through mark
::
(stag %fszp ;~(pfix zap ;~(sfix sym net)))
:: `/mark/` passes current path through :mark
::
(stag %fszy ;~(sfix sym net))
==
==
:: +parse-alts: parse a set of alternatives
::
++ parse-alts
%+ wide-or-tall
(ifix [lit rit] (most ace subcrane))
;~(sfix (star subcrane) gap duz)
:: +parse-face: parse a face around a subcrane
::
++ parse-face
%+ wide-or-tall
;~(plug sym ;~(pfix tis subcrane))
;~(pfix gap ;~(plug sym subcrane))
:: +parse-list: parse a null terminated list of cranes
::
++ parse-list
%+ wide-or-tall
fail
;~(sfix (star subcrane) gap duz)
:: +parse-switch: parses a list of [path crane]
::
++ parse-switch
%+ wide-or-tall
fail
=- ;~(sfix (star -) gap duz)
;~(pfix gap net ;~(plug static-path subcrane))
:: +parse-pipe: parses a pipe of mark conversions
::
++ parse-pipe
%+ wide-or-tall
;~(plug (plus ;~(sfix sym pad)) subcrane)
=+ (cook |=(a=term [a ~]) sym)
;~(pfix gap ;~(plug - subcrane))
:: +parse-gate: parses a gate applied to a crane
::
++ parse-gate
%+ wide-or-tall
;~(plug ;~(sfix wide:hoon-parser mic) subcrane)
;~(pfix gap ;~(plug tall:hoon-parser subcrane))
:: +parse-at-path: parses a late bound bath
::
++ parse-at-path
%+ wide-or-tall
;~(plug ;~(sfix late-bound-path col) subcrane)
;~(pfix gap ;~(plug late-bound-path subcrane))
:: +parse-cast: parses a mold and then the subcrane to apply that mold to
::
++ parse-cast
%+ wide-or-tall
;~(plug ;~(sfix wyde:hoon-parser ket) subcrane)
;~(pfix gap ;~(plug till:hoon-parser subcrane))
:: +subcrane: parses a subcrane
::
++ subcrane
%+ wide-or-tall
apex(allow-tall-form |)
;~(pfix gap apex)
:: +wide-or-tall: parses tall form hoon if :allow-tall-form is %.y
::
++ wide-or-tall
|* [wide=rule tall=rule]
?. allow-tall-form wide
;~(pose wide tall)
:: +hoon: parses hoon as an argument to a crane
::
++ hoon
%+ wide-or-tall
(ifix [lac rac] (stag %cltr (most ace wide:hoon-parser)))
;~(pfix gap tall:hoon-parser)
--
:: +static-path: parses a path
::
++ static-path
(sear plex (stag %clsg (more net hasp))):hoon-parser
:: +late-bound-path: a path whose time varies
::
++ late-bound-path
;~ pfix net
%+ cook |=(a=truss a)
=> hoon-parser
;~ plug
(stag ~ gash)
;~(pose (stag ~ ;~(pfix cen porc)) (easy ~))
==
==
--
:: +per-event: per-event core; main build engine
::
:: This arm produces a gate that when called with state and event
:: information produces the core of Ford's main build engine.
::
:: The main build engine core has the following entry points:
::
:: +start-build start performing a build
:: +rebuild rerun a live build at a new date
:: +unblock continue a build that was waiting on a resource
:: +cancel stop trying to run a build and delete its tracking info
:: +wipe wipe the build storage to free memory
:: +keep resize caches, deleting entries if necessary
::
:: The main internal arm is +execute-loop, which is called from +start-build,
:: +rebuild, and +unblock. +execute defines Ford's build loop.
::
++ per-event
:: moves: the moves to be sent out at the end of this event, reversed
::
=| moves=(list move)
:: scry-results: responses to scry's to handle in this event
::
:: If a value is `~`, the requested resource is not available.
:: Otherwise, the value will contain a +cage.
::
=| scry-results=(map scry-request (unit cage))
:: next-builds: builds to perform in the next iteration
::
=| next-builds=(set build)
:: candidate-builds: builds which might go into next-builds
::
=| candidate-builds=(set build)
:: gate that produces the +per-event core from event information
::
:: Produces a core containing Ford's main build engine.
::
~% %f ..is ~
|= [[our=@p =duct now=@da scry=sley] state=ford-state]
::
~% %per-event + ~
|%
:: +finalize: extract moves and state from the +per-event core
::
:: Run once at the end of processing an event.
::
++ finalize
^- [(list move) ford-state]
[(flop moves) state]
:: |entry-points: externally fired arms
::
::+| entry-points
::
:: +start-build: perform a fresh +build, either live or once
::
:: This might complete the build, or the build might block on one or more
:: requests for resources. Calls +execute-loop.
::
++ start-build
~/ %start-build
|= [=build live=?]
^- [(list move) ford-state]
::
=< finalize
:: associate :duct with :build in :ducts.state
::
=. ducts.state
%+ ~(put by ducts.state) duct
:_ schematic.build
?: live
[%live in-progress=`date.build last-sent=~]
[%once in-progress=date.build]
:: register a state machine for :build in :builds.state
::
=. state (add-build build)
:: :anchor: the reason we hold onto the root of this build tree
::
=/ =anchor [%duct duct]
:: register :duct as an anchor in :requesters.build-status
::
:: This establishes :build as the root build for :duct.
::
=. builds.state
%+ ~(jab by builds.state) build
|= =build-status
build-status(requesters (~(put in requesters.build-status) anchor))
:: copy :anchor into any preexisting descendants
::
:: Sub-builds will reference :build in their :clients.build-status,
:: using `[%duct duct]` as the key. Some sub-builds might already
:: exist if we've already started running :build, so make sure they
:: know who their daddy is.
::
=. builds.state (add-anchor-to-subs anchor build)
:: run +execute on :build in a loop until it completes or blocks
::
(execute-loop (sy [build ~]))
:: +rebuild: rebuild a live build based on +resource updates
::
:: For every changed resource, run the %scry build for that
:: for that resource. Then rebuild upward using the main +execute-loop
:: until all relevant builds either complete or block on external
:: resources. Use dependency tracking information from the previous
:: run of this live build to inform the dependency tracking for this
:: new rebuild.
::
++ rebuild
~/ %rebuild
|= $: =subscription
new-date=@da
=disc
care-paths=(set [care=care:clay =path])
==
^- [(list move) ford-state]
::
~| [%rebuilding new-date disc]
::
=< finalize
:: mark this subscription as complete now that we've heard a response
::
=. pending-subscriptions.state
+:(del-request pending-subscriptions.state subscription duct)
:: for every changed resource, create a %scry build
::
=/ builds=(list build)
%+ turn ~(tap in care-paths)
|= [care=care:clay =path]
^- build
::
[new-date [%scry [%c care rail=[disc spur=(flop path)]]]]
:: sanity check; only rebuild live builds, not once builds
::
=/ duct-status (~(got by ducts.state) duct)
?> ?=(%live -.live.duct-status)
:: sanity check; only rebuild once we've completed the previous one
::
?> ?=(~ in-progress.live.duct-status)
?> ?=(^ last-sent.live.duct-status)
:: set the in-progress date for this new build
::
=. ducts.state
%+ ~(put by ducts.state) duct
duct-status(in-progress.live `new-date)
:: copy the previous build's tree as provisional sub-builds
::
:: This provides an upward rebuild path from leaves to root,
:: so that once the %scry builds complete, we'll know to rebuild
:: their clients. This process will continue up through rebuilding
:: the root build.
::
:: If the build at this new date ends up with a different set of
:: dependencies from its previous incarnation, provisional sub-builds
:: that weren't actually used will be removed in
:: +cleanup-orphaned-provisional-builds.
::
=/ old-root=build
[date.u.last-sent.live.duct-status root-schematic.duct-status]
::
=. state
::
~| [%duct-doesnt-refer-to-real-build live.duct-status]
~| [%missing-build (build-to-tape old-root)]
~| [%dates (~(get by builds-by-schematic.state) root-schematic.duct-status)]
?> (~(has by builds.state) old-root)
::
(copy-build-tree-as-provisional old-root new-date=new-date)
:: gather all the :builds, forcing reruns
::
:: The normal +gather logic would promote the previous results
:: for these %scry builds, since we have subscriptions on them.
:: We pass `force=%.y` to ensure the builds get enqueued instead
:: of promoted.
::
=. ..execute (gather (sy builds) force=%.y)
:: rebuild resource builds at the new date
::
:: This kicks off the main build loop, which will first build
:: :builds, then rebuild upward toward the root. If the whole
:: build tree completes synchronously, then this will produce
:: %made moves at the end of this event. Otherwise, it will
:: block on resources and complete during a later event.
::
(execute-loop ~)
:: +unblock: continue builds that had blocked on :resource
::
:: A build can be stymied temporarily if it depends on a resource
:: that must be fetched asynchronously. +unblock is called when
:: we receive a response to a resource request that blocked a build.
::
:: We pick up the build from where we left off, starting with the
:: %scry build that blocked on this resource last time we tried it.
::
++ unblock
~/ %unblock
|= [=scry-request scry-result=(unit cage)]
^- [(list move) ford-state]
::
=< finalize
:: place :scry-result in :scry-results.per-event
::
:: We don't want to call the actual +scry function again,
:: because we already tried that in a previous event and it
:: had no synchronous answer. This +unblock call is a result
:: of the response to the asynchronous request we made to
:: retrieve that resource from another vane.
::
:: Instead, we'll intercept any calls to +scry by looking up
:: the arguments in :scry-results.per-event. This is ok because
:: in this function we attempt to run every +build that had
:: blocked on the resource, so the information is guaranteed
:: to be used during this event before it goes out of scope.
::
=. scry-results (~(put by scry-results) scry-request scry-result)
:: mark this +scry-request as complete now that we have a response
::
=. pending-scrys.state
+:(del-request pending-scrys.state scry-request duct)
:: update :unblocked-build's state machine to reflect its new status
::
=/ unblocked-build=build (scry-request-to-build scry-request)
=. builds.state
%+ ~(jab by builds.state) unblocked-build
|= =build-status
build-status(state [%unblocked ~])
:: jump into the main build loop, starting with :unblocked-build
::
(execute-loop (sy unblocked-build ~))
:: +wipe: forcibly decimate build results from the state
::
:: +wipe decimates both the :compiler-cache and the results in
:: :builds.state. It removes the specified percentage of build results
:: from the state. For simplicity, it considers the weight of each
:: compiler cache line to be equal to the weight of a build result.
::
:: It deletes cache entries before dipping into :builds.state; it only
:: converts entries in :builds.state to %tombstone's if there aren't
:: enough entries in the compiler cache to sate the request's bloodlust.
::
:: When deleting results from :builds.state, it first sorts them by
:: their :last-accessed date so that the stalest builds are deleted first.
:: We do not touch the :build-cache directly, but because the results
:: of the builds in :build-cache live in :builds.state, the results of
:: both FIFO-cached builds and active builds are all sorted and trimmed.
::
++ wipe
~/ %wipe
|= percent-to-remove=@ud
^+ state
:: removing 0% is the same as doing nothing, so do nothing
::
?: =(0 percent-to-remove)
~& %wipe-no-op
state
::
~| [%wipe percent-to-remove=percent-to-remove]
?> (lte percent-to-remove 100)
:: find all completed builds, sorted by :last-accessed date
::
=/ completed-builds=(list build)
=- (turn - head)
%+ sort
:: filter for builds with a stored +build-result
::
%+ skim ~(tap by builds.state)
|= [=build =build-status]
^- ?
::
?=([%complete %value *] state.build-status)
:: sort by :last-accessed date
::
|= [[* a=build-status] [* b=build-status]]
^- ?
::
?> ?=([%complete %value *] state.a)
?> ?=([%complete %value *] state.b)
::
%+ lte
last-accessed.build-record.state.a
last-accessed.build-record.state.b
:: determine how many builds should remain after decimation
::
:: This formula has the property that repeated applications
:: of +wipe with anything other than 100% retention rate will
:: always eventually remove every build.
::
=/ num-completed-builds=@ud
(add (lent completed-builds) size.compiler-cache.state)
=/ percent-to-keep=@ud (sub 100 percent-to-remove)
=/ num-to-keep=@ud (div (mul percent-to-keep num-completed-builds) 100)
=/ num-to-remove=@ud (sub num-completed-builds num-to-keep)
::
|^ ^+ state
::
=+ cache-size=size.compiler-cache.state
?: (lte num-to-remove cache-size)
(remove-from-cache num-to-remove)
=. compiler-cache.state
%~ purge
(by-clock compiler-cache-key build-result)
compiler-cache.state
(tombstone-builds (sub num-to-remove cache-size))
::
++ remove-from-cache
|= count=@ud
%_ state
compiler-cache
%- %~ trim
(by-clock compiler-cache-key build-result)
compiler-cache.state
count
==
::
++ tombstone-builds
|= num-to-remove=@ud
::
~| [%wipe num-to-remove=num-to-remove]
:: the oldest :num-to-remove builds are considered stale
::
=/ stale-builds (scag num-to-remove completed-builds)
:: iterate over :stale-builds, replacing with %tombstone's
::
|- ^+ state
?~ stale-builds state
:: replace the build's entry in :builds.state with a %tombstone
::
=. builds.state
=< builds
%+ update-build-status i.stale-builds
|= =build-status
build-status(state [%complete %tombstone ~])
::
$(stale-builds t.stale-builds)
--
:: +keep: resize caches
::
:: Ford maintains two caches: a :build-cache for caching previously
:: completed build trees, and a :compiler-cache for caching various
:: compiler operations that tend to be shared among multiple builds.
::
:: To handle this command, we reset the maximum sizes of both of
:: these caches, removing entries from the caches if necessary.
::
++ keep
~/ %keep
|= [compiler-cache-size=@ud build-cache-size=@ud]
^+ state
:: pop old builds out of :build-cache and remove their cache anchors
::
=^ pops queue.build-cache.state
%. build-cache-size
~(resize (to-capped-queue build-cache-key) queue.build-cache.state)
::
=. state
|- ^+ state
?~ pops state
::
=. state (remove-anchor-from-root root-build.i.pops [%cache id.i.pops])
::
$(pops t.pops)
:: resize the :compiler-cache
::
%_ state
compiler-cache
%- %~ resize
(by-clock compiler-cache-key build-result)
compiler-cache.state
compiler-cache-size
==
:: +cancel: cancel a build
::
:: When called on a live build, removes all tracking related to the live
:: build, and no more %made moves will be sent for that build.
::
:: When called on a once build, removes all tracking related to the once
:: build, and that build will never be completed or have a %made sent.
::
:: When called on a build that isn't registered in :state, such as a
:: completed once build, or a build that has already been canceled,
:: prints and no-ops.
::
++ cancel ^+ [moves state]
::
=< finalize
::
?~ duct-status=(~(get by ducts.state) duct)
~& [%no-build-for-duct duct]
..execute
:: :duct is being canceled, so remove it unconditionally
::
=. ducts.state (~(del by ducts.state) duct)
:: if the duct was not live, cancel any in-progress builds
::
?: ?=(%once -.live.u.duct-status)
::
=/ root-build=build [in-progress.live root-schematic]:u.duct-status
::
=. ..execute (cancel-scrys root-build)
=. state (remove-anchor-from-root root-build [%duct duct])
..execute
:: if the duct was live and has an unfinished build, cancel it
::
=? ..execute ?=(^ in-progress.live.u.duct-status)
::
=/ root-build=build [u.in-progress.live root-schematic]:u.duct-status
::
=. ..execute (cancel-scrys root-build)
=. state (remove-anchor-from-root root-build [%duct duct])
..execute
:: if there is no completed build for the live duct, we're done
::
?~ last-sent=last-sent.live.u.duct-status
..execute
:: there is a completed build for the live duct, so delete it
::
=/ root-build=build [date.u.last-sent root-schematic.u.duct-status]
::
=. state (remove-anchor-from-root root-build [%duct duct])
::
?~ subscription.u.last-sent
..execute
(cancel-clay-subscription u.subscription.u.last-sent)
:: +cancel-scrys: cancel all blocked %scry sub-builds of :root-builds
::
++ cancel-scrys
|= root-build=build
^+ ..execute
::
=/ blocked-sub-scrys ~(tap in (collect-blocked-sub-scrys root-build))
::
|- ^+ ..execute
?~ blocked-sub-scrys ..execute
::
=. ..execute (cancel-scry-request i.blocked-sub-scrys)
::
$(blocked-sub-scrys t.blocked-sub-scrys)
:: +move-root-to-cache: replace :duct with a %cache anchor in :build's tree
::
++ move-root-to-cache
~/ %move-root-to-cache
|= =build
^+ state
:: obtain the new cache id and increment the :next-anchor-id in the state
::
=^ new-id next-anchor-id.build-cache.state
=/ id=@ud next-anchor-id.build-cache.state
[id +(id)]
:: replace the requester in the root build
::
=. builds.state
%+ ~(jab by builds.state) build
|= =build-status
%_ build-status
requesters
=- (~(del in -) [%duct duct])
=- (~(put in -) [%cache new-id])
requesters.build-status
==
:: enqueue :build into cache, possibly popping and deleting a stale build
::
=^ oldest queue.build-cache.state
%. [new-id build]
~(put (to-capped-queue build-cache-key) queue.build-cache.state)
::
=? state
?=(^ oldest)
(remove-anchor-from-root root-build.u.oldest [%cache id.u.oldest])
:: recursively replace :clients in :build and descendants
::
|- ^+ state
::
=/ client-status=build-status (~(got by builds.state) build)
=/ subs=(list ^build) ~(tap in ~(key by subs.client-status))
::
|- ^+ state
?~ subs state
::
=. builds.state
%+ ~(jab by builds.state) i.subs
|= =build-status
%_ build-status
clients
:: if we've already encountered :i.subs, don't overwrite
::
?: (~(has by clients.build-status) [%cache new-id])
clients.build-status
::
=/ old-clients-on-duct (~(get ju clients.build-status) [%duct duct])
::
=- (~(del by -) [%duct duct])
=- (~(put by -) [%cache new-id] old-clients-on-duct)
clients.build-status
==
::
=. state ^$(build i.subs)
::
$(subs t.subs)
:: +remove-anchor-from-root: remove :anchor from :build's tree
::
++ remove-anchor-from-root
~/ %remove-anchor-from-root
|= [=build =anchor]
^+ state
::
=. builds.state
%+ ~(jab by builds.state) build
|= =build-status
build-status(requesters (~(del in requesters.build-status) anchor))
::
=. builds.state (remove-anchor-from-subs build anchor)
::
(cleanup build)
:: +remove-anchor-from-subs: recursively remove :anchor from sub-builds
::
++ remove-anchor-from-subs
~/ %remove-anchor-from-subs
|= [=build =anchor]
^+ builds.state
::
=/ =build-status (~(got by builds.state) build)
=/ subs=(list ^build) ~(tap in ~(key by subs.build-status))
=/ client=^build build
::
|- ^+ builds.state
?~ subs builds.state
::
=/ sub-status=^build-status (~(got by builds.state) i.subs)
::
=. clients.sub-status
(~(del ju clients.sub-status) anchor client)
::
=. builds.state (~(put by builds.state) i.subs sub-status)
::
=? builds.state !(~(has by clients.sub-status) anchor)
::
^$(build i.subs)
::
$(subs t.subs)
:: +add-anchors-to-build-subs: for each sub, add all of :build's anchors
::
++ add-anchors-to-build-subs
~/ %add-anchors-to-build-subs
|= =build
^+ state
::
=/ =build-status (~(got by builds.state) build)
=/ new-anchors
~(tap in (~(put in ~(key by clients.build-status)) [%duct duct]))
=/ subs ~(tap in ~(key by subs.build-status))
::
=. state
|-
^+ state
?~ subs state
::
=. state (add-build i.subs)
::
$(subs t.subs)
::
=. builds.state
|- ^+ builds.state
?~ new-anchors builds.state
::
=. builds.state (add-anchor-to-subs i.new-anchors build)
::
$(new-anchors t.new-anchors)
::
state
:: +add-anchor-to-subs: attach :duct to :build's descendants
::
++ add-anchor-to-subs
~/ %add-anchor-to-subs
|= [=anchor =build]
^+ builds.state
::
=/ =build-status (~(got by builds.state) build)
=/ subs=(list ^build) ~(tap in ~(key by subs.build-status))
=/ client=^build build
::
|- ^+ builds.state
?~ subs builds.state
::
=/ sub-status=^build-status (~(got by builds.state) i.subs)
::
=/ already-had-anchor=? (~(has by clients.sub-status) anchor)
::
=. clients.sub-status
(~(put ju clients.sub-status) anchor client)
::
=. builds.state (~(put by builds.state) i.subs sub-status)
::
=? builds.state !already-had-anchor ^$(build i.subs)
::
$(subs t.subs)
:: +copy-build-tree-as-provisional: prepopulate new live build
::
:: Make a provisional copy of the completed old root build tree at the
:: :new time.
::
++ copy-build-tree-as-provisional
~/ %copy-build-tree-as-provisional
|= [old-root=build new-date=@da]
^+ state
~| [old-root=(build-to-tape old-root) new-date=new-date]
::
=/ old-client=build old-root
=/ new-client=build old-client(date new-date)
=. state (add-build new-client)
::
=. builds.state
%+ ~(jab by builds.state) new-client
|= =build-status
build-status(requesters (~(put in requesters.build-status) [%duct duct]))
::
=< copy-node
::
|%
++ copy-node
^+ state
::
=/ old-build-status=build-status
~| old-client=(build-to-tape old-client)
(~(got by builds.state) old-client)
::
=/ old-subs=(list build) ~(tap in ~(key by subs.old-build-status))
=/ new-subs=(list build) (turn old-subs |=(a=build a(date new-date)))
::
=. builds.state
(add-subs-to-client new-client new-subs [verified=%.n blocked=%.y])
::
|-
^+ state
?~ old-subs
state
::
=. state (add-client-to-sub i.old-subs)
=. state
copy-node(old-client i.old-subs, new-client i.old-subs(date new-date))
::
$(old-subs t.old-subs)
::
++ add-client-to-sub
|= old-sub=build
^+ state
::
=/ new-sub old-sub(date new-date)
=. state (add-build new-sub)
::
=. builds.state
%+ ~(jab by builds.state) new-sub
|= =build-status
%_ build-status
clients (~(put ju clients.build-status) [%duct duct] new-client)
==
::
state
--
:: +add-subs-to-client: register :new-subs as subs of :new-client
::
++ add-subs-to-client
~/ %add-subs-to-client
|= [new-client=build new-subs=(list build) =build-relation]
^+ builds.state
::
%+ ~(jab by builds.state) new-client
|= =build-status
%_ build-status
subs
%- ~(gas by subs.build-status)
%+ murn new-subs
|= sub=build
^- (unit (pair build ^build-relation))
::
?^ (~(get by subs.build-status) sub)
~
`[sub build-relation]
==
:: |construction: arms for performing builds
::
::+| construction
::
:: +execute-loop: +execute repeatedly until there's no more work to do
::
:: Keep running +execute until all relevant builds either complete or
:: block on external resource requests. See +execute for details of each
:: loop execution.
::
:: This implementation is for simplicity. In the longer term, we'd
:: like to just perform a single run through +execute and set a Behn timer
:: to wake us up immediately. This has the advantage that Ford stops hard
:: blocking the main Urbit event loop, letting other work be done.
::
++ execute-loop
~/ %execute-loop
|= builds=(set build)
^+ ..execute
::
=. ..execute (execute builds)
::
?: ?& ?=(~ next-builds)
?=(~ candidate-builds)
==
..execute
::
$(builds ~)
:: +execute: main recursive construction algorithm
::
:: Performs the three step build process: First, figure out which builds
:: we're going to run this loop through the ford algorithm. Second, run
:: the gathered builds, possibly in parallel. Third, apply the
:: +build-receipt algorithms to the ford state.
::
++ execute
~/ %execute
|= builds=(set build)
^+ ..execute
::
=. ..execute (gather builds force=%.n)
::
=^ build-receipts ..execute run-builds
::
(reduce build-receipts)
:: +gather: collect builds to be run in a batch
::
:: The +gather phase is the first of the three parts of +execute. In
:: +gather, we look through each item in :candidate-builds. If we
:: should run the candidate build this cycle through the +execute loop, we
:: place it in :next-builds. +gather runs until it has no more candidates.
::
++ gather
~/ %gather
|= [builds=(set build) force=?]
^+ ..execute
:: add builds that were triggered by incoming event to the candidate list
::
=. candidate-builds (~(uni in candidate-builds) builds)
::
|^ ^+ ..execute
::
?: =(~ candidate-builds)
..execute
::
=/ next=build
?< ?=(~ candidate-builds)
n.candidate-builds
=. candidate-builds (~(del in candidate-builds) next)
::
$(..execute (gather-build next))
:: +gather-build: looks at a single candidate build
::
:: This gate inspects a single build. It might move it to :next-builds,
:: or promote it using an old build. It also might add this build's
:: sub-builds to :candidate-builds.
::
++ gather-build
|= =build
^+ ..execute
~| [%duct duct]
=/ duct-status (~(got by ducts.state) duct)
:: if we already have a result for this build, don't rerun the build
::
=^ current-result builds.state (access-build-record build)
::
?: ?=([~ %value *] current-result)
(on-build-complete build)
:: place :build in :builds.state if it isn't already there
::
=. state (add-build build)
:: ignore blocked builds
::
=/ =build-status (~(got by builds.state) build)
?: ?=(%blocked -.state.build-status)
=. state (add-anchors-to-build-subs build)
::
=/ sub-scrys=(list scry-request)
~(tap in (collect-blocked-sub-scrys build))
::
=. pending-scrys.state
|- ^+ pending-scrys.state
?~ sub-scrys pending-scrys.state
::
=. pending-scrys.state
(put-request pending-scrys.state i.sub-scrys duct)
::
$(sub-scrys t.sub-scrys)
::
..execute
:: old-build: most recent previous build with :schematic.build
::
=/ old-build=(unit ^build)
?: ?& ?=(%live -.live.duct-status)
?=(^ last-sent.live.duct-status)
==
:: check whether :build was run as part of the last live build tree
::
:: If we had build this schematic as part of the build tree
:: during the last run of this live build, then we can compare
:: our result to that build. It might not be the most recent,
:: but if our sub-builds have the same results as they did then,
:: we can promote them. This is especially helpful for a %scry
:: build, because we don't have to make a new request for the
:: resource if the last live build subscribed to it.
::
:: Otherwise, default to looking up the most recent build of this
:: schematic in :builds-by-schematic.state. We'll have to rerun
:: any %scry sub-builds, but other than that, we should still be
:: able to promote its result if its sub-builds have the same
:: results as ours.
::
=/ possible-build=^build
[date.u.last-sent.live.duct-status schematic.build]
?: (~(has by builds.state) possible-build)
`possible-build
(~(find-previous by-schematic builds-by-schematic.state) build)
(~(find-previous by-schematic builds-by-schematic.state) build)
:: if no previous builds exist, we need to run :build
::
?~ old-build
(add-build-to-next build)
::
=/ old-build-status=^build-status
~| [%missing-old-build (build-to-tape u.old-build)]
~| [%build-state (turn ~(tap in ~(key by builds.state)) build-to-tape)]
(~(got by builds.state) u.old-build)
:: selectively promote scry builds
::
:: We can only promote a scry if it's not forced and we ran the same
:: scry schematic as a descendant of the root build schematic at the
:: last sent time for this duct.
::
?: ?& ?=(%scry -.schematic.build)
?| force
?!
?& ?=(%live -.live.duct-status)
?=(^ last-sent.live.duct-status)
::
=/ subscription=(unit subscription)
subscription.u.last-sent.live.duct-status
::
?~ subscription
%.n
%- ~(has in resources.u.subscription)
resource.schematic.build
== == ==
(add-build-to-next build)
:: if we don't have :u.old-build's result cached, we need to run :build
::
=^ old-build-record builds.state (access-build-record u.old-build)
?. ?=([~ %value *] old-build-record)
(add-build-to-next build)
::
=. old-build-status (~(got by builds.state) u.old-build)
::
=/ old-subs=(list ^build) ~(tap in ~(key by subs.old-build-status))
=/ new-subs=(list ^build)
(turn old-subs |=(^build +<(date date.build)))
:: link sub-builds provisionally, blocking on incomplete
::
:: We don't know that :build will end up depending on :new-subs,
:: so they're not :verified.
::
=/ split-new-subs
%+ skid new-subs
|= sub=^build
^- ?
::
?~ maybe-build-status=(~(get by builds.state) sub)
%.n
::
?& ?=(%complete -.state.u.maybe-build-status)
?=(%value -.build-record.state.u.maybe-build-status)
==
::
=/ stored-new-subs=(list ^build) -.split-new-subs
=/ un-stored-new-subs=(list ^build) +.split-new-subs
::
=. builds.state
(add-subs-to-client build stored-new-subs [verified=%.n blocked=%.n])
=. builds.state
(add-subs-to-client build un-stored-new-subs [verified=%.n blocked=%.y])
::
=. state (add-anchors-to-build-subs build)
::
?^ un-stored-new-subs
:: enqueue incomplete sub-builds to be promoted or run
::
:: When not all our sub builds have results, we can't add :build to
:: :next-builds.state. Instead, put all the remaining uncached new
:: subs into :candidate-builds.
::
:: If all of our sub-builds finish immediately (i.e. promoted) when
:: they pass through +gather-internal, they will add :build back to
:: :candidate-builds and we will run again before +execute runs
:: +make.
::
%_ ..execute
candidate-builds
(~(gas in candidate-builds) un-stored-new-subs)
==
::
=^ promotable builds.state (are-subs-unchanged old-subs new-subs)
?. promotable
(add-build-to-next build)
::
?> =(schematic.build schematic.u.old-build)
?> (~(has by builds.state) build)
(promote-build u.old-build date.build new-subs)
:: +are-subs-unchanged: checks sub-build equivalence, updating access time
::
++ are-subs-unchanged
|= [old-subs=(list build) new-subs=(list build)]
^- [? _builds.state]
::
?~ old-subs
[%.y builds.state]
?> ?=(^ new-subs)
::
=^ old-build-record builds.state (access-build-record i.old-subs)
?. ?=([~ %value *] old-build-record)
[%.n builds.state]
::
=^ new-build-record builds.state (access-build-record i.new-subs)
?. ?=([~ %value *] new-build-record)
[%.n builds.state]
::
?. =(build-result.u.old-build-record build-result.u.new-build-record)
[%.n builds.state]
$(new-subs t.new-subs, old-subs t.old-subs)
:: +add-build-to-next: run this build during the +make phase
::
++ add-build-to-next
|= =build
..execute(next-builds (~(put in next-builds) build))
:: +promote-build: promote result of :build to newer :date
::
:: Also performs relevant accounting, and possibly sends %made moves.
::
++ promote-build
|= [old-build=build new-date=@da new-subs=(list build)]
^+ ..execute
:: grab the previous result, freshening the cache
::
=^ old-build-record builds.state (access-build-record old-build)
:: we can only promote a cached result, not missing or a %tombstone
::
?> ?=([~ %value *] old-build-record)
=/ =build-result build-result.u.old-build-record
:: :new-build is :old-build at :date; promotion destination
::
=/ new-build=build old-build(date new-date)
::
=. builds.state
%+ ~(jab by builds.state) new-build
|= =build-status
^+ build-status
::
%_ build-status
:: verify linkages between :new-build and subs
::
subs
::
^- (map build build-relation)
%- my
^- (list (pair build build-relation))
%+ turn new-subs
|= sub=build
::
[sub [verified=& blocked=|]]
:: copy the old result to :new-build
::
state
[%complete [%value last-accessed=now build-result=build-result]]
==
::
(on-build-complete new-build)
--
:: +run-builds: run the builds and produce +build-receipts
::
:: Runs the builds and cleans up the build lists afterwards.
::
:: When the vere interpreter has a parallel variant of +turn, use
:: that as each build might take a while and there are no data
:: dependencies between builds here. For now, though, run them serially.
::
++ run-builds
~% %run-builds + ~
|-
^- [(list build-receipt) _..execute]
::
=/ build-receipts=(list build-receipt)
(turn ~(tap in next-builds) make)
::
=. next-builds ~
[build-receipts ..execute]
:: reduce: apply +build-receipts produce from the +make phase.
::
:: +gather produces builds to run make on. +make produces
:: +build-receipts. It is in +reduce where we take these +build-receipts
:: and apply them to ..execute.
::
++ reduce
~/ %reduce
|= build-receipts=(list build-receipt)
^+ ..execute
:: sort :build-receipts so blocks are processed before completions
::
:: It's possible for a build to block on a sub-build that was run
:: in the same batch. If that's the case, make sure we register
:: that the build blocked on the sub-build before registering the
:: completion of the sub-build. This way, when we do register the
:: completion of the sub-build, we will know which builds are blocked
:: on the sub-build, so we can enqueue those blocked clients to be
:: rerun.
::
=. build-receipts
%+ sort build-receipts
|= [a=build-receipt b=build-receipt]
^- ?
?=(%blocks -.result.a)
::
|^ ^+ ..execute
?~ build-receipts ..execute
::
=. ..execute (apply-build-receipt i.build-receipts)
$(build-receipts t.build-receipts)
:: +apply-build-receipt: applies a single state diff to ..execute
::
++ apply-build-receipt
|= made=build-receipt
^+ ..execute
:: process :sub-builds.made
::
=. state (track-sub-builds build.made sub-builds.made)
::
?- -.result.made
%build-result
(apply-build-result [build build-result.result cache-access]:made)
::
%blocks
(apply-blocks [build builds.result]:made)
==
:: +track-sub-builds:
::
:: For every sub-build discovered while running :build, we have to make
:: sure that we track that sub-build and that it is associated with the
:: right ducts.
::
++ track-sub-builds
|= [client=build sub-builds=(list build)]
^+ state
:: mark :sub-builds as :subs in :build's +build-status
::
=^ build-status builds.state
%+ update-build-status client
|= =build-status
%_ build-status
subs
%- ~(gas by subs.build-status)
%+ turn sub-builds
|= sub=build
::
=/ blocked=?
?~ sub-status=(~(get by builds.state) sub)
%.y
!?=([%complete %value *] state.u.sub-status)
::
[sub [verified=& blocked]]
==
::
=. state (add-anchors-to-build-subs client)
::
|- ^+ state
?~ sub-builds state
::
=. builds.state
%+ ~(jab by builds.state) i.sub-builds
|= build-status=^build-status
%_ build-status
:: freshen :last-accessed date
::
state
::
?. ?=([%complete %value *] state.build-status)
state.build-status
state.build-status(last-accessed.build-record now)
==
::
$(sub-builds t.sub-builds)
:: +apply-build-result: apply a %build-result +build-receipt to ..execute
::
:: Our build produced an actual result.
::
++ apply-build-result
|= [=build =build-result cache-access=(unit [=compiler-cache-key new=?])]
^+ ..execute
::
=? compiler-cache.state ?=(^ cache-access)
=+ by-clock=(by-clock compiler-cache-key ^build-result)
?. new.u.cache-access
=^ ignored compiler-cache.state
(~(get by-clock compiler-cache.state) compiler-cache-key.u.cache-access)
compiler-cache.state
::
%+ ~(put by-clock compiler-cache.state)
compiler-cache-key.u.cache-access
build-result
::
=. builds.state
%+ ~(jab by builds.state) build
|= =build-status
build-status(state [%complete [%value last-accessed=now build-result]])
::
(on-build-complete build)
:: +apply-blocks: apply a %blocks +build-receipt to ..execute
::
:: :build blocked. Record information about what builds it blocked on
:: and try those blocked builds as candidates in the next pass.
::
++ apply-blocks
|= [=build blocks=(list build)]
^+ ..execute
:: if a %scry blocked, register it and maybe send an async request
::
=? ..execute
?=(~ blocks)
?> ?=(%scry -.schematic.build)
=, resource.schematic.build
%- start-scry-request
[vane care [[ship.disc.rail desk.disc.rail [%da date.build]] spur.rail]]
:: we must run +apply-build-receipt on :build.made before :block
::
?< %+ lien blocks
|= block=^build
?~ maybe-build-status=(~(get by builds.state) block)
%.n
?=(%complete -.state.u.maybe-build-status)
:: transition :build's state machine to the %blocked state
::
=. builds.state
%+ ~(jab by builds.state) build
|= =build-status
build-status(state [%blocked ~])
:: enqueue :blocks to be run next
::
=. candidate-builds (~(gas in candidate-builds) blocks)
::
..execute
--
:: +make: attempt to perform :build, non-recursively
::
:: Registers component linkages between :build and its sub-builds.
:: Attempts to perform +scry if necessary. Does not directly enqueue
:: any moves.
::
++ make
~/ %make
|= =build
^- build-receipt
:: out: receipt to return to caller
::
=| out=build-receipt
:: ~& [%turbo-make (build-to-tape build)]
:: dispatch based on the kind of +schematic in :build
::
|^ =, schematic.build
::
=. build.out build
::
?- -.schematic.build
::
^ (make-autocons [head tail])
::
%$ (make-literal literal)
::
%pin (make-pin date schematic)
%alts (make-alts choices ~)
%bake (make-bake renderer query-string path-to-render)
%bunt (make-bunt disc mark)
%call (make-call gate sample)
%cast (make-cast disc mark input)
%core (make-core source-path)
%diff (make-diff disc start end)
%dude (make-dude error attempt)
%hood (make-hood source-path)
%join (make-join disc mark first second)
%list (make-list schematics)
%mash (make-mash disc mark first second)
%mute (make-mute subject mutations)
%pact (make-pact disc start diff)
%path (make-path disc prefix raw-path)
%plan (make-plan path-to-render query-string scaffold)
%reef (make-reef disc)
%ride (make-ride formula subject)
%same (make-same schematic)
%scry (make-scry resource)
%slim (make-slim subject-type formula)
%slit (make-slit gate sample)
%vale (make-vale disc mark input)
%volt (make-volt disc mark input)
%walk (make-walk disc source target)
==
:: |schematic-handlers:make: implementation of the schematics
::
:: All of these produce a value of the same type as +make itself.
::
:: +| schematic-handlers
::
++ make-autocons
~% %make-autocons ..^^$ ~
|= [head=schematic tail=schematic]
^- build-receipt
::
=/ head-build=^build [date.build head]
=/ tail-build=^build [date.build tail]
=^ head-result out (depend-on head-build)
=^ tail-result out (depend-on tail-build)
::
=| blocks=(list ^build)
=? blocks ?=(~ head-result) [head-build blocks]
=? blocks ?=(~ tail-result) [tail-build blocks]
:: if either build blocked, we're not done
::
?^ blocks
::
(return-blocks blocks)
::
?< ?=(~ head-result)
?< ?=(~ tail-result)
::
(return-result %success u.head-result u.tail-result)
::
++ make-literal
~% %make-literal ..^^$ ~
|= =cage
^- build-receipt
(return-result %success %$ cage)
::
++ make-pin
~% %make-pin ..^^$ ~
|= [date=@da =schematic]
^- build-receipt
:: pinned-sub: sub-build with the %pin date as formal date
::
=/ pinned-sub=^build [date schematic]
::
=^ result out (depend-on pinned-sub)
::
?~ result
(return-blocks ~[pinned-sub])
::
(return-result u.result)
::
++ make-alts
~% %make-alts ..^^$ ~
|= [choices=(list schematic) errors=(list tank)]
^- build-receipt
::
?~ choices
(return-error [[%leaf "%alts: all options failed"] errors])
::
=/ choice=^build [date.build i.choices]
::
=^ result out (depend-on choice)
?~ result
(return-blocks ~[choice])
::
?: ?=([%error *] u.result)
::
=/ braces [[' ' ' ' ~] ['{' ~] ['}' ~]]
=/ wrapped-error=tank
[%rose braces `(list tank)`message.u.result]
=. errors
(weld errors `(list tank)`[[%leaf "option"] wrapped-error ~])
$(choices t.choices)
::
(return-result %success %alts u.result)
::
++ make-bake
~% %make-bake ..^^$ ~
|= [renderer=term query-string=coin path-to-render=rail]
^- build-receipt
:: path-build: find the file path for the renderer source
::
=/ path-build=^build
[date.build [%path disc.path-to-render %ren renderer]]
::
=^ path-result out (depend-on path-build)
?~ path-result
(return-blocks [path-build]~)
::
|^ ^- build-receipt
:: if there's a renderer called :renderer, use it on :path-to-render
::
:: Otherwise, fall back to running the contents of :path-to-render
:: through a mark that has the same name as :renderer.
::
?: ?=([~ %success %path *] path-result)
(try-renderer-then-mark rail.u.path-result)
(try-mark ~)
:: +try-renderer-then-mark: try to render a path, then fall back to mark
::
++ try-renderer-then-mark
|= =rail
^- build-receipt
:: build a +scaffold from the renderer source
::
=/ hood-build=^build [date.build [%hood rail]]
::
=^ hood-result out (depend-on hood-build)
?~ hood-result
(return-blocks [hood-build]~)
:: if we can't find and parse the renderer, try the mark instead
::
?: ?=([~ %error *] hood-result)
(try-mark message.u.hood-result)
?> ?=([~ %success %hood *] hood-result)
:: link the renderer, passing through :path-to-render and :query-string
::
=/ plan-build=^build
:- date.build
[%plan path-to-render query-string scaffold.u.hood-result]
::
=^ plan-result out (depend-on plan-build)
?~ plan-result
(return-blocks [plan-build]~)
:: if compiling the renderer errors out, try the mark instead
::
?: ?=([~ %error *] plan-result)
(try-mark message.u.plan-result)
?> ?=([~ %success %plan *] plan-result)
:: renderers return their name as the mark
::
:: We should rethink whether we want this to be the case going
:: forward, but for now, Eyre depends on this detail to work.
::
(return-result [%success %bake renderer vase.u.plan-result])
:: +try-mark: try to cast a file's contents through a mark
::
:: :errors contains any error messages from our previous attempt to
:: run a renderer, if we made one. This way if both the renderer and
:: mark fail, the requester will see the errors of both attempts.
::
++ try-mark
|= errors=(list tank)
^- build-receipt
:: no renderer, try mark; retrieve directory listing of :path-to-render
::
:: There might be multiple files of different marks stored at
:: :path-to-render. Retrieve the directory listing for
:: :path-to-render, then check which of the path segments in
:: that directory are files (not just folders), then for each
:: file try to %cast its mark to the desired mark (:renderer).
::
:: Start by retrieving the directory listing, using :toplevel-build.
::
=/ toplevel-build=^build
[date.build [%scry %c %y path-to-render]]
::
=^ toplevel-result out (depend-on toplevel-build)
?~ toplevel-result
(return-blocks [toplevel-build]~)
::
?: ?=([~ %error *] toplevel-result)
::
=/ =path (rail-to-path path-to-render)
?~ errors
%- return-error
:- [%leaf "ford: %bake {<renderer>} on {<path>} failed:"]
message.u.toplevel-result
::
=/ braces [[' ' ' ' ~] ['{' ~] ['}' ~]]
%- return-error :~
[%leaf "ford: %bake {<renderer>} on {<path>} failed:"]
[%leaf "as-renderer"]
[%rose braces errors]
[%leaf "as-mark"]
[%rose braces message.u.toplevel-result]
==
?> ?=([~ %success %scry *] toplevel-result)
::
=/ toplevel-arch=arch ;;(arch q.q.cage.u.toplevel-result)
:: find the :sub-path-segments that could be files
::
:: Filter out path segments that aren't a +term,
:: since those aren't valid marks and therefore can't
:: be the last segment of a filepath in Clay.
::
=/ sub-path-segments=(list @ta)
(skim (turn ~(tap by dir.toplevel-arch) head) (sane %tas))
::
=/ sub-schematics=(list [sub-path=@ta =schematic])
%+ turn sub-path-segments
|= sub=@ta
:- sub
[%scry %c %y path-to-render(spur [sub spur.path-to-render])]
::
=^ maybe-schematic-results out
%- perform-schematics :*
"ford: %bake {<renderer>} on {<path>} contained failures:"
sub-schematics
%fail-on-errors
*@ta
==
?~ maybe-schematic-results
out
:: marks: list of the marks of the files at :path-to-render
::
=/ marks=(list @tas)
%+ murn u.maybe-schematic-results
|= [sub-path=@ta result=build-result]
^- (unit @tas)
::
?> ?=([%success %scry *] result)
::
=/ =arch ;;(arch q.q.cage.result)
:: if it's a directory, not a file, we can't load it
::
?~ fil.arch
~
[~ `@tas`sub-path]
:: sort marks in alphabetical order
::
=. marks (sort marks lte)
:: try to convert files to the destination mark, in order
::
=/ alts-build=^build
::
:+ date.build %alts
^= choices ^- (list schematic)
::
%+ turn marks
|= mark=term
^- schematic
::
=/ file=rail path-to-render(spur [mark spur.path-to-render])
::
[%cast disc.file renderer [%scry %c %x file]]
::
=^ alts-result out (depend-on alts-build)
?~ alts-result
(return-blocks [alts-build]~)
::
?: ?=([~ %error *] alts-result)
=/ =path (rail-to-path path-to-render)
?~ errors
%- return-error
:- [%leaf "ford: %bake {<renderer>} on {<path>} failed:"]
message.u.alts-result
::
=/ braces [[' ' ' ' ~] ['{' ~] ['}' ~]]
%- return-error :~
[%leaf "ford: %bake {<renderer>} on {<path>} failed:"]
[%leaf "as-renderer"]
[%rose braces errors]
[%leaf "as-mark"]
[%rose braces message.u.alts-result]
==
::
?> ?=([~ %success %alts *] alts-result)
::
=/ =build-result
[%success %bake (result-to-cage u.alts-result)]
::
(return-result build-result)
--
::
++ make-bunt
~% %make-bunt ..^^$ ~
|= [=disc mark=term]
^- build-receipt
:: resolve path of the mark definition file
::
=/ path-build=^build [date.build [%path disc %mar mark]]
::
=^ path-result out (depend-on path-build)
?~ path-result
(return-blocks [path-build]~)
::
?: ?=([~ %error *] path-result)
%- return-error
:_ message.u.path-result
:- %leaf
"ford: %bunt resolving path for {<mark>} on {<disc>} failed:"
::
?> ?=([~ %success %path *] path-result)
:: build the mark core from source
::
=/ core-build=^build [date.build [%core rail.u.path-result]]
::
=^ core-result out (depend-on core-build)
?~ core-result
(return-blocks [core-build]~)
::
?: ?=([~ %error *] core-result)
%- return-error
:_ message.u.core-result
:- %leaf
"ford: %bunt compiling mark {<mark>} on {<disc>} failed:"
::
?> ?=([~ %success %core *] core-result)
:: extract the sample from the mark core
::
=/ mark-vase=vase vase.u.core-result
~| %mark-vase
=+ [sample-type=p sample-value=q]:(slot 6 mark-vase)
:: if sample is wrapped in a face, unwrap it
::
=? sample-type ?=(%face -.sample-type) q.sample-type
::
=/ =cage [mark sample-type sample-value]
(return-result %success %bunt cage)
::
++ make-call
~% %make-call ..^^$ ~
|= [gate=schematic sample=schematic]
^- build-receipt
::
=/ gate-build=^build [date.build gate]
=^ gate-result out (depend-on gate-build)
::
=/ sample-build=^build [date.build sample]
=^ sample-result out (depend-on sample-build)
::
=| blocks=(list ^build)
=? blocks ?=(~ gate-result) [[date.build gate] blocks]
=? blocks ?=(~ sample-result) [[date.build sample] blocks]
?^ blocks
(return-blocks blocks)
::
?< ?=(~ gate-result)
?: ?=([~ %error *] gate-result)
%- return-error
:- [%leaf "ford: %call failed to build gate:"]
message.u.gate-result
::
?< ?=(~ sample-result)
?: ?=([~ %error *] sample-result)
%- return-error
:- [%leaf "ford: %call failed to build sample:"]
message.u.sample-result
::
=/ gate-vase=vase q:(result-to-cage u.gate-result)
=/ sample-vase=vase q:(result-to-cage u.sample-result)
:: run %slit to get the resulting type of calculating the gate
::
=/ slit-schematic=schematic [%slit gate-vase sample-vase]
=/ slit-build=^build [date.build slit-schematic]
=^ slit-result out (depend-on slit-build)
?~ slit-result
(return-blocks [date.build slit-schematic]~)
::
?: ?=([~ %error *] slit-result)
%- return-error
:- [%leaf "ford: %call failed type calculation"]
message.u.slit-result
::
?> ?=([~ %success %slit *] slit-result)
::
=/ =compiler-cache-key [%call gate-vase sample-vase]
=^ cached-result out (access-cache compiler-cache-key)
?^ cached-result
(return-result u.cached-result)
::
?> &(?=(^ q.gate-vase) ?=(^ +.q.gate-vase))
=/ val
(mong [q.gate-vase q.sample-vase] intercepted-scry)
::
?- -.val
%0
(return-result %success %call [type.u.slit-result p.val])
::
%1
=/ blocked-paths=(list path) ((hard (list path)) p.val)
(blocked-paths-to-receipt %call blocked-paths)
::
%2
(return-error [[%leaf "ford: %call execution failed:"] p.val])
==
::
++ make-cast
~% %make-cast ..^^$ ~
|= [=disc mark=term input=schematic]
^- build-receipt
::
=/ input-build=^build [date.build input]
::
=^ input-result out (depend-on input-build)
?~ input-result
(return-blocks [input-build]~)
::
?: ?=([~ %error *] input-result)
%- return-error
:- [%leaf "ford: %cast {<mark>} on {<disc>} failed on input:"]
message.u.input-result
::
?> ?=([~ %success *] input-result)
::
=/ result-cage=cage (result-to-cage u.input-result)
::
=/ translation-path-build=^build
[date.build [%walk disc p.result-cage mark]]
=^ translation-path-result out
(depend-on translation-path-build)
::
?~ translation-path-result
(return-blocks [translation-path-build]~)
::
?: ?=([~ %error *] translation-path-result)
%- return-error
:- [%leaf "ford: %cast {<mark>} on {<disc>} failed:"]
message.u.translation-path-result
::
?> ?=([~ %success %walk *] translation-path-result)
::
=/ translation-path=(list mark-action)
results.u.translation-path-result
::
|^ ^- build-receipt
?~ translation-path
(return-result %success %cast result-cage)
::
=^ action-result out
=, i.translation-path
?- -.i.translation-path
%grow (run-grow source target result-cage)
%grab (run-grab source target result-cage)
==
::
?- -.action-result
%success
%_ $
translation-path t.translation-path
result-cage cage.action-result
==
::
%blocks
(return-blocks blocks.action-result)
::
%error
(return-error [leaf+"ford: failed to %cast" tang.action-result])
==
::
+= action-result
$% :: translation was successful and here's a cage for you
[%success =cage]
:: it was an error. sorry.
[%error =tang]
:: we block on a build
[%blocks blocks=(list ^build)]
==
::
++ run-grab
|= [source-mark=term target-mark=term input-cage=cage]
^- [action-result _out]
::
=/ mark-path-build=^build
[date.build [%path disc %mar target-mark]]
::
=^ mark-path-result out
(depend-on mark-path-build)
?~ mark-path-result
[[%blocks [mark-path-build]~] out]
::
?. ?=([~ %success %path *] mark-path-result)
%- cast-wrap-error :*
source-mark
target-mark
%+ weld
"ford: %cast failed to find path for mark {<source-mark>} "
"during +grab:"
mark-path-result
==
::
=/ mark-core-build=^build [date.build [%core rail.u.mark-path-result]]
::
=^ mark-core-result out (depend-on mark-core-build)
?~ mark-core-result
[[%blocks ~[mark-core-build]] out]
:: find +grab within the destination mark core
::
=/ grab-build=^build
:- date.build
[%ride [%limb %grab] [%$ (result-to-cage u.mark-core-result)]]
::
=^ grab-result out (depend-on grab-build)
?~ grab-result
[[%blocks [grab-build]~] out]
::
?. ?=([~ %success %ride *] grab-result)
=/ =path (rail-to-path rail.u.mark-path-result)
%- cast-wrap-error :*
source-mark
target-mark
"ford: %cast failed to ride {<path>} during +grab:"
grab-result
==
:: find an arm for the input's mark within the +grab core
::
=/ grab-mark-build=^build
:- date.build
[%ride [%limb source-mark] [%$ %noun vase.u.grab-result]]
::
=^ grab-mark-result out (depend-on grab-mark-build)
?~ grab-mark-result
[[%blocks [grab-mark-build]~] out]
::
?. ?=([~ %success %ride *] grab-mark-result)
=/ =path (rail-to-path rail.u.mark-path-result)
%- cast-wrap-error :*
source-mark
target-mark
"ford: %cast failed to ride {<path>} during +grab:"
grab-mark-result
==
:: slam the +mark-name:grab gate on the result of running :input
::
=/ call-build=^build
:- date.build
[%call gate=[%$ %noun vase.u.grab-mark-result] sample=[%$ input-cage]]
::
=^ call-result out (depend-on call-build)
?~ call-result
[[%blocks [call-build]~] out]
::
?. ?=([~ %success %call *] call-result)
=/ =path (rail-to-path rail.u.mark-path-result)
%- cast-wrap-error :*
source-mark
target-mark
"ford: %cast failed to call +grab arm in {<path>}:"
call-result
==
::
[[%success [mark vase.u.call-result]] out]
:: +grow: grow from the input mark to the destination mark
::
++ run-grow
|= [source-mark=term target-mark=term input-cage=cage]
^- [action-result _out]
::
=/ starting-mark-path-build=^build
[date.build [%path disc %mar source-mark]]
::
=^ starting-mark-path-result out
(depend-on starting-mark-path-build)
?~ starting-mark-path-result
[[%blocks [starting-mark-path-build]~] out]
::
?. ?=([~ %success %path *] starting-mark-path-result)
%- cast-wrap-error :*
source-mark
target-mark
%+ weld
"ford: %cast failed to find path for mark {<source-mark>} "
"during +grow:"
starting-mark-path-result
==
:: grow the value from the initial mark to the final mark
::
:: Replace the input mark's sample with the input's result,
:: then fire the mark-name:grow arm to produce a result.
::
=/ grow-build=^build
:- date.build
:+ %ride
formula=`hoon`[%tsld [%wing ~[target-mark]] [%wing ~[%grow]]]
^= subject
^- schematic
:* %mute
^- schematic
[%core rail.u.starting-mark-path-result]
^= mutations
^- (list [wing schematic])
[[%& 6]~ [%$ input-cage]]~
==
::
=^ grow-result out (depend-on grow-build)
?~ grow-result
[[%blocks [grow-build]~] out]
::
?. ?=([~ %success %ride *] grow-result)
=/ =path (rail-to-path rail.u.starting-mark-path-result)
%- cast-wrap-error :*
source-mark
target-mark
"ford: %cast failed to ride {<path>} during +grow:"
grow-result
==
:: make sure the product nests in the sample of the destination mark
::
=/ bunt-build=^build [date.build [%bunt disc target-mark]]
::
=^ bunt-result out (depend-on bunt-build)
?~ bunt-result
[[%blocks [bunt-build]~] out]
::
?. ?=([~ %success %bunt *] bunt-result)
%- cast-wrap-error :*
source-mark
target-mark
"ford: %cast failed to bunt {<target-mark>}:"
bunt-result
==
::
?. (~(nest ut p.q.cage.u.bunt-result) | p.vase.u.grow-result)
=* src source-mark
=* dst target-mark
:_ out
:- %error
[leaf+"ford: %cast from {<src>} to {<dst>} failed: nest fail"]~
::
[[%success mark vase.u.grow-result] out]
::
++ cast-wrap-error
|= $: source-mark=term
target-mark=term
description=tape
result=(unit build-result)
==
^- [action-result _out]
::
?> ?=([~ %error *] result)
::
:_ out
:- %error
:* :- %leaf
%+ weld
"ford: %cast failed while trying to cast from "
"{<source-mark>} to {<target-mark>}:"
[%leaf description]
message.u.result
==
--
::
++ make-core
~% %make-core ..^^$ ~
|= source-path=rail
^- build-receipt
:: convert file at :source-path to a +scaffold
::
=/ hood-build=^build [date.build [%hood source-path]]
::
=^ hood-result out (depend-on hood-build)
?~ hood-result
(return-blocks [hood-build]~)
::
?: ?=(%error -.u.hood-result)
%- return-error
:- [%leaf "ford: %core on {<(rail-to-path source-path)>} failed:"]
message.u.hood-result
:: build the +scaffold into a program
::
?> ?=([%success %hood *] u.hood-result)
::
=/ plan-build=^build
[date.build [%plan source-path `coin`[%many ~] scaffold.u.hood-result]]
::
=^ plan-result out (depend-on plan-build)
?~ plan-result
(return-blocks [plan-build]~)
::
?: ?=(%error -.u.plan-result)
%- return-error
:- [%leaf "ford: %core on {<(rail-to-path source-path)>} failed:"]
message.u.plan-result
::
?> ?=([%success %plan *] u.plan-result)
(return-result %success %core vase.u.plan-result)
::
++ make-diff
~% %make-diff ..^^$ ~
|= [=disc start=schematic end=schematic]
^- build-receipt
:: run both input schematics as an autocons build
::
=/ sub-build=^build [date.build [start end]]
::
=^ sub-result out (depend-on sub-build)
?~ sub-result
(return-blocks [sub-build]~)
::
?. ?=([~ %success ^ ^] sub-result)
(wrap-error sub-result)
?. ?=([%success *] head.u.sub-result)
(wrap-error `head.u.sub-result)
?. ?=([%success *] tail.u.sub-result)
(wrap-error `tail.u.sub-result)
::
=/ start-cage=cage (result-to-cage head.u.sub-result)
=/ end-cage=cage (result-to-cage tail.u.sub-result)
:: if the marks aren't the same, we can't diff them
::
?. =(p.start-cage p.end-cage)
%- return-error :_ ~ :- %leaf
"ford: %diff failed: mark mismatch: %{<p.start-cage>} / %{<p.end-cage>}"
:: if the values are the same, the diff is null
::
?: =(q.q.start-cage q.q.end-cage)
=/ =build-result
[%success %diff [%null [%atom %n ~] ~]]
::
(return-result build-result)
::
=/ mark-path-build=^build [date.build [%path disc %mar p.start-cage]]
::
=^ mark-path-result out (depend-on mark-path-build)
?~ mark-path-result
(return-blocks [mark-path-build]~)
::
?: ?=([~ %error *] mark-path-result)
%- return-error
:- [%leaf "ford: %diff failed on {<disc>}:"]
message.u.mark-path-result
::
?> ?=([~ %success %path *] mark-path-result)
::
=/ mark-build=^build [date.build [%core rail.u.mark-path-result]]
::
=^ mark-result out (depend-on mark-build)
?~ mark-result
(return-blocks [mark-build]~)
::
?: ?=([~ %error *] mark-result)
%- return-error
:- [%leaf "ford: %diff failed on {<disc>}:"]
message.u.mark-result
::
?> ?=([~ %success %core *] mark-result)
::
?. (slab %grad p.vase.u.mark-result)
%- return-error :_ ~ :- %leaf
"ford: %diff failed: %{<p.start-cage>} mark has no +grad arm"
::
=/ grad-build=^build
[date.build [%ride [%limb %grad] [%$ %noun vase.u.mark-result]]]
::
=^ grad-result out (depend-on grad-build)
?~ grad-result
(return-blocks [grad-build]~)
::
?: ?=([~ %error *] grad-result)
%- return-error
:- [%leaf "ford: %diff failed on {<disc>}:"]
message.u.grad-result
::
?> ?=([~ %success %ride *] grad-result)
:: if +grad produced a @tas, convert to that mark and diff those
::
?@ q.vase.u.grad-result
=/ mark=(unit @tas) ((sand %tas) q.vase.u.grad-result)
?~ mark
%- return-error :_ ~ :- %leaf
"ford: %diff failed: %{<p.start-cage>} mark has invalid +grad arm"
::
=/ diff-build=^build
:- date.build
:^ %diff
disc
[%cast disc u.mark [%$ start-cage]]
[%cast disc u.mark [%$ end-cage]]
::
=^ diff-result out (depend-on diff-build)
?~ diff-result
(return-blocks [diff-build]~)
::
?. ?=([~ %success %diff *] diff-result)
(wrap-error diff-result)
::
=/ =build-result
[%success %diff cage.u.diff-result]
::
(return-result build-result)
:: +grad produced a cell, which should be a core with a +form arm
::
?. (slab %form p.vase.u.grad-result)
%- return-error :_ ~ :- %leaf
"ford: %diff failed: %{<p.start-cage>} mark has no +form:grab arm"
:: the +grab core should also contain a +diff arm
::
?. (slab %diff p.vase.u.grad-result)
%- return-error :_ ~ :- %leaf
"ford: %diff failed: %{<p.start-cage>} mark has no +diff:grab arm"
::
=/ diff-build=^build
:- date.build
:+ %call
::
^= gate
:+ %ride
::
formula=`hoon`[%tsld [%wing ~[%diff]] [%wing ~[%grad]]]
::
^= subject
:+ %mute
::
subject=`schematic`[%$ %noun vase.u.mark-result]
::
^= mutations
^- (list [wing schematic])
[[%& 6]~ [%$ start-cage]]~
::
sample=`schematic`[%$ end-cage]
::
=^ diff-result out (depend-on diff-build)
?~ diff-result
(return-blocks [diff-build]~)
::
?. ?=([~ %success %call *] diff-result)
(wrap-error diff-result)
::
=/ form-build=^build
[date.build [%ride [%limb %form] [%$ %noun vase.u.grad-result]]]
::
=^ form-result out (depend-on form-build)
?~ form-result
(return-blocks [form-build]~)
::
?. ?=([~ %success %ride *] form-result)
(wrap-error form-result)
::
=/ mark=(unit @tas) ((soft @tas) q.vase.u.form-result)
?~ mark
%- return-error :_ ~ :- %leaf
"ford: %diff failed: invalid +form result: {(text vase.u.form-result)}"
::
=/ =build-result
[%success %diff [u.mark vase.u.diff-result]]
::
(return-result build-result)
::
++ make-dude
~% %make-dude ..^^$ ~
|= [error=(trap tank) attempt=schematic]
^- build-receipt
::
=/ attempt-build=^build [date.build attempt]
=^ attempt-result out (depend-on attempt-build)
?~ attempt-result
::
(return-blocks ~[[date.build attempt]])
::
?. ?=([%error *] u.attempt-result)
(return-result u.attempt-result)
::
(return-error [$:error message.u.attempt-result])
::
++ make-hood
~% %make-hood ..^^$ ~
|= source-rail=rail
^- build-receipt
::
=/ scry-build=^build [date.build [%scry [%c %x source-rail]]]
=^ scry-result out (depend-on scry-build)
?~ scry-result
::
(return-blocks ~[scry-build])
::
?: ?=([~ %error *] scry-result)
=/ =path (rail-to-path source-rail)
%- return-error
:- [%leaf "ford: %hood failed for {<path>}:"]
message.u.scry-result
=+ as-cage=(result-to-cage u.scry-result)
:: hoon files must be atoms to parse
::
?. ?=(@ q.q.as-cage)
=/ =path (rail-to-path source-rail)
%- return-error
:_ ~
:- %leaf
"ford: %hood: path {<path>} not an atom"
::
=/ src-beam=beam [[ship.disc desk.disc [%ud 0]] spur]:source-rail
::
=/ =compiler-cache-key [%hood src-beam q.q.as-cage]
=^ cached-result out (access-cache compiler-cache-key)
?^ cached-result
(return-result u.cached-result)
::
=/ parsed
((full (parse-scaffold src-beam)) [1 1] (trip q.q.as-cage))
::
?~ q.parsed
=/ =path (rail-to-path source-rail)
%- return-error
:- :- %leaf
%+ weld "ford: %hood: syntax error at "
"[{<p.p.parsed>} {<q.p.parsed>}] in {<path>}"
~
::
(return-result %success %hood p.u.q.parsed)
::
++ make-join
~% %make-join ..^^$ ~
|= [disc=disc mark=term first=schematic second=schematic]
^- build-receipt
::
=/ initial-build=^build
[date.build [first second] [%path disc %mar mark]]
::
=^ initial-result out (depend-on initial-build)
?~ initial-result
(return-blocks [initial-build]~)
::
?. ?=([~ %success [%success ^ ^] %success %path *] initial-result)
(wrap-error initial-result)
?. ?=([%success *] head.head.u.initial-result)
(wrap-error `head.head.u.initial-result)
?. ?=([%success *] tail.head.u.initial-result)
(wrap-error `tail.head.u.initial-result)
::
=/ first-cage=cage (result-to-cage head.head.u.initial-result)
=/ second-cage=cage (result-to-cage tail.head.u.initial-result)
=/ mark-path=rail rail.tail.u.initial-result
:: TODO: duplicate logic with +make-pact and others
::
=/ mark-build=^build [date.build [%core mark-path]]
::
=^ mark-result out (depend-on mark-build)
?~ mark-result
(return-blocks [mark-build]~)
::
?: ?=([~ %error *] mark-result)
%- return-error
:- [%leaf "ford: %join to {<mark>} on {<disc>} failed:"]
message.u.mark-result
::
?> ?=([~ %success %core *] mark-result)
::
=/ mark-vase=vase vase.u.mark-result
::
?. (slab %grad p.mark-vase)
%- return-error :_ ~ :- %leaf
"ford: %join failed: %{<mark>} mark has no +grad arm"
::
=/ grad-build=^build
[date.build [%ride [%limb %grad] [%$ %noun mark-vase]]]
::
=^ grad-result out (depend-on grad-build)
?~ grad-result
(return-blocks [grad-build]~)
::
?: ?=([~ %error *] grad-result)
%- return-error
:- [%leaf "ford: %join to {<mark>} on {<disc>} failed:"]
message.u.grad-result
::
?> ?=([~ %success %ride *] grad-result)
::
=/ grad-vase=vase vase.u.grad-result
:: if +grad produced a mark, delegate %join behavior to that mark
::
?@ q.grad-vase
:: if +grad produced a term, make sure it's a valid mark
::
=/ grad-mark=(unit term) ((sand %tas) q.grad-vase)
?~ grad-mark
%- return-error :_ ~ :- %leaf
"ford: %join failed: %{<mark>} mark invalid +grad"
:: todo: doesn't catch full cycles of +grad arms, only simple cases
::
?: =(u.grad-mark mark)
%- return-error :_ ~ :- %leaf
"ford: %join failed: %{<mark>} mark +grad arm refers to self"
::
=/ join-build=^build
[date.build [%join disc u.grad-mark [%$ first-cage] [%$ second-cage]]]
::
=^ join-result out (depend-on join-build)
?~ join-result
(return-blocks [join-build]~)
::
?: ?=([~ %error *] join-result)
%- return-error
:- [%leaf "ford: %join to {<mark>} on {<disc>} failed:"]
message.u.join-result
::
?> ?=([~ %success %join *] join-result)
::
(return-result u.join-result)
:: make sure the +grad core has a +form arm
::
?. (slab %form p.grad-vase)
%- return-error :_ ~ :- %leaf
"ford: %join failed: no +form:grad in %{<mark>} mark"
:: make sure the +grad core has a +join arm
::
?. (slab %join p.grad-vase)
%- return-error :_ ~ :- %leaf
"ford: %join failed: no +join:grad in %{<mark>} mark"
:: fire the +form:grad arm, which should produce a mark
::
=/ form-build=^build
[date.build [%ride [%limb %form] [%$ %noun grad-vase]]]
::
=^ form-result out (depend-on form-build)
?~ form-result
(return-blocks [form-build]~)
::
?. ?=([~ %success %ride *] form-result)
(wrap-error form-result)
::
=/ form-mark=(unit term) ((soft @tas) q.vase.u.form-result)
?~ form-mark
%- return-error :_ ~ :- %leaf
"ford: %join failed: %{<mark>} mark invalid +form:grad"
:: the mark produced by +form:grad should match both diffs
::
?. &(=(u.form-mark p.first-cage) =(u.form-mark p.second-cage))
%- return-error :_ ~ :- %leaf
"ford: %join failed: mark mismatch"
:: if the diffs are identical, just produce the first
::
?: =(q.q.first-cage q.q.second-cage)
(return-result %success %join first-cage)
:: call the +join:grad gate on the two diffs
::
=/ diff-build=^build
:- date.build
:+ %call
:+ %ride
[%limb %join]
[%$ %noun grad-vase]
[%$ %noun (slop q.first-cage q.second-cage)]
::
=^ diff-result out (depend-on diff-build)
?~ diff-result
(return-blocks [diff-build]~)
::
?: ?=([~ %error *] diff-result)
%- return-error
:- [%leaf "ford: %join to {<mark>} on {<disc>} failed:"]
message.u.diff-result
::
?> ?=([~ %success %call *] diff-result)
:: the result was a unit; if `~`, use %null mark; otherwise grab tail
::
=/ =build-result
:+ %success %join
?@ q.vase.u.diff-result
[%null vase.u.diff-result]
[u.form-mark (slot 3 vase.u.diff-result)]
::
(return-result build-result)
::
++ make-list
~% %make-list ..^^$ ~
|= schematics=(list schematic)
^- build-receipt
::
=/ key-and-schematics
(turn schematics |=(=schematic [~ schematic]))
:: depend on builds of each schematic
::
=^ maybe-schematic-results out
(perform-schematics "" key-and-schematics %ignore-errors *~)
?~ maybe-schematic-results
out
:: return all builds
::
=/ =build-result
:+ %success %list
:: the roll above implicitly flopped the results
::
(flop (turn u.maybe-schematic-results tail))
(return-result build-result)
::
++ make-mash
~% %make-mash ..^^$ ~
|= $: disc=disc
mark=term
first=[disc=disc mark=term =schematic]
second=[disc=disc mark=term =schematic]
==
^- build-receipt
::
=/ initial-build=^build
[date.build [schematic.first schematic.second] [%path disc %mar mark]]
::
=^ initial-result out (depend-on initial-build)
?~ initial-result
(return-blocks [initial-build]~)
:: TODO: duplicate logic with +make-join
::
?. ?=([~ %success [%success ^ ^] %success %path *] initial-result)
(wrap-error initial-result)
?. ?=([%success *] head.head.u.initial-result)
(wrap-error `head.head.u.initial-result)
?. ?=([%success *] tail.head.u.initial-result)
(wrap-error `tail.head.u.initial-result)
::
=/ first-cage=cage (result-to-cage head.head.u.initial-result)
=/ second-cage=cage (result-to-cage tail.head.u.initial-result)
=/ mark-path=rail rail.tail.u.initial-result
:: TODO: duplicate logic with +make-pact and others
::
=/ mark-build=^build [date.build [%core mark-path]]
::
=^ mark-result out (depend-on mark-build)
?~ mark-result
(return-blocks [mark-build]~)
::
?. ?=([~ %success %core *] mark-result)
(wrap-error mark-result)
::
=/ mark-vase=vase vase.u.mark-result
::
?. (slab %grad p.mark-vase)
%- return-error :_ ~ :- %leaf
"ford: %mash failed: %{<mark>} mark has no +grad arm"
::
=/ grad-build=^build
[date.build [%ride [%limb %grad] [%$ %noun mark-vase]]]
::
=^ grad-result out (depend-on grad-build)
?~ grad-result
(return-blocks [grad-build]~)
::
?. ?=([~ %success %ride *] grad-result)
(wrap-error grad-result)
::
=/ grad-vase=vase vase.u.grad-result
:: if +grad produced a mark, delegate %mash behavior to that mark
::
?@ q.grad-vase
:: if +grad produced a term, make sure it's a valid mark
::
=/ grad-mark=(unit term) ((sand %tas) q.grad-vase)
?~ grad-mark
%- return-error :_ ~ :- %leaf
"ford: %mash failed: %{<mark>} mark invalid +grad"
::
=/ mash-build=^build
:- date.build
:- %mash
:^ disc u.grad-mark
[disc.first mark.first [%$ first-cage]]
[disc.second mark.second [%$ second-cage]]
::
=^ mash-result out (depend-on mash-build)
?~ mash-result
(return-blocks [mash-build]~)
::
?. ?=([~ %success %mash *] mash-result)
(wrap-error mash-result)
::
=/ =build-result
[%success %mash cage.u.mash-result]
::
(return-result build-result)
::
?. (slab %form p.grad-vase)
%- return-error :_ ~ :- %leaf
"ford: %mash failed: %{<mark>} mark has no +form:grad"
::
?. (slab %mash p.grad-vase)
%- return-error :_ ~ :- %leaf
"ford: %mash failed: %{<mark>} mark has no +mash:grad"
::
=/ form-build=^build
[date.build [%ride [%limb %form] [%$ %noun grad-vase]]]
::
=^ form-result out (depend-on form-build)
?~ form-result
(return-blocks [form-build]~)
::
?. ?=([~ %success %ride *] form-result)
(wrap-error form-result)
::
=/ form-mark=(unit term) ((soft @tas) q.vase.u.form-result)
?~ form-mark
%- return-error :_ ~ :- %leaf
"ford: %mash failed: %{<mark>} mark invalid +form:grad"
::
?. &(=(u.form-mark p.first-cage) =(u.form-mark p.second-cage))
%- return-error :_ ~ :- %leaf
"ford: %mash failed: mark mismatch"
::
?: =(q.q.first-cage q.q.second-cage)
=/ =build-result
[%success %mash [%null [%atom %n ~] ~]]
::
(return-result build-result)
:: call the +mash:grad gate on two [ship desk diff] triples
::
=/ mash-build=^build
:- date.build
:+ %call
:+ %ride
[%limb %mash]
[%$ %noun grad-vase]
:+ %$ %noun
%+ slop
;: slop
[[%atom %p ~] ship.disc.first]
[[%atom %tas ~] desk.disc.first]
q.first-cage
==
;: slop
[[%atom %p ~] ship.disc.second]
[[%atom %tas ~] desk.disc.second]
q.second-cage
==
::
=^ mash-result out (depend-on mash-build)
?~ mash-result
(return-blocks [mash-build]~)
::
?. ?=([~ %success %call *] mash-result)
(wrap-error mash-result)
::
=/ =build-result
[%success %mash [u.form-mark vase.u.mash-result]]
::
(return-result build-result)
::
++ make-mute
~% %make-mute ..^^$ ~
|= [subject=schematic mutations=(list [=wing =schematic])]
^- build-receipt
:: run the subject build to produce the noun to be mutated
::
=/ subject-build=^build [date.build subject]
=^ subject-result out (depend-on subject-build)
?~ subject-result
(return-blocks [subject-build]~)
::
?. ?=([~ %success *] subject-result)
(wrap-error subject-result)
::
=/ subject-cage=cage (result-to-cage u.subject-result)
::
=/ subject-vase=vase q.subject-cage
::
=^ maybe-schematic-results out
%- perform-schematics :*
"ford: %mute contained failures:"
mutations
%fail-on-errors
*wing
==
?~ maybe-schematic-results
out
:: all builds succeeded; retrieve vases from results
::
=/ successes=(list [=wing =vase])
%+ turn u.maybe-schematic-results
|= [=wing result=build-result]
^- [^wing vase]
::
?> ?=([%success *] result)
::
[wing q:(result-to-cage result)]
:: create and run a +build to apply all mutations in order
::
=/ ride-build=^build
:- date.build
:+ %ride
:: formula: a `%_` +hoon that applies a list of mutations
::
:: The hoon ends up looking like:
:: ```
:: %_ +2
:: wing-1 +6
:: wing-2 +14
:: ...
:: ==
:: ```
::
^= formula
^- hoon
:+ %cncb [%& 2]~
=/ axis 3
::
|- ^- (list [wing hoon])
?~ successes ~
::
:- [wing.i.successes [%$ (peg axis 2)]]
$(successes t.successes, axis (peg axis 3))
:: subject: list of :subject-vase and mutations, as literal schematic
::
:: The subject ends up as a vase of something like this:
:: ```
:: :~ original-subject
:: mutant-1
:: mutant-2
:: ...
:: ==
:: ```
::
^= subject ^- schematic
:+ %$ %noun
^- vase
%+ slop subject-vase
|- ^- vase
?~ successes [[%atom %n ~] ~]
::
(slop vase.i.successes $(successes t.successes))
::
=^ ride-result out (depend-on ride-build)
?~ ride-result
(return-blocks [ride-build]~)
::
?. ?=([~ %success %ride *] ride-result)
(wrap-error ride-result)
::
=/ =build-result
[%success %mute p.subject-cage vase.u.ride-result]
::
(return-result build-result)
::
++ make-pact
~% %make-pact ..^^$ ~
|= [disc=disc start=schematic diff=schematic]
^- build-receipt
:: first, build the inputs
::
=/ initial-build=^build [date.build start diff]
::
=^ initial-result out (depend-on initial-build)
?~ initial-result
(return-blocks [initial-build]~)
::
?> ?=([~ %success ^ ^] initial-result)
=/ start-result=build-result head.u.initial-result
=/ diff-result=build-result tail.u.initial-result
::
?. ?=(%success -.start-result)
(wrap-error `start-result)
?. ?=(%success -.diff-result)
(wrap-error `diff-result)
::
=/ start-cage=cage (result-to-cage start-result)
=/ diff-cage=cage (result-to-cage diff-result)
::
=/ start-mark=term p.start-cage
=/ diff-mark=term p.diff-cage
:: load the starting mark from the filesystem
::
=/ mark-path-build=^build [date.build [%path disc %mar start-mark]]
::
=^ mark-path-result out
(depend-on mark-path-build)
::
?~ mark-path-result
(return-blocks [mark-path-build]~)
::
?. ?=([~ %success %path *] mark-path-result)
(wrap-error mark-path-result)
::
=/ mark-build=^build [date.build [%core rail.u.mark-path-result]]
::
=^ mark-result out (depend-on mark-build)
?~ mark-result
(return-blocks [mark-build]~)
::
?. ?=([~ %success %core *] mark-result)
(wrap-error mark-result)
::
=/ mark-vase=vase vase.u.mark-result
:: fire the +grad arm of the mark core
::
?. (slab %grad p.mark-vase)
%- return-error :_ ~ :- %leaf
"ford: %pact failed: %{<start-mark>} mark has no +grad arm"
::
=/ grad-build=^build
[date.build [%ride [%limb %grad] [%$ %noun mark-vase]]]
::
=^ grad-result out (depend-on grad-build)
?~ grad-result
(return-blocks [grad-build]~)
::
?. ?=([~ %success %ride *] grad-result)
(wrap-error grad-result)
::
=/ grad-vase=vase vase.u.grad-result
:: +grad can produce a term or a core
::
:: If a mark's +grad arm produces a mark (as a +term),
:: it means we should use that mark's machinery to run %pact.
:: In this way, a mark can delegate its patching machinery to
:: another mark.
::
:: First we cast :start-cage to the +grad mark, then we run
:: a new %pact build on the result of that, which will use the
:: +grad mark's +grad arm. Finally we cast the %pact result back to
:: :start-mark, since we're trying to produce a patched version of
:: the initial marked value (:start-cage).
::
?@ q.grad-vase
:: if +grad produced a term, make sure it's a valid mark
::
=/ grad-mark=(unit term) ((sand %tas) q.grad-vase)
?~ grad-mark
%- return-error :_ ~ :- %leaf
"ford: %pact failed: %{<start-mark>} mark invalid +grad"
:: cast :start-cage to :grad-mark, %pact that, then cast back to start
::
=/ cast-build=^build
:- date.build
:^ %cast disc start-mark
:^ %pact disc
:^ %cast disc u.grad-mark
[%$ start-cage]
[%$ diff-cage]
::
=^ cast-result out (depend-on cast-build)
?~ cast-result
(return-blocks [cast-build]~)
::
?. ?=([~ %success %cast *] cast-result)
(wrap-error cast-result)
::
=/ =build-result
[%success %pact cage.u.cast-result]
::
(return-result build-result)
:: +grad produced a core; make sure it has a +form arm
::
:: +grad can produce a core containing +pact and +form
:: arms. +form:grad, which produces a mark (as a term), is used
:: to verify that the diff is of the correct mark.
::
:: +pact:grad produces a gate that gets slammed with the diff
:: as its sample and produces a mutant version of :start-cage
:: by applying the diff.
::
?. (slab %form p.grad-vase)
%- return-error :_ ~ :- %leaf
"ford: %pact failed: no +form:grad in %{<start-mark>} mark"
:: we also need a +pact arm in the +grad core
::
?. (slab %pact p.grad-vase)
%- return-error :_ ~ :- %leaf
"ford: %pact failed: no +pact:grad in %{<start-mark>} mark"
:: fire the +form arm in the core produced by +grad
::
=/ form-build=^build
[date.build [%ride [%limb %form] [%$ %noun grad-vase]]]
::
=^ form-result out (depend-on form-build)
?~ form-result
(return-blocks [form-build]~)
::
?. ?=([~ %success %ride *] form-result)
(wrap-error form-result)
:: +form:grad should produce a mark
::
=/ form-mark=(unit @tas) ((soft @tas) q.vase.u.form-result)
?~ form-mark
%- return-error :_ ~ :- %leaf
"ford: %pact failed: %{<start-mark>} mark invalid +form:grad"
:: mark produced by +form:grad needs to match the mark of the diff
::
?. =(u.form-mark diff-mark)
%- return-error :_ ~ :- %leaf
"ford: %pact failed: %{<start-mark>} mark invalid +form:grad"
:: call +pact:grad on the diff
::
=/ pact-build=^build
:- date.build
:+ %call
^- schematic
:+ %ride
[%tsld [%limb %pact] [%limb %grad]]
^- schematic
:+ %mute
^- schematic
[%$ %noun mark-vase]
^- (list [wing schematic])
[[%& 6]~ [%$ start-cage]]~
^- schematic
[%$ diff-cage]
::
=^ pact-result out (depend-on pact-build)
?~ pact-result
(return-blocks [pact-build]~)
::
?. ?=([~ %success %call *] pact-result)
(wrap-error pact-result)
::
=/ =build-result
[%success %pact start-mark vase.u.pact-result]
::
(return-result build-result)
::
++ make-path
~% %make-path ..^^$ ~
|= [disc=disc prefix=@tas raw-path=@tas]
^- build-receipt
:: possible-spurs: flopped paths to which :raw-path could resolve
::
=/ possible-spurs=(list spur) (turn (segments raw-path) flop)
:: rails-and-schematics: scrys to check each path in :possible-paths
::
=/ rails-and-schematics=(list [=rail =schematic])
%+ turn possible-spurs
|= possible-spur=spur
^- [rail schematic]
:: full-spur: wrap :possible-spur with :prefix and /hoon suffix
::
=/ full-spur=spur :(welp /hoon possible-spur /[prefix])
::
:- [disc full-spur]
[%scry %c %x `rail`[disc full-spur]]
:: depend on builds of each schematic
::
=^ maybe-schematic-results out
%- perform-schematics :*
;: weld
"ford: %path resolution of "
(trip raw-path)
"at prefix "
(trip prefix)
" contained failures:"
==
rails-and-schematics
%filter-errors
*rail
==
?~ maybe-schematic-results
out
:: matches: builds that completed with a successful result
::
=/ matches u.maybe-schematic-results
:: if no matches, error out
::
?~ matches
=/ =beam
[[ship.disc desk.disc [%da date.build]] /hoon/[raw-path]/[prefix]]
::
(return-error [%leaf "%path: no matches for {<(en-beam beam)>}"]~)
:: if exactly one path matches, succeed with the matching path
::
?: ?=([* ~] matches)
(return-result %success %path key.i.matches)
:: multiple paths matched; error out
::
%- return-error
::
:- [%leaf "multiple matches for %path: "]
:: tmi; cast :matches back to +list
::
%+ roll `_u.maybe-schematic-results`matches
|= [[key=rail result=build-result] message=tang]
^- tang
:: beam: reconstruct request from :kid's schematic and date
::
=/ =beam [[ship.disc desk.disc [%da date.build]] spur.key]
::
[[%leaf "{<(en-beam beam)>}"] message]
::
++ make-plan
~% %make-plan ..^^$ ~
|= [path-to-render=rail query-string=coin =scaffold]
^- build-receipt
:: blocks: accumulator for blocked sub-builds
::
=| blocks=(list ^build)
:: error-message: accumulator for failed sub-builds
::
=| error-message=tang
::
|^ :: imports: structure and library +cables, with %sur/%lib prefixes
::
=/ imports=(list [prefix=?(%sur %lib) =cable])
%+ welp
(turn structures.scaffold |=(cable [%sur +<]))
(turn libraries.scaffold |=(cable [%lib +<]))
:: path-builds: %path sub-builds to resolve import paths
::
=/ path-builds (gather-path-builds imports)
::
=^ path-results ..$ (resolve-builds path-builds)
?^ blocks
(return-blocks blocks)
::
?^ error-message
(return-error error-message)
:: tmi; remove type specializations
::
=> .(blocks *(list ^build), error-message *tang)
:: core-builds: %core sub-builds to produce library vases
::
=/ core-builds (gather-core-builds path-results)
::
=^ core-results ..$ (resolve-builds core-builds)
?^ blocks
(return-blocks blocks)
::
?^ error-message
(return-error error-message)
:: reef-build: %reef build to produce standard library
::
=/ reef-build=^build [date.build [%reef disc.path-to-render]]
::
=^ reef-result out (depend-on reef-build)
?~ reef-result
(return-blocks [reef-build]~)
::
?. ?=([~ %success %reef *] reef-result)
(wrap-error reef-result)
:: subject: tuple of imports and standard library
::
=/ subject=vase
(link-imports imports vase.u.reef-result core-results)
:: tmi; remove type specializations
::
=> .(blocks *(list ^build), error-message *tang)
:: iterate over each crane
::
=^ crane-result ..$
(compose-cranes [%noun subject] cranes.scaffold)
?: ?=(%error -.crane-result)
(return-error message.crane-result)
?: ?=(%block -.crane-result)
(return-blocks builds.crane-result)
:: combined-hoon: source hoons condensed into a single +hoon
::
=/ combined-hoon=hoon [%tssg sources.scaffold]
:: compile :combined-hoon against :subject
::
=/ compile=^build
[date.build [%ride combined-hoon [%$ subject.crane-result]]]
::
=^ compiled out (depend-on compile)
:: compilation blocked; produce block on sub-build
::
?~ compiled
(return-blocks ~[compile])
:: compilation failed; error out
::
?. ?=([~ %success %ride *] compiled)
(wrap-error compiled)
:: compilation succeeded: produce resulting +vase
::
(return-result %success %plan vase.u.compiled)
:: +compose-result: the result of a single composition
::
+= compose-result
$% [%subject subject=cage]
[%block builds=(list ^build)]
[%error message=tang]
==
:: +compose-cranes: runs each crane and composes the results
::
:: For each crane in :cranes, runs it and composes its result into a
:: new subject, which is returned if there are no errors or blocks.
::
++ compose-cranes
|= [subject=cage cranes=(list crane)]
^- $: compose-result
_..compose-cranes
==
::
?~ cranes
[[%subject subject] ..compose-cranes]
::
=^ result ..compose-cranes (run-crane subject i.cranes)
?+ -.result [result ..compose-cranes]
::
%subject
$(cranes t.cranes, subject [%noun (slop q.subject.result q.subject)])
==
:: +run-crane: runs an individual :crane against :subject
::
++ run-crane
|= [subject=cage =crane]
^- compose-cranes
::
|^ ?- -.crane
%fssg (run-fssg +.crane)
%fsbc (run-fsbc +.crane)
%fsbr (run-fsbr +.crane)
%fsts (run-fsts +.crane)
%fscm (run-fscm +.crane)
%fspm (run-fspm +.crane)
%fscb (run-fscb +.crane)
%fsdt (run-fsdt +.crane)
%fssm (run-fssm +.crane)
%fscl (run-fscl +.crane)
%fskt (run-fskt +.crane)
%fstr (run-fstr +.crane)
%fszp (run-fszp +.crane)
%fszy (run-fszy +.crane)
==
:: +run-fssg: runs the `/~` rune
::
++ run-fssg
|= =hoon
^- compose-cranes
::
=/ ride-build=^build
[date.build [%ride hoon [%$ subject]]]
=^ ride-result out (depend-on ride-build)
?~ ride-result
[[%block [ride-build]~] ..run-crane]
?: ?=([~ %error *] ride-result)
[[%error [leaf+"/~ failed: " message.u.ride-result]] ..run-crane]
?> ?=([~ %success %ride *] ride-result)
[[%subject %noun vase.u.ride-result] ..run-crane]
:: +run-fsbc: runs the `/$` rune
::
++ run-fsbc
|= =hoon
^- compose-cranes
::
=/ query-compile-build=^build
[date.build [%ride ((jock |) query-string) [%$ %noun !>(~)]]]
=^ query-compile-result out (depend-on query-compile-build)
?~ query-compile-result
[[%block [query-compile-build]~] ..run-crane]
?: ?=([~ %error *] query-compile-result)
:- [%error [leaf+"/; failed: " message.u.query-compile-result]]
..run-crane
?> ?=([~ %success %ride *] query-compile-result)
::
=/ =beam
=, path-to-render
[[ship.disc desk.disc [%da date.build]] spur]
=+ arguments=(slop !>(beam) vase.u.query-compile-result)
::
=/ call-build=^build
[date.build [%call [%ride hoon [%$ subject]] [%$ %noun arguments]]]
=^ call-result out (depend-on call-build)
?~ call-result
[[%block [call-build]~] ..run-crane]
?: ?=([~ %error *] call-result)
[[%error [leaf+"/; failed: " message.u.call-result]] ..run-crane]
?> ?=([~ %success %call *] call-result)
::
[[%subject %noun vase.u.call-result] ..run-crane]
:: +run-fsbr: runs the `/|` rune
::
++ run-fsbr
|= choices=(list ^crane)
^- compose-cranes
::
?~ choices
[[%error [leaf+"/| failed: out of options"]~] ..run-crane]
::
=^ child ..run-crane (run-crane subject i.choices)
?. ?=([%error *] child)
[child ..run-crane]
$(choices t.choices)
:: +run-fsts: runs the `/=` rune
::
++ run-fsts
|= [face=term sub-crane=^crane]
^- compose-cranes
::
=^ child ..run-crane (run-crane subject sub-crane)
?. ?=([%subject *] child)
[child ..run-crane]
:_ ..run-crane
:* %subject
p.subject.child
[[%face face p.q.subject.child] q.q.subject.child]
==
:: +run-fscm: runs the `/,` rune
::
++ run-fscm
|= cases=(list [=spur crane=^crane])
^- compose-cranes
::
?~ cases
[[%error [leaf+"/, failed: no match"]~] ..run-crane]
::
?. .= spur.i.cases
(scag (lent spur.i.cases) (flop spur.path-to-render))
$(cases t.cases)
::
(run-crane subject crane.i.cases)
:: +run-fspm: runs the `/&` rune
::
++ run-fspm
|= [marks=(list mark) sub-crane=^crane]
^- compose-cranes
::
=^ child ..run-crane (run-crane subject sub-crane)
?. ?=([%subject *] child)
[child ..run-crane]
::
=/ cast-build=^build
:- date.build
|-
^- schematic
?~ marks
:: TODO: If we were keeping track of the mark across runes, this
:: wouldn't have %noun here. This is a case where it might matter.
::
[%$ subject.child]
[%cast disc.source-rail.scaffold i.marks $(marks t.marks)]
=^ cast-result out (depend-on cast-build)
?~ cast-result
[[%block [cast-build]~] ..run-crane]
::
?: ?=([~ %error *] cast-result)
[[%error [leaf+"/& failed: " message.u.cast-result]] ..run-crane]
?> ?=([~ %success %cast *] cast-result)
::
[[%subject cage.u.cast-result] ..run-crane]
:: +run-fscb: runs the `/_` rune
::
++ run-fscb
|= sub-crane=^crane
^- compose-cranes
:: perform a scry to get the contents of +path-to-render
::
=/ toplevel-build=^build
[date.build [%scry [%c %y path-to-render]]]
::
=^ toplevel-result out (depend-on toplevel-build)
?~ toplevel-result
[[%block ~[toplevel-build]] ..run-crane]
::
?: ?=([~ %error *] toplevel-result)
:- [%error [leaf+"/_ failed: " message.u.toplevel-result]]
..run-crane
?> ?=([~ %success %scry *] toplevel-result)
::
=/ toplevel-arch=arch ;;(arch q.q.cage.u.toplevel-result)
:: sub-path: each possible sub-directory to check
::
=/ sub-paths=(list @ta)
(turn ~(tap by dir.toplevel-arch) head)
:: for each directory in :toplevel-arch, issue a sub-build
::
=/ sub-builds=(list ^build)
%+ turn sub-paths
|= sub=@ta
^- ^build
:- date.build
[%scry [%c %y path-to-render(spur [sub spur.path-to-render])]]
:: results: accumulator for results of sub-builds
::
=| $= results
(list [kid=^build sub-path=@ta results=(unit build-result)])
:: resolve all the :sub-builds
::
=/ subs-results
|- ^+ [results out]
?~ sub-builds [results out]
?> ?=(^ sub-paths)
::
=/ kid=^build i.sub-builds
=/ sub-path=@ta i.sub-paths
::
=^ result out (depend-on kid)
=. results [[kid sub-path result] results]
::
$(sub-builds t.sub-builds, sub-paths t.sub-paths)
:: apply mutations from depending on sub-builds
::
=: results -.subs-results
out +.subs-results
==
:: split :results into completed :mades and incomplete :blocks
::
=+ ^= split-results
(skid results |=([* * r=(unit build-result)] ?=(^ r)))
::
=/ mades=_results -.split-results
=/ blocks=_results +.split-results
:: if any builds blocked, produce them all in %blocks
::
?^ blocks
[[%block (turn `_results`blocks head)] ..run-crane]
:: find the first error and return it if exists
::
=/ errors=_results
%+ skim results
|= [* * r=(unit build-result)]
?=([~ %error *] r)
?^ errors
?> ?=([~ %error *] results.i.errors)
[[%error message.u.results.i.errors] ..run-crane]
:: get a list of valid sub-paths
::
:: :results is now a list of the :build-result of %cy on each path
:: in :toplevel-arch. What we want is to now filter this list so
:: that we filter files out.
::
=/ sub-paths=(list [=rail sub-path=@ta])
%+ murn results
|= [build=^build sub-path=@ta result=(unit build-result)]
^- (unit [rail @ta])
::
?> ?=([@da %scry %c %y *] build)
?> ?=([~ %success %scry *] result)
=/ =arch ;;(arch q.q.cage.u.result)
::
?~ dir.arch
~
`[rail.resource.schematic.build sub-path]
:: keep track of the original value so we can reset it
::
=/ old-path-to-render path-to-render
:: apply each of the filtered :sub-paths to the :sub-crane.
::
=^ crane-results ..run-crane
%+ roll sub-paths
|= $: [=rail sub-path=@ta]
$= accumulator
[(list [sub-path=@ta =compose-result]) _..run-crane]
==
=. ..run-crane +.accumulator
=. path-to-render rail
=^ result ..run-crane (run-crane subject sub-crane)
[[[sub-path result] -.accumulator] ..run-crane]
:: set :path-to-render back
::
=. path-to-render old-path-to-render
:: if any sub-cranes error, return the first error
::
=/ error-list=(list [@ta =compose-result])
%+ skim crane-results
|= [@ta =compose-result]
=(%error -.compose-result)
::
?^ error-list
[compose-result.i.error-list ..run-crane]
:: if any sub-cranes block, return all blocks
::
=/ block-list=(list ^build)
=| block-list=(list ^build)
|-
^+ block-list
?~ crane-results
block-list
?. ?=(%block -.compose-result.i.crane-results)
$(crane-results t.crane-results)
=. block-list
(weld builds.compose-result.i.crane-results block-list)
$(crane-results t.crane-results)
::
?^ block-list
[[%block block-list] ..run-crane]
:: put the data in map order
::
=/ result-map=(map @ta vase)
%- my
%+ turn crane-results
|= [path=@ta =compose-result]
^- (pair @ta vase)
::
?> ?=([%subject *] compose-result)
[path q.subject.compose-result]
:: convert the map into a flat format for return
::
:: This step flattens the values out of the map for return. Let's
:: say we're doing a /_ over a directory of files that just have a
:: single @ud in them. We want the return value of /_ to have the
:: nest in (map @ta @ud) instead of returning a (map @ta vase).
::
=/ as-vase=vase
|-
^- vase
::
?~ result-map
[[%atom %n `0] 0]
::
%+ slop
(slop [[%atom %ta ~] p.n.result-map] q.n.result-map)
(slop $(result-map l.result-map) $(result-map r.result-map))
::
[[%subject %noun as-vase] ..run-crane]
:: +run-fsdt: runs the `/.` rune
::
++ run-fsdt
|= sub-cranes=(list ^crane)
^- compose-cranes
::
=^ list-results ..run-crane
%+ roll sub-cranes
|= $: sub-crane=^crane
accumulator=[(list compose-result) _..run-crane]
==
=. ..run-crane +.accumulator
=^ result ..run-crane (run-crane subject sub-crane)
[[result -.accumulator] ..run-crane]
:: if any sub-cranes error, return the first error
::
=/ error-list=(list compose-result)
%+ skim list-results
|= =compose-result
=(%error -.compose-result)
::
?^ error-list
[i.error-list ..run-crane]
:: if any sub-cranes block, return all blocks
::
=/ block-list=(list ^build)
=| block-list=(list ^build)
|-
^+ block-list
?~ list-results
block-list
?. ?=(%block -.i.list-results)
$(list-results t.list-results)
=. block-list (weld builds.i.list-results block-list)
$(list-results t.list-results)
::
?^ block-list
[[%block block-list] ..run-crane]
:: concatenate all the results together with null termination
::
=. list-results (flop list-results)
::
=/ final-result=vase
|-
^- vase
?~ list-results
[[%atom %n `~] 0]
?> ?=(%subject -.i.list-results)
(slop q.subject.i.list-results $(list-results t.list-results))
::
[[%subject %noun final-result] ..run-crane]
:: +run-fssm: runs the `/;` rune
::
++ run-fssm
|= [=hoon sub-crane=^crane]
^- compose-cranes
::
=^ child ..run-crane (run-crane subject sub-crane)
?. ?=([%subject *] child)
[child ..run-crane]
::
=/ call-build=^build
[date.build [%call [%ride hoon [%$ subject]] [%$ subject.child]]]
=^ call-result out (depend-on call-build)
?~ call-result
[[%block [call-build]~] ..run-crane]
?: ?=([~ %error *] call-result)
[[%error [leaf+"/; failed: " message.u.call-result]] ..run-crane]
?> ?=([~ %success %call *] call-result)
::
[[%subject %noun vase.u.call-result] ..run-crane]
:: +run-fscl: runs the `/:` rune
::
++ run-fscl
|= [=truss sub-crane=^crane]
^- compose-cranes
::
=/ =beam
=, source-rail.scaffold
[[ship.disc desk.disc [%ud 0]] spur]
=/ hoon-parser (vang & (en-beam beam))
::
=+ tuz=(posh:hoon-parser truss)
?~ tuz
[[%error [leaf+"/: failed: bad tusk: {<truss>}"]~] ..run-crane]
=+ pax=(plex:hoon-parser %clsg u.tuz)
?~ pax
[[%error [leaf+"/: failed: bad path: {<u.tuz>}"]~] ..run-crane]
=+ bem=(de-beam u.pax)
?~ bem
[[%error [leaf+"/: failed: bad beam: {<u.pax>}"]~] ..run-crane]
::
=. path-to-render [[p q] s]:u.bem
(run-crane subject sub-crane)
:: +run-fskt: runs the `/^` rune
::
++ run-fskt
|= [=spec sub-crane=^crane]
^- compose-cranes
::
=^ child ..run-crane (run-crane subject sub-crane)
?. ?=([%subject *] child)
[child ..run-crane]
::
=/ bunt-build=^build
[date.build [%ride [%kttr spec] [%$ subject]]]
=^ bunt-result out (depend-on bunt-build)
?~ bunt-result
[[%block [bunt-build]~] ..run-crane]
?: ?=([~ %error *] bunt-result)
[[%error [leaf+"/^ failed: " message.u.bunt-result]] ..run-crane]
?> ?=([~ %success %ride *] bunt-result)
::
?. (~(nest ut p.vase.u.bunt-result) | p.q.subject.child)
[[%error [leaf+"/^ failed: nest-fail"]~] ..run-crane]
:_ ..run-crane
[%subject %noun [p.vase.u.bunt-result q.q.subject.child]]
:: +run-fstr: runs the `/*` rune
::
:: TODO: some duplicate code with +run-fscb
::
++ run-fstr
|= sub-crane=^crane
^- compose-cranes
::
=/ tree-build=^build
[date.build [%scry [%c %t path-to-render]]]
::
=^ tree-result out (depend-on tree-build)
?~ tree-result
[[%block ~[tree-build]] ..run-crane]
::
?: ?=([~ %error *] tree-result)
:- [%error [%leaf "/* failed: "] message.u.tree-result]
..run-crane
?> ?=([~ %success %scry *] tree-result)
::
=/ file-list=(list path) ;;((list path) q.q.cage.u.tree-result)
:: trim file extensions off the file paths
::
:: This is pretty ugly, but Ford expects :path-to-render not to
:: have a file extension, so we need to trim it off each path.
::
=. file-list
:: deduplicate since multiple files could share a trimmed path
::
=- ~(tap in (~(gas in *(set path)) `(list path)`-))
%+ turn file-list
|= =path
^+ path
(scag (sub (lent path) 1) path)
::
=/ old-path-to-render path-to-render
:: apply each of the paths in :file-list to the :sub-crane
::
=^ crane-results ..run-crane
%+ roll file-list
|= $: =path
$= accumulator
[(list [=path =compose-result]) _..run-crane]
==
=. ..run-crane +.accumulator
=. spur.path-to-render (flop path)
::
=^ result ..run-crane (run-crane subject sub-crane)
[[[path result] -.accumulator] ..run-crane]
::
=. path-to-render old-path-to-render
:: if any sub-cranes error, return the first error
::
=/ error-list=(list [=path =compose-result])
%+ skim crane-results
|= [=path =compose-result]
=(%error -.compose-result)
::
?^ error-list
[compose-result.i.error-list ..run-crane]
:: if any sub-cranes block, return all blocks
::
=/ block-list=(list ^build)
=| block-list=(list ^build)
|- ^+ block-list
?~ crane-results block-list
::
?. ?=(%block -.compose-result.i.crane-results)
$(crane-results t.crane-results)
=. block-list
(weld builds.compose-result.i.crane-results block-list)
::
$(crane-results t.crane-results)
::
?^ block-list
[[%block block-list] ..run-crane]
::
=/ result-map=(map path vase)
%- my
%+ turn crane-results
|= [=path =compose-result]
^- (pair ^path vase)
::
?> ?=(%subject -.compose-result)
[path q.subject.compose-result]
::
=/ as-vase
=/ path-type -:!>(*path)
|- ^- vase
?~ result-map [[%atom %n `0] 0]
::
%+ slop
(slop [path-type p.n.result-map] q.n.result-map)
(slop $(result-map l.result-map) $(result-map r.result-map))
::
[[%subject %noun as-vase] ..run-crane]
:: +run-fszp: runs the `/!mark/` "rune"
::
++ run-fszp
|= =mark
^- compose-cranes
::
=/ hoon-path=rail
=, path-to-render
[disc [%hoon spur]]
::
=/ hood-build=^build [date.build [%hood hoon-path]]
=^ hood-result out (depend-on hood-build)
?~ hood-result
[[%block [hood-build]~] ..run-crane]
?: ?=([~ %error *] hood-result)
[[%error [leaf+"/! failed: " message.u.hood-result]] ..run-crane]
?> ?=([~ %success %hood *] hood-result)
::
=/ plan-build=^build
:- date.build
[%plan path-to-render query-string scaffold.u.hood-result]
=^ plan-result out (depend-on plan-build)
?~ plan-result
[[%block [plan-build]~] ..run-crane]
?: ?=([~ %error *] plan-result)
[[%error [leaf+"/! failed: " message.u.plan-result]] ..run-crane]
?> ?=([~ %success %plan *] plan-result)
:: if :mark is %noun, don't perform mark translation; just return
::
:: If we were to verify the product type with %noun, this would
:: cast to *, which would overwrite :vase.u.plan-result's actual
:: product type
::
?: =(%noun mark)
[[%subject %noun vase.u.plan-result] ..run-crane]
::
=/ vale-build=^build
:- date.build
[%vale disc.source-rail.scaffold mark q.vase.u.plan-result]
=^ vale-result out (depend-on vale-build)
?~ vale-result
[[%block [vale-build]~] ..run-crane]
?: ?=([~ %error *] vale-result)
[[%error [leaf+"/! failed: " message.u.vale-result]] ..run-crane]
?> ?=([~ %success %vale *] vale-result)
::
[[%subject cage.u.vale-result] ..run-crane]
:: +run-fszy: runs the `/mark/` "rune"
::
++ run-fszy
|= =mark
^- compose-cranes
::
=/ bake-build=^build
:- date.build
[%bake mark query-string path-to-render]
=^ bake-result out (depend-on bake-build)
?~ bake-result
[[%block [bake-build]~] ..run-crane]
?: ?=([~ %error *] bake-result)
:_ ..run-crane
[%error [leaf+"/{(trip mark)}/ failed: " message.u.bake-result]]
?> ?=([~ %success %bake *] bake-result)
::
[[%subject cage.u.bake-result] ..run-crane]
--
:: +gather-path-builds: produce %path builds to resolve import paths
::
++ gather-path-builds
|= imports=(list [prefix=?(%sur %lib) =cable])
^- (list ^build)
::
%+ turn imports
|= [prefix=?(%sur %lib) =cable]
^- ^build
[date.build [%path disc.source-rail.scaffold prefix file-path.cable]]
:: +resolve-builds: run a list of builds and collect results
::
:: If a build blocks, put its +tang in :error-message and stop.
:: All builds that block get put in :blocks. Results of
:: successful builds are produced in :results.
::
++ resolve-builds
=| results=(list build-result)
|= builds=(list ^build)
^+ [results ..^$]
::
?~ builds
[results ..^$]
::
=^ result out (depend-on i.builds)
?~ result
=. blocks [i.builds blocks]
$(builds t.builds)
::
?. ?=(%success -.u.result)
=. error-message [[%leaf "%plan failed: "] message.u.result]
[results ..^$]
::
=. results [u.result results]
$(builds t.builds)
:: +gather-core-builds: produce %core builds from resolved paths
::
++ gather-core-builds
|= path-results=(list build-result)
^- (list ^build)
%+ turn path-results
|= result=build-result
^- ^build
::
?> ?=([%success %path *] result)
::
[date.build [%core rail.result]]
:: +link-imports: link libraries and structures with standard library
::
:: Prepends each library vase onto the standard library vase.
:: Wraps a face around each library to prevent namespace leakage
:: unless imported as *lib-name.
::
++ link-imports
|= $: imports=(list [?(%lib %sur) =cable])
reef=vase
core-results=(list build-result)
==
^- vase
::
=/ subject=vase reef
::
=/ core-vases=(list vase)
%+ turn core-results
|= result=build-result
^- vase
?> ?=([%success %core *] result)
vase.result
:: link structures and libraries into a subject for compilation
::
|- ^+ subject
?~ core-vases subject
?< ?=(~ imports)
:: cons this vase onto the head of the subject
::
=. subject
%- slop :_ subject
:: check if the programmer named the library
::
?~ face.cable.i.imports
:: no face assigned to this library, so use vase as-is
::
i.core-vases
:: use the library name as a face to prevent namespace leakage
::
^- vase
[[%face u.face.cable.i.imports p.i.core-vases] q.i.core-vases]
::
$(core-vases t.core-vases, imports t.imports)
--
::
++ make-reef
~% %make-reef ..^^$ ~
|= =disc
^- build-receipt
::
=/ hoon-scry
[date.build [%scry %c %x [disc /hoon/hoon/sys]]]
::
=^ hoon-scry-result out (depend-on hoon-scry)
::
=/ arvo-scry
[date.build [%scry %c %x [disc /hoon/arvo/sys]]]
::
=^ arvo-scry-result out (depend-on arvo-scry)
::
=/ zuse-scry
[date.build [%scry %c %x [disc /hoon/zuse/sys]]]
::
=^ zuse-scry-result out (depend-on zuse-scry)
::
=| blocks=(list ^build)
=? blocks ?=(~ hoon-scry-result) [hoon-scry blocks]
=? blocks ?=(~ arvo-scry-result) [arvo-scry blocks]
=? blocks ?=(~ zuse-scry-result) [zuse-scry blocks]
::
?^ blocks
(return-blocks blocks)
::
?. ?=([~ %success %scry *] hoon-scry-result)
(wrap-error hoon-scry-result)
::
?. ?=([~ %success %scry *] arvo-scry-result)
(wrap-error arvo-scry-result)
::
?. ?=([~ %success %scry *] zuse-scry-result)
(wrap-error zuse-scry-result)
:: short-circuit to :pit if asked for current %home desk
::
:: This avoids needing to recompile the kernel if we're asked
:: for the kernel we're already running. Note that this fails
:: referential transparency if |autoload is turned off.
::
?: ?& |(=(disc [our %home]) =(disc [our %base]))
:: is :date.build the latest commit on the %home desk?
::
?| =(now date.build)
::
=/ =beam [[our %home [%da date.build]] /hoon/hoon/sys]
::
.= (scry [%141 %noun] ~ %cw beam)
(scry [%141 %noun] ~ %cw beam(r [%da now]))
== ==
::
(return-result %success %reef pit)
:: omit case from path to prevent cache misses
::
=/ hoon-path=path
/(scot %p ship.disc)/(scot %tas desk.disc)/hoon/hoon/sys
=/ hoon-hoon=hoon (rain hoon-path ;;(@t q.q.cage.u.hoon-scry-result))
::
=/ arvo-path=path
/(scot %p ship.disc)/(scot %tas desk.disc)/hoon/arvo/sys
=/ arvo-hoon=hoon (rain arvo-path ;;(@t q.q.cage.u.arvo-scry-result))
::
=/ zuse-path=path
/(scot %p ship.disc)/(scot %tas desk.disc)/hoon/zuse/sys
=/ zuse-hoon=hoon (rain zuse-path ;;(@t q.q.cage.u.zuse-scry-result))
::
=/ zuse-build=^build
:* date.build
%ride zuse-hoon
:: hoon for `..is` to grab the :pit out of the arvo core
::
%ride [%cnts ~[[%& 1] %is] ~]
%ride arvo-hoon
%ride hoon-hoon
[%$ %noun !>(~)]
==
::
=^ zuse-build-result out (depend-on zuse-build)
?~ zuse-build-result
(return-blocks [zuse-build]~)
::
?. ?=([~ %success %ride *] zuse-build-result)
(wrap-error zuse-build-result)
::
(return-result %success %reef vase.u.zuse-build-result)
::
++ make-ride
~% %make-ride ..^^$ ~
|= [formula=hoon =schematic]
^- build-receipt
::
=^ result out (depend-on [date.build schematic])
?~ result
(return-blocks [date.build schematic]~)
::
=* subject-vase q:(result-to-cage u.result)
=/ slim-schematic=^schematic [%slim p.subject-vase formula]
=^ slim-result out (depend-on [date.build slim-schematic])
?~ slim-result
(return-blocks [date.build slim-schematic]~)
::
?: ?=([~ %error *] slim-result)
%- return-error
:* [%leaf "ford: %ride failed to compute type:"]
message.u.slim-result
==
::
?> ?=([~ %success %slim *] slim-result)
::
=/ =compiler-cache-key [%ride formula subject-vase]
=^ cached-result out (access-cache compiler-cache-key)
?^ cached-result
(return-result u.cached-result)
::
=/ val
(mock [q.subject-vase nock.u.slim-result] intercepted-scry)
:: val is a toon, which might be a list of blocks.
::
?- -.val
::
%0
(return-result %success %ride [type.u.slim-result p.val])
::
%1
=/ blocked-paths=(list path) ((hard (list path)) p.val)
(blocked-paths-to-receipt %ride blocked-paths)
::
%2
(return-error [[%leaf "ford: %ride failed to execute:"] p.val])
==
::
++ make-same
~% %make-same ..^^$ ~
|= =schematic
^- build-receipt
::
=^ result out (depend-on [date.build schematic])
::
?~ result
(return-blocks [date.build schematic]~)
(return-result u.result)
::
++ make-scry
~% %make-scry ..^^$ ~
|= =resource
^- build-receipt
:: construct a full +beam to make the scry request
::
=/ =beam (extract-beam resource `date.build)
=/ =scry-request [vane.resource care.resource beam]
:: perform scry operation if we don't already know the result
::
:: Look up :scry-request in :scry-results.per-event to avoid
:: rerunning a previously blocked +scry.
::
=/ scry-response
?: (~(has by scry-results) scry-request)
(~(get by scry-results) scry-request)
(scry [%141 %noun] ~ `@tas`(cat 3 [vane care]:resource) beam)
:: scry blocked
::
?~ scry-response
(return-blocks ~)
:: scry failed
::
?~ u.scry-response
%- return-error
:~ leaf+"scry failed for"
leaf+"%c{(trip care.resource)} {<(en-beam beam)>}"
==
:: scry succeeded
::
(return-result %success %scry u.u.scry-response)
::
++ make-slim
~% %make-slim ..^^$ ~
|= [subject-type=type formula=hoon]
^- build-receipt
::
=/ =compiler-cache-key [%slim subject-type formula]
=^ cached-result out (access-cache compiler-cache-key)
?^ cached-result
(return-result u.cached-result)
::
=/ compiled=(each (pair type nock) tang)
(mule |.((~(mint ut subject-type) [%noun formula])))
::
%_ out
result
?- -.compiled
%| [%build-result %error [leaf+"ford: %slim failed: " p.compiled]]
%& [%build-result %success %slim p.compiled]
==
==
:: TODO: Take in +type instead of +vase?
::
++ make-slit
~% %make-slit ..^^$ ~
|= [gate=vase sample=vase]
^- build-receipt
::
=/ =compiler-cache-key [%slit p.gate p.sample]
=^ cached-result out (access-cache compiler-cache-key)
?^ cached-result
(return-result u.cached-result)
::
=/ product=(each type tang)
(mule |.((slit p.gate p.sample)))
::
%_ out
result
?- -.product
%| :* %build-result %error
:* (~(dunk ut p.sample) %have)
(~(dunk ut (~(peek ut p.gate) %free 6)) %want)
leaf+"ford: %slit failed:"
p.product
==
==
%& [%build-result %success %slit p.product]
==
==
::
++ make-volt
~% %make-volt ..^^$ ~
|= [=disc mark=term input=*]
^- build-receipt
::
=/ bunt-build=^build [date.build [%bunt disc mark]]
::
=^ bunt-result out (depend-on bunt-build)
?~ bunt-result
(return-blocks [bunt-build]~)
::
?: ?=([~ %error *] bunt-result)
%- return-error
:- [%leaf "ford: %volt {<mark>} on {<disc>} failed:"]
message.u.bunt-result
::
?> ?=([~ %success %bunt *] bunt-result)
::
=/ =build-result
[%success %volt [mark p.q.cage.u.bunt-result input]]
::
(return-result build-result)
::
++ make-vale
~% %make-vale ..^^$ ~
:: TODO: better docs
::
|= [=disc mark=term input=*]
^- build-receipt
:: don't validate for the %noun mark
::
?: =(%noun mark)
=/ =build-result [%success %vale [%noun %noun input]]
::
(return-result build-result)
::
=/ path-build [date.build [%path disc %mar mark]]
::
=^ path-result out (depend-on path-build)
?~ path-result
(return-blocks [path-build]~)
::
?: ?=([~ %error *] path-result)
%- return-error
:- leaf+"ford: %vale failed while searching for {<mark>}:"
message.u.path-result
::
?> ?=([~ %success %path *] path-result)
::
=/ bunt-build=^build [date.build [%bunt disc mark]]
::
=^ bunt-result out (depend-on bunt-build)
?~ bunt-result
(return-blocks [bunt-build]~)
::
?. ?=([~ %success %bunt *] bunt-result)
(wrap-error bunt-result)
::
=/ mark-sample=vase q.cage.u.bunt-result
::
=/ call-build=^build
:^ date.build
%call
^= gate
:* %ride
:: (ream 'noun:grab')
formula=`hoon`[%tsld [%wing ~[%noun]] [%wing ~[%grab]]]
subject=`schematic`[%core rail.u.path-result]
==
sample=[%$ %noun %noun input]
::
=^ call-result out (depend-on call-build)
?~ call-result
(return-blocks [call-build]~)
::
?: ?=([~ %error *] call-result)
::
%- return-error
=/ =beam
[[ship.disc desk.disc %da date.build] spur.rail.u.path-result]
:* :- %leaf
"ford: %vale failed: invalid input for mark: {<(en-beam beam)>}"
message.u.call-result
==
::
?> ?=([~ %success %call *] call-result)
=/ product=vase vase.u.call-result
:: +grab might produce the wrong type
::
?. (~(nest ut p.mark-sample) | p.product)
%- return-error
:~ leaf+"ford: %vale failed"
leaf+"+grab has wrong type in mark {<mark>} on disc {<disc>}"
==
::
=/ =build-result
[%success %vale [mark p.mark-sample q.product]]
::
(return-result build-result)
::
++ make-walk
~% %make-walk ..^^$ ~
|= [=disc source=term target=term]
^- build-receipt
:: define some types used in this gate
::
=> |%
:: +load-node: a queued arm to run from a mark core
::
+= load-node [type=?(%grab %grow) mark=term]
:: edge-jug: directed graph from :source mark to :target marks
::
:: :source can be converted to :target either by running
:: its own +grow arm, or by running the target's +grab arm.
::
+= edge-jug (jug source=term [target=term arm=?(%grow %grab)])
:: mark-path: a path through the mark graph
::
:: +mark-path represents a series of mark translation
:: operations to be performed to 'walk' from one mark to another.
::
:: +mark-action is defined in Zuse. It represents a conversion
:: from a source mark to a target mark, and it specifies
:: whether it will use +grow or +grab.
::
+= mark-path (list mark-action)
--
::
|^ ^- build-receipt
?: =(source target)
(return-result %success %walk ~)
:: load all marks.
::
=^ marks-result out
(load-marks-reachable-from [[%grow source] [%grab target] ~])
?~ -.marks-result
out
:: find a path through the graph
::
:: Make a list of individual mark translation actions which will
:: take us from :source to :term.
::
=/ path (find-path-through u.-.marks-result)
:: if there is no path between these marks, give an error message
::
?~ path
:: we failed; surface errors from +load-marks-reachable-from
::
=/ braces [[' ' ' ' ~] ['{' ~] ['}' ~]]
=/ errors=(list tank)
%- zing
%+ turn ~(tap in +.marks-result)
|= [mark=term err=tang]
^- tang
:~ [%leaf "while compiling {<mark>}:"]
[%rose braces err]
==
::
%_ out
result
:* %build-result %error
:* [leaf+"ford: no mark path from {<source>} to {<target>}"]
errors
== ==
==
::
(return-result %success %walk path)
:: +load-marks-reachable-from: partial mark graph loading
::
:: While we can just load all marks in the %/mar directory, this is
:: rather slow. What we do instead is traverse forwards and backwards
:: from the source and target marks: we start at the source mark,
:: check all the grow arms, and then check their grow arms. At the
:: same time, we start from the target mark, check all the grab arms,
:: and then check their grab arms. This gives us a much smaller
:: dependency set than loading the entire %/mar directory.
::
++ load-marks-reachable-from
|= queued-nodes=(list load-node)
:: list of nodes in the graph that we've already checked
::
=| visited=(set load-node)
:: graph of the available edges
::
=| =edge-jug
:: compile-failures: mark files which didn't compile
::
=| compile-failures=(map term tang)
::
|-
^- [[(unit ^edge-jug) _compile-failures] _out]
:: no ?~ to prevent tmi
::
?: =(~ queued-nodes)
[[`edge-jug compile-failures] out]
::
=/ nodes-and-schematics
%+ turn queued-nodes
|= =load-node
^- [^load-node schematic]
:- load-node
[%path disc %mar mark.load-node]
:: get the path for each mark name
::
:: For %path builds, any ambiguous path is just filtered out.
::
=^ maybe-path-results out
%- perform-schematics :*
"ford: %walk from {<source>} to {<target>} contained failures:"
nodes-and-schematics
%filter-errors
*load-node
==
?~ maybe-path-results
[[~ ~] out]
::
=/ nodes-and-cores
%+ turn u.maybe-path-results
|= [=load-node =build-result]
^- [^load-node schematic]
::
?> ?=([%success %path *] build-result)
::
:- load-node
[%core rail.build-result]
::
=^ maybe-core-results out
%- perform-schematics :*
"ford: %walk from {<source>} to {<target>} contained failures:"
nodes-and-cores
%ignore-errors
*load-node
==
?~ maybe-core-results
[[~ ~] out]
:: clear the queue before we process the new results
::
=. queued-nodes ~
::
=/ cores u.maybe-core-results
::
|-
?~ cores
^$
:: mark this node as visited
::
=. visited (~(put in visited) key.i.cores)
:: add core errors to compile failures
::
=? compile-failures ?=([%error *] result.i.cores)
%+ ~(put by compile-failures) mark.key.i.cores
message.result.i.cores
::
=/ target-arms=(list load-node)
?. ?=([%success %core *] result.i.cores)
~
?: =(%grow type.key.i.cores)
(get-arms-of-type %grow vase.result.i.cores)
(get-arms-of-type %grab vase.result.i.cores)
:: filter places we know we've already been.
::
=. target-arms
%+ skip target-arms ~(has in visited)
=. queued-nodes (weld target-arms queued-nodes)
::
=. edge-jug
|-
?~ target-arms
edge-jug
::
=. edge-jug
?- type.i.target-arms
::
%grab
(~(put ju edge-jug) mark.i.target-arms [mark.key.i.cores %grab])
::
%grow
(~(put ju edge-jug) mark.key.i.cores [mark.i.target-arms %grow])
==
$(target-arms t.target-arms)
::
$(cores t.cores)
::
++ get-arms-of-type
|= [type=?(%grab %grow) =vase]
^- (list load-node)
:: it is valid for this node to not have a +grow arm.
::
?. (slob type p.vase)
~
::
%+ turn
(sloe p:(slap vase [%limb type]))
|= arm=term
[type arm]
:: +find-path-through: breadth first search over the mark graph
::
++ find-path-through
|= edges=edge-jug
^- mark-path
:: the source node starts out visited
=/ visited-nodes=(set mark) [source ~ ~]
:: these paths are flopped so we're always inserting to the front.
=| path-queue=(qeu mark-path)
:: start the queue with all the edges which start at the source mark
::
=. path-queue
=/ start-links (find-links-in-edges edges source)
::
|-
^+ path-queue
?~ start-links
path-queue
::
=. path-queue (~(put to path-queue) [i.start-links]~)
::
$(start-links t.start-links)
::
|-
^- mark-path
::
?: =(~ path-queue)
:: no path found
~
=^ current path-queue [p q]:~(get to path-queue)
?> ?=(^ current)
::
?: =(target target.i.current)
:: we have a completed path. paths in the queue are backwards
(flop current)
::
=+ next-steps=(find-links-in-edges edges target.i.current)
:: filter out already visited nodes
::
=. next-steps
%+ skip next-steps
|= link=mark-action
(~(has in visited-nodes) source.link)
:: then add the new ones to the set of already visited nodes
::
=. visited-nodes
(~(gas in visited-nodes) (turn next-steps |=(mark-action source)))
:: now all next steps go in the queue
::
=. path-queue
%- ~(gas to path-queue)
%+ turn next-steps
|= new-link=mark-action
[new-link current]
::
$
:: +find-links-in-edges: gets edges usable by +find-path-through
::
:: This deals with disambiguating between %grab and %grow so we always
:: pick %grab over %grow.
::
++ find-links-in-edges
|= [edges=edge-jug source=term]
^- (list mark-action)
::
=+ links=~(tap in (~(get ju edges) source))
::
=| results=(set mark-action)
|-
^- (list mark-action)
?~ links
~(tap in results)
::
?- arm.i.links
%grab
:: if :results has a %grow entry, remove it before adding our %grab
=/ grow-entry=mark-action [%grow source target.i.links]
=? results (~(has in results) grow-entry)
(~(del in results) grow-entry)
::
=. results (~(put in results) [%grab source target.i.links])
$(links t.links)
::
%grow
:: if :results has a %grab entry, don't add a %grow entry
?: (~(has in results) [%grab source target.i.links])
$(links t.links)
::
=. results (~(put in results) [%grow source target.i.links])
$(links t.links)
==
--
:: |utilities:make: helper arms
::
::+| utilities
::
:: +perform-schematics: helper function that performs a list of builds
::
:: We often need to run a list of builds. This helper method will
:: depend on all :builds, will return a +build-receipt of either the
:: blocks or the first error, or a list of all completed results.
::
:: This is a wet gate so individual callers can associate their own
:: key types with schematics.
::
++ perform-schematics
|* $: failure=tape
builds=(list [key=* =schematic])
on-error=?(%fail-on-errors %filter-errors %ignore-errors)
key-bunt=*
==
^- $: (unit (list [key=_key-bunt result=build-result]))
_out
==
::
|^ =^ results out
=| results=(list [_key-bunt ^build (unit build-result)])
|-
^+ [results out]
::
?~ builds
[results out]
::
=/ sub-build=^build [date.build schematic.i.builds]
=^ result out (depend-on sub-build)
=. results [[key.i.builds sub-build result] results]
::
$(builds t.builds)
?: =(%fail-on-errors on-error)
(check-errors results)
?: =(%filter-errors on-error)
(filter-errors results)
(handle-rest results)
::
++ check-errors
|= results=(list [_key-bunt ^build (unit build-result)])
::
=/ braces [[' ' ' ' ~] ['{' ~] ['}' ~]]
=/ errors=(list tank)
%+ murn results
|= [* * result=(unit build-result)]
^- (unit tank)
?. ?=([~ %error *] result)
~
`[%rose braces message.u.result]
::
?^ errors
:- ~
%- return-error
:- [%leaf failure]
errors
::
(handle-rest results)
::
++ filter-errors
|= results=(list [_key-bunt ^build (unit build-result)])
=. results
%+ skip results
|= [* * r=(unit build-result)]
?=([~ %error *] r)
(handle-rest results)
::
++ handle-rest
|= results=(list [_key-bunt ^build (unit build-result)])
:: if any sub-builds blocked, produce all blocked sub-builds
::
=/ blocks=(list ^build)
%+ murn `(list [* ^build (unit build-result)])`results
|= [* sub=^build result=(unit build-result)]
^- (unit ^build)
?^ result
~
`sub
::
?^ blocks
[~ (return-blocks blocks)]
::
:_ out
:- ~
%+ turn results
|* [key=_key-bunt ^build result=(unit build-result)]
^- [_key-bunt build-result]
[key (need result)]
--
:: +wrap-error: wrap an error message around a failed sub-build
::
++ wrap-error
|= result=(unit build-result)
^- build-receipt
::
?> ?=([~ %error *] result)
=/ message=tang
[[%leaf "ford: {<-.schematic.build>} failed: "] message.u.result]
::
(return-error message)
:: +return-blocks: exit +make as a blocked build
::
++ return-blocks
|= builds=(list ^build)
^- build-receipt
out(result [%blocks builds])
:: +return-error: exit +make with a specific failure message
::
++ return-error
|= =tang
^- build-receipt
out(result [%build-result %error tang])
:: +return-result: exit +make with a completed build
::
++ return-result
|= =build-result
^- build-receipt
out(result [%build-result build-result])
::
++ access-cache
|= =compiler-cache-key
^- [(unit build-result) _out]
::
?~ entry=(~(get by lookup.compiler-cache.state) compiler-cache-key)
[~ out(cache-access `[compiler-cache-key new=%.y])]
::
[`val.u.entry out(cache-access `[compiler-cache-key new=%.n])]
::
++ depend-on
|= kid=^build
^- [(unit build-result) _out]
::
?: =(kid build)
~| [%depend-on-self (build-to-tape kid)]
!!
::
=. sub-builds.out [kid sub-builds.out]
:: +access-build-record will mutate :results.state
::
:: It's okay to ignore this because the accessed-builds get gathered
:: and merged during the +reduce step.
::
=/ maybe-build-record -:(access-build-record kid)
?~ maybe-build-record
[~ out]
::
=* build-record u.maybe-build-record
?: ?=(%tombstone -.build-record)
[~ out]
::
[`build-result.build-record out]
:: +blocked-paths-to-receipt: handle the %2 case for mock
::
:: Multiple schematics handle +toon instances. This handles the %2 case
:: for a +toon and transforms it into a +build-receipt so we depend on
:: the blocked paths correctly.
::
++ blocked-paths-to-receipt
|= [name=term blocked-paths=(list path)]
^- build-receipt
::
=/ blocks-or-failures=(list (each ^build tank))
%+ turn blocked-paths
|= =path
::
=/ scry-request=(unit scry-request) (path-to-scry-request path)
?~ scry-request
[%| [%leaf "ford: {<name>}: invalid scry path: {<path>}"]]
::
=* case r.beam.u.scry-request
::
?. ?=(%da -.case)
[%| [%leaf "ford: {<name>}: invalid case in scry path: {<path>}"]]
::
=/ date=@da p.case
::
=/ resource=(unit resource) (path-to-resource path)
?~ resource
:- %|
[%leaf "ford: {<name>}: invalid resource in scry path: {<path>}"]
::
=/ sub-schematic=schematic [%pin date %scry u.resource]
::
[%& `^build`[date sub-schematic]]
::
=/ failed=tang
%+ murn blocks-or-failures
|= block=(each ^build tank)
^- (unit tank)
?- -.block
%& ~
%| `p.block
==
::
?^ failed
:: some failed
::
out(result [%build-result %error failed])
:: no failures
::
=/ blocks=(list ^build)
%+ turn blocks-or-failures
|= block=(each ^build tank)
?> ?=(%& -.block)
::
p.block
::
=. out
%+ roll blocks
|= [block=^build accumulator=_out]
=. out accumulator
+:(depend-on [date.block schematic.block])
::
(return-blocks blocks)
--
:: |utilities:per-event: helper arms
::
::+| utilities
::
:: +add-build: store a fresh, unstarted build in the state
::
++ add-build
~/ %add-build
|= =build
^+ state
:: don't overwrite an existing entry
::
?: (~(has by builds.state) build)
state
::
%_ state
builds-by-schematic
(~(put by-schematic builds-by-schematic.state) build)
::
builds
%+ ~(put by builds.state) build
=| =build-status
build-status(state [%untried ~])
==
:: +remove-builds: remove builds and their sub-builds
::
++ remove-builds
~/ %remove-builds
|= builds=(list build)
::
|^ ^+ state
::
?~ builds
state
::
?~ maybe-build-status=(~(get by builds.state) i.builds)
$(builds t.builds)
=/ subs ~(tap in ~(key by subs.u.maybe-build-status))
::
=^ removed state (remove-single-build i.builds u.maybe-build-status)
?. removed
$(builds t.builds)
::
$(builds (welp t.builds subs))
:: +remove-build: stop storing :build in the state
::
:: Removes all linkages to and from sub-builds
::
++ remove-single-build
|= [=build =build-status]
^+ [removed=| state]
:: never delete a build that something depends on
::
?^ clients.build-status
[removed=| state]
?^ requesters.build-status
[removed=| state]
:: nothing depends on :build, so we'll remove it
::
:- removed=&
::
%_ state
builds-by-schematic
(~(del by-schematic builds-by-schematic.state) build)
::
builds
(~(del by builds.state) build)
==
--
:: +update-build-status: replace :build's +build-status by running a function
::
++ update-build-status
~/ %update-build-status
|= [=build update-func=$-(build-status build-status)]
^- [build-status builds=_builds.state]
::
=/ original=build-status
~| [%update-build (build-to-tape build)]
(~(got by builds.state) build)
=/ mutant=build-status (update-func original)
::
[mutant (~(put by builds.state) build mutant)]
:: +intercepted-scry: augment real scry with local %scry build results
::
:: Try to deduplicate requests for possibly remote resources by looking up
:: the result in local state if the real scry has no synchronous
:: answer (it produced `~`).
::
++ intercepted-scry
%- sloy ^- slyd
~/ %intercepted-scry
|= [ref=* (unit (set monk)) =term =beam]
^- (unit (unit (cask)))
:: if the actual scry produces a value, use that value; otherwise use local
::
=/ scry-response (scry +<.$)
::
?^ scry-response
scry-response
::
=/ vane=(unit %c) ((soft ,%c) (end 3 1 term))
?~ vane
~
=/ care=(unit care:clay) ((soft care:clay) (rsh 3 1 term))
?~ care
~
?. ?=(%da -.r.beam)
~
=/ =resource [u.vane u.care rail=[[p.beam q.beam] s.beam]]
=/ =build [date=p.r.beam %scry resource]
:: look up the scry result from our permanent state
::
:: Note: we can't freshen :build's :last-accessed date because
:: we can't mutate :state from this gate. %scry results might get
:: deleted during %wipe more quickly than they should because of this.
::
=/ local-result -:(access-build-record build)
?~ local-result
~
?: ?=(%tombstone -.u.local-result)
~
::
=/ local-cage=cage (result-to-cage build-result.u.local-result)
:: if :local-result does not nest in :type, produce an error
::
?. -:(nets:wa +.ref `type`p.q.local-cage)
[~ ~]
::
[~ ~ `(cask)`local-cage]
:: +unblock-clients-on-duct: unblock and produce clients blocked on :build
::
++ unblock-clients-on-duct
=| unblocked=(list build)
~% %unblock-clients-on-duct +>+ ~
|= =build
^+ [unblocked builds.state]
::
=/ =build-status
~| [%unblocking (build-to-tape build)]
(~(got by builds.state) build)
::
=/ clients=(list ^build) ~(tap in (~(get ju clients.build-status) [%duct duct]))
::
|-
^+ [unblocked builds.state]
?~ clients
[unblocked builds.state]
::
=^ client-status builds.state
%+ update-build-status i.clients
|= client-status=^build-status
::
=. subs.client-status
%+ ~(jab by subs.client-status) build
|= original=build-relation
original(blocked |)
::
=? state.client-status
?& ?=(%blocked -.state.client-status)
::
?!
%- ~(any by subs.client-status)
|=(build-relation &(blocked verified))
==
::
[%unblocked ~]
client-status
::
=? unblocked !?=(%blocked -.state.client-status)
[i.clients unblocked]
::
$(clients t.clients)
:: +on-build-complete: handles completion of any build
::
++ on-build-complete
~/ %on-build-complete
|= =build
^+ ..execute
::
=. ..execute (cleanup-orphaned-provisional-builds build)
::
=/ duct-status (~(got by ducts.state) duct)
::
=/ =build-status (~(got by builds.state) build)
?: (~(has in requesters.build-status) [%duct duct])
(on-root-build-complete build)
::
=^ unblocked-clients builds.state (unblock-clients-on-duct build)
=. candidate-builds (~(gas in candidate-builds) unblocked-clients)
::
..execute
:: +on-root-build-complete: handle completion or promotion of a root build
::
:: When a build completes for a duct, we might have to send a %made move
:: on the requesting duct and also do duct and build book-keeping.
::
++ on-root-build-complete
~/ %on-root-build-complete
|= =build
^+ ..execute
::
=; res=_..execute
=/ duct-status=(unit duct-status)
(~(get by ducts.state.res) duct)
?~ duct-status res
:: debugging assertions to try to track down failure in
:: +copy-build-tree-as-provisional
::
~| [%failed-to-preserve-live-build (build-to-tape build)]
?> ?=(%live -.live.u.duct-status)
~| %failed-2
?> ?=(^ last-sent.live.u.duct-status)
~| %failed-3
?> .= build
[date.u.last-sent.live.u.duct-status root-schematic.u.duct-status]
~| %failed-4
?> (~(has by builds.state.res) build)
::
res
::
=/ =build-status (~(got by builds.state) build)
=/ =duct-status (~(got by ducts.state) duct)
:: make sure we have something to send
::
?> ?=([%complete %value *] state.build-status)
:: send a %made move unless it's an unchanged live build
::
=? moves
?!
?& ?=(%live -.live.duct-status)
?=(^ last-sent.live.duct-status)
::
=/ last-build-status
%- ~(got by builds.state)
[date.u.last-sent.live.duct-status schematic.build]
::
?> ?=(%complete -.state.last-build-status)
?& ?=(%value -.build-record.state.last-build-status)
::
.= build-result.build-record.state.last-build-status
build-result.build-record.state.build-status
== ==
:_ moves
^- move
::
:* duct %give %made date.build %complete
build-result.build-record.state.build-status
==
::
?- -.live.duct-status
%once
=. ducts.state (~(del by ducts.state) duct)
=. state (move-root-to-cache build)
::
..execute
::
%live
:: clean up previous build
::
=? state ?=(^ last-sent.live.duct-status)
=/ old-build=^build build(date date.u.last-sent.live.duct-status)
::
(remove-anchor-from-root old-build [%duct duct])
::
=/ resource-list=(list [=disc resources=(set resource)])
~(tap by (collect-live-resources build))
:: we can only handle a single subscription
::
:: In the long term, we need Clay's interface to change so we can
:: subscribe to multiple desks at the same time.
::
?: (lth 1 (lent resource-list))
=. ..execute
%+ send-incomplete build :~
[%leaf "root build {(build-to-tape build)}"]
[%leaf "on duct:"]
[%leaf "{<duct>}"]
[%leaf "tried to subscribe to multiple discs:"]
[%leaf "{<resource-list>}"]
==
:: delete this instead of caching it, since it wasn't right
::
=. ducts.state (~(del by ducts.state) duct)
=. state (remove-anchor-from-root build [%duct duct])
..execute
::
=/ subscription=(unit subscription)
?~ resource-list
~
`[date.build disc.i.resource-list resources.i.resource-list]
::
=? ..execute ?=(^ subscription)
(start-clay-subscription u.subscription)
::
=. ducts.state
%+ ~(put by ducts.state) duct
%_ duct-status
live
[%live in-progress=~ last-sent=`[date.build subscription]]
==
::
..execute
==
:: +send-incomplete: emit a move indicating we can't complete :build
::
++ send-incomplete
|= [=build message=tang]
^+ ..execute
::
=. moves
:_ moves
`move`[duct %give %made date.build %incomplete message]
::
..execute
:: +cleanup-orphaned-provisional-builds: delete extraneous sub-builds
::
:: Remove unverified linkages to sub builds. If a sub-build has no other
:: clients on this duct, then it is orphaned and we remove the duct from
:: its subs and call +cleanup on it.
::
++ cleanup-orphaned-provisional-builds
~/ %cleanup-orphaned-provisional-builds
|= =build
^+ ..execute
::
=/ =build-status (~(got by builds.state) build)
::
=/ orphans=(list ^build)
%+ murn ~(tap by subs.build-status)
|= [sub=^build =build-relation]
^- (unit ^build)
::
?: verified.build-relation
~
`sub
:: remove links to orphans in :build's +build-status
::
=^ build-status builds.state
%+ update-build-status build
|= build-status=^build-status
%_ build-status
subs
::
|- ^+ subs.build-status
?~ orphans subs.build-status
::
=. subs.build-status (~(del by subs.build-status) i.orphans)
::
$(orphans t.orphans)
==
::
=/ =anchor [%duct duct]
::
|- ^+ ..execute
?~ orphans ..execute
:: remove link to :build in :i.orphan's +build-status
::
=^ orphan-status builds.state
%+ update-build-status i.orphans
|= orphan-status=_build-status
%_ orphan-status
clients (~(del ju clients.orphan-status) anchor build)
==
::
?: (~(has by clients.orphan-status) anchor)
$(orphans t.orphans)
:: :build was the last client on this duct so remove it
::
=. builds.state (remove-anchor-from-subs i.orphans anchor)
=. state (cleanup i.orphans)
$(orphans t.orphans)
:: +access-build-record: access a +build-record, updating :last-accessed
::
:: Usage:
:: ```
:: =^ maybe-build-record builds.state (access-build-record build)
:: ```
::
++ access-build-record
~/ %access-build-record
|= =build
^- [(unit build-record) _builds.state]
::
?~ maybe-build-status=(~(get by builds.state) build)
[~ builds.state]
::
=/ =build-status u.maybe-build-status
::
?. ?=(%complete -.state.build-status)
[~ builds.state]
::
?: ?=(%tombstone -.build-record.state.build-status)
[`build-record.state.build-status builds.state]
::
=. last-accessed.build-record.state.build-status now
::
:- `build-record.state.build-status
(~(put by builds.state) build build-status)
:: +cleanup: try to clean up a build and its sub-builds
::
++ cleanup
~/ %cleanup
|= =build
^+ state
:: does this build even exist?!
::
?~ maybe-build-status=(~(get by builds.state) build)
state
::
=/ =build-status u.maybe-build-status
:: never delete a build that something depends on
::
?^ clients.build-status
state
?^ requesters.build-status
state
::
(remove-builds ~[build])
:: +collect-live-resources: produces all live resources from sub-scrys
::
++ collect-live-resources
~/ %collect-live-resources
|= =build
^- (jug disc resource)
::
?: ?=(%scry -.schematic.build)
=* resource resource.schematic.build
(my [(extract-disc resource) (sy [resource]~)]~)
::
?: ?=(%pin -.schematic.build)
~
::
=/ subs
~| [%collect-live-resource (build-to-tape build)]
~(tap in ~(key by subs:(~(got by builds.state) build)))
=| resources=(jug disc resource)
|-
?~ subs
resources
::
=/ sub-resources=(jug disc resource) ^$(build i.subs)
=. resources (unify-jugs resources sub-resources)
$(subs t.subs)
:: +collect-blocked-resources: produces all blocked resources from sub-scrys
::
++ collect-blocked-sub-scrys
~/ %collect-blocked-sub-scrys
|= =build
^- (set scry-request)
::
?: ?=(%scry -.schematic.build)
=, resource.schematic.build
=/ =scry-request
:+ vane care
^- beam
[[ship.disc.rail desk.disc.rail [%da date.build]] spur.rail]
(sy [scry-request ~])
:: only recurse on blocked sub-builds
::
=/ subs=(list ^build)
%+ murn ~(tap by subs:(~(got by builds.state) build))
|= [sub=^build =build-relation]
^- (unit ^build)
::
?. blocked.build-relation
~
`sub
::
=| scrys=(set scry-request)
|-
^+ scrys
?~ subs
scrys
::
=. scrys (~(uni in scrys) ^$(build i.subs))
$(subs t.subs)
:: +start-clay-subscription: listen for changes in the filesystem
::
++ start-clay-subscription
~/ %start-clay-subscription
|= =subscription
^+ ..execute
::
=/ already-subscribed=?
(~(has by pending-subscriptions.state) subscription)
::
=. pending-subscriptions.state
(put-request pending-subscriptions.state subscription duct)
:: don't send a duplicate move if we're already subscribed
::
?: already-subscribed
..execute
::
=/ =wire (clay-subscription-wire [date disc]:subscription)
::
=/ =note
:: request-contents: the set of [care path]s to subscribe to in clay
::
=/ request-contents=(set [care:clay path])
%- sy ^- (list [care:clay path])
%+ murn ~(tap in `(set resource)`resources.subscription)
|= =resource ^- (unit [care:clay path])
::
`[care.resource (flop spur.rail.resource)]
:: if :request-contents is `~`, this code is incorrect
::
?< ?=(~ request-contents)
:: their: requestee +ship
::
=+ [their desk]=disc.subscription
::
:^ %c %warp sock=[our their]
^- riff:clay
[desk `[%mult `case`[%da date.subscription] request-contents]]
::
=. moves [`move`[duct [%pass wire note]] moves]
::
..execute
:: +cancel-clay-subscription: remove a subscription on :duct
::
++ cancel-clay-subscription
~/ %cancel-clay-subscription
|= =subscription
^+ ..execute
::
=^ originator pending-subscriptions.state
(del-request pending-subscriptions.state subscription duct)
:: if there are still other ducts on this subscription, don't send a move
::
?~ originator
..execute
::
=/ =wire (clay-subscription-wire [date disc]:subscription)
::
=/ =note
=+ [their desk]=disc.subscription
[%c %warp sock=[our their] `riff:clay`[desk ~]]
::
=. moves [`move`[u.originator [%pass wire note]] moves]
::
..execute
:: +clay-sub-wire: the wire to use for a clay subscription
::
:: While it is possible for two different root builds to make
:: subscriptions with the same wire, those wires will always be associated
:: with different ducts, so there's no risk of duplicates.
::
++ clay-subscription-wire
|= [date=@da =disc]
^- wire
::
=+ [their desk]=disc
::
/(scot %p our)/clay-sub/(scot %p their)/[desk]/(scot %da date)
:: +start-scry-request: kick off an asynchronous request for a resource
::
++ start-scry-request
|= =scry-request
^+ ..execute
:: if we are the first block depending on this scry, send a move
::
=/ already-started=? (~(has by pending-scrys.state) scry-request)
::
=. pending-scrys.state
(put-request pending-scrys.state scry-request duct)
:: don't send a duplicate move if we've already sent one
::
?: already-started
..execute
::
=/ =wire (scry-request-wire scry-request)
::
=/ =note
=, scry-request
=/ =disc [p q]:beam
:* %c %warp sock=[our their=ship.disc] desk.disc
`[%sing care case=r.beam (flop s.beam)]
==
::
=. moves [`move`[duct [%pass wire note]] moves]
::
..execute
:: +cancel-scry-request: cancel a pending asynchronous scry request
::
++ cancel-scry-request
|= =scry-request
^+ ..execute
::
=^ originator pending-scrys.state
(del-request pending-scrys.state scry-request duct)
:: if there are still other ducts on this subscription, don't send a move
::
?~ originator
..execute
::
=/ =wire (scry-request-wire scry-request)
::
=/ =note
=+ [their desk]=[p q]:beam.scry-request
[%c %warp sock=[our their] `riff:clay`[desk ~]]
::
=. moves [`move`[u.originator [%pass wire note]] moves]
::
..execute
:: +scry-request-wire
::
++ scry-request-wire
|= =scry-request
^- wire
(welp /(scot %p our)/scry-request (scry-request-to-path scry-request))
--
--
::
:: end the =~
::
. ==
::
:::: vane interface
::
:: begin with a default +axle as a blank slate
::
=| ax=axle
:: a vane is activated with current date, entropy, and a namespace function
::
|= [now=@da eny=@ scry-gate=sley]
:: allow jets to be registered within this core
::
~% %ford ..is ~
|%
:: +call: handle a +task:able from arvo
::
:: Ford can be tasked with:
::
:: %build: perform a build
:: %keep: resize caches
:: %kill: cancel a build
:: %wipe: clear memory
::
:: The general procedure is for Ford to determine the `our` identity
:: for this +task and operate on the :ship-state for that identity.
::
:: Most requests get converted into operations to be performed inside
:: the +per-event core, which is Ford's main build engine. The %keep
:: and %wipe requests work across all identities stored in Ford, though.
::
++ call
|= [=duct type=* wrapped-task=(hobo task:able)]
^- [p=(list move) q=_ford-gate]
:: unwrap :task from :wrapped-task
::
=/ task=task:able
?. ?=(%soft -.wrapped-task)
wrapped-task
((hard task:able) p.wrapped-task)
::
?- -.task
:: %build: request to perform a build
::
%build
:: perform the build indicated by :task
::
:: First, we find or create the :ship-state for :our.task,
:: modifying :state-by-ship as necessary. Then we dispatch to the |ev
:: by constructing :event-args and using them to create :start-build,
:: which performs the build. The result of :start-build is a pair of
:: :moves and a mutant :ship-state. We update our :state-by-ship map
:: with the new :ship-state and produce it along with :moves.
::
=^ ship-state state-by-ship.ax (find-or-create-ship-state our.task)
=/ =build [now schematic.task]
=* event-args [[our.task duct now scry-gate] ship-state]
=* start-build start-build:(per-event event-args)
=^ moves ship-state (start-build build live.task)
=. state-by-ship.ax (~(put by state-by-ship.ax) our.task ship-state)
::
[moves ford-gate]
::
:: %keep: keep :count cache entries
::
%keep
::
=/ ship-states=(list [ship=@p state=ford-state])
~(tap by state-by-ship.ax)
::
=. state-by-ship.ax
|- ^+ state-by-ship.ax
?~ ship-states state-by-ship.ax
::
=, i.ship-states
=* event-args [[ship duct now scry-gate] state]
::
=. state-by-ship.ax
%+ ~(put by state-by-ship.ax) ship
(keep:(per-event event-args) [compiler-cache build-cache]:task)
::
$(ship-states t.ship-states)
::
[~ ford-gate]
::
:: %kill: cancel a %build
::
%kill
::
=/ ship-state ~|(our+our.task (~(got by state-by-ship.ax) our.task))
=* event-args [[our.task duct now scry-gate] ship-state]
=^ moves ship-state cancel:(per-event event-args)
=. state-by-ship.ax (~(put by state-by-ship.ax) our.task ship-state)
::
[moves ford-gate]
::
:: %sunk: foreign ship has lost continutity
::
%sunk
::
[~ ford-gate]
::
:: %wipe: wipe stored builds, clearing :percent-to-remove of the entries
::
%wipe
::
=/ ship-states=(list [ship=@p state=ford-state])
~(tap by state-by-ship.ax)
::
=. state-by-ship.ax
|- ^+ state-by-ship.ax
?~ ship-states state-by-ship.ax
::
=, i.ship-states
=* event-args [[ship duct now scry-gate] state]
::
=. state-by-ship.ax
%+ ~(put by state-by-ship.ax) ship
(wipe:(per-event event-args) percent-to-remove.task)
::
$(ship-states t.ship-states)
::
[~ ford-gate]
::
%wegh
:_ ford-gate
:_ ~
:^ duct %give %mass
^- mass
:- %ford
:- %|
%+ turn ~(tap by state-by-ship.ax) :: XX single-home
|= [our=@ ford-state] ^- mass
:+ (scot %p our) %|
::
:~ [%builds [%& builds]]
[%compiler-cache [%& compiler-cache]]
==
==
:: +take: receive a response from another vane
::
:: A +take is a response to a request that Ford made of another vane.
::
:: Ford decodes the type of response based on the +wire in the +take.
:: The possibilities are:
::
:: %clay-sub: Clay notification of an update to a subscription
::
:: If Ford receives this, it will rebuild one or more live builds,
:: taking into account the new date and changed resources.
::
:: %scry-request: Clay response to a request for a resource
::
:: If Ford receives this, it will continue building one or more builds
:: that were blocked on this resource.
::
:: The general procedure is for Ford to determine the `our` identity
:: for this +task and operate on the :ship-state for that identity.
::
:: The +sign gets converted into operations to be performed inside
:: the +per-event core, which is Ford's main build engine.
::
++ take
|= [=wire =duct wrapped-sign=(hypo sign)]
^- [p=(list move) q=_ford-gate]
:: unwrap :sign, ignoring unneeded +type in :p.wrapped-sign
::
=/ =sign q.wrapped-sign
:: :wire must at least contain :our and a tag for dispatching
::
?> ?=([@ @ *] wire)
:: :parse our from the head of :wire
::
=/ our=@p (slav %p i.wire)
::
::
=/ ship-state
:: we know :our is already in :state-by-ship because we sent this request
::
~| [%take-our our]
(~(got by state-by-ship.ax) our)
::
|^ ^- [p=(list move) q=_ford-gate]
::
=^ moves ship-state
?+ i.t.wire ~|([%bad-take-wire wire] !!)
%clay-sub take-rebuilds
%scry-request take-unblocks
==
::
=. state-by-ship.ax (~(put by state-by-ship.ax) our ship-state)
::
[moves ford-gate]
:: +take-rebuilds: rebuild all live builds affected by the Clay changes
::
++ take-rebuilds
^- [(list move) ford-state]
::
?> ?=([%c %wris *] sign)
=+ [ship desk date]=(raid:wired t.t.wire ~[%p %tas %da])
=/ disc [ship desk]
::
=/ =subscription
~| [%ford-take-bad-clay-sub wire=wire duct=duct]
=/ =duct-status (~(got by ducts.ship-state) duct)
?> ?=(%live -.live.duct-status)
?> ?=(^ last-sent.live.duct-status)
?> ?=(^ subscription.u.last-sent.live.duct-status)
u.subscription.u.last-sent.live.duct-status
::
=/ ducts=(list ^duct)
~| [%ford-take-missing-subscription subscription]
(get-request-ducts pending-subscriptions.ship-state subscription)
::
=| moves=(list move)
|- ^+ [moves ship-state]
?~ ducts [moves ship-state]
::
=* event-args [[our i.ducts now scry-gate] ship-state]
=* rebuild rebuild:(per-event event-args)
=^ duct-moves ship-state
(rebuild subscription p.case.sign disc care-paths.sign)
::
$(ducts t.ducts, moves (weld moves duct-moves))
:: +take-unblocks: unblock all builds waiting on this scry request
::
++ take-unblocks
^- [(list move) ford-state]
::
?> ?=([%c %writ *] sign)
:: scry-request: the +scry-request we had previously blocked on
::
=/ =scry-request
~| [%ford-take-bad-scry-request wire=wire duct=duct]
(need (path-to-scry-request t.t.wire))
:: scry-result: parse a (unit cage) from :sign
::
:: If the result is `~`, the requested resource was not available.
::
=/ scry-result=(unit cage)
?~ riot.sign
~
`r.u.riot.sign
::
=/ ducts=(list ^duct)
~| [%ford-take-missing-scry-request scry-request]
(get-request-ducts pending-scrys.ship-state scry-request)
::
=| moves=(list move)
|- ^+ [moves ship-state]
?~ ducts [moves ship-state]
::
=* event-args [[our i.ducts now scry-gate] ship-state]
:: unblock the builds that had blocked on :resource
::
=* unblock unblock:(per-event event-args)
=^ duct-moves ship-state (unblock scry-request scry-result)
::
$(ducts t.ducts, moves (weld moves duct-moves))
--
:: +load: migrate old state to new state (called on vane reload)
::
++ load
|= old=axle
^+ ..^$
::
~! %loading
..^$(ax old)
:: +stay: produce current state
::
++ stay `axle`ax
:: +scry: request a path in the urbit namespace
::
++ scry
|= *
[~ ~]
:: %utilities
::
::+|
::
++ ford-gate ..$
:: +find-or-create-ship-state: find or create a ford-state for a @p
::
:: Accesses and modifies :state-by-ship.
::
++ find-or-create-ship-state
|= our=@p
^- [ford-state _state-by-ship.ax]
::
=/ existing (~(get by state-by-ship.ax) our)
?^ existing
[u.existing state-by-ship.ax]
::
=| new-state=ford-state
[new-state (~(put by state-by-ship.ax) our new-state)]
--
Reference in New Issue View Git Blame Copy Permalink