urbit/shrub
1
1
Fork 0
mirror of https://github.com/urbit/shrub.git synced 2024-12-24 11:24:21 +03:00
Code Issues Packages Projects Releases Wiki Activity
4940501f3b
shrub/pkg/arvo/app/group-hook.hoon

253 lines
6.3 KiB
Plaintext
Raw Normal View History

static gall: convert group-hook
2019-11-21 02:37:43 +03:00
:: group-hook: allow syncing group data from foreign paths to local paths
::
/- *group-store, *group-hook
dbug: augment various apps with /lib/dbug Also includes lib/verb where it wasn't being used yet.
2020-01-21 23:36:03 +03:00
/+ default-agent, verb, dbug
static gall: convert group-hook
2019-11-21 02:37:43 +03:00
|%
+$ card card:agent:gall
::
++ versioned-state
$% state-zero
==
::
::
+$ state-zero
$: %0
synced=(map path ship)
==
::
--
::
=| state-zero
=* state -
dbug: augment various apps with /lib/dbug Also includes lib/verb where it wasn't being used yet.
2020-01-21 23:36:03 +03:00
::
%- agent:dbug
%+ verb |
static gall: convert group-hook
2019-11-21 02:37:43 +03:00
^- agent:gall
=<
|_ =bowl:gall
+* this .
group-core +>
gc ~(. group-core bowl)
def ~(. (default-agent this %|) bowl)
::
++ on-init on-init:def
++ on-save !>(state)
++ on-load
group-hook: use actual synced data in +on-load It's gonna be ~ if we pull it from the app core during +on-load.
2020-03-27 01:58:15 +03:00
|= =vase
group-hook: on-load, re-establish subscriptions For every item in the synced map that doesn't have a matching outgoing subscription, re-establish the subscription we expect to have.
2020-03-26 22:19:18 +03:00
^- (quip card _this)
group-hook: use actual synced data in +on-load It's gonna be ~ if we pull it from the app core during +on-load.
2020-03-27 01:58:15 +03:00
=/ old !<(state-zero vase)
:_ this(state old)
group-hook: on-load, re-establish subscriptions For every item in the synced map that doesn't have a matching outgoing subscription, re-establish the subscription we expect to have.
2020-03-26 22:19:18 +03:00
%+ murn
group-hook: use actual synced data in +on-load It's gonna be ~ if we pull it from the app core during +on-load.
2020-03-27 01:58:15 +03:00
~(tap by synced.old)
group-hook: on-load, re-establish subscriptions For every item in the synced map that doesn't have a matching outgoing subscription, re-establish the subscription we expect to have.
2020-03-26 22:19:18 +03:00
|= [=path =ship]
^- (unit card)
=/ =wire
[(scot %p ship) %group path]
=/ =term
?: =(our.bowl ship)
%group-store
%group-hook
?: (~(has by wex.bowl) [wire ship term])
~
`[%pass wire %agent [ship term] %watch [%group path]]
::
static gall: convert group-hook
2019-11-21 02:37:43 +03:00
++ on-leave on-leave:def
++ on-peek on-peek:def
++ on-arvo on-arvo:def
++ on-fail on-fail:def
::
++ on-poke
|= [=mark =vase]
^- (quip card _this)
?. ?=(%group-hook-action mark)
(on-poke:def mark vase)
=^ cards state
(poke-group-hook-action:gc !<(group-hook-action vase))
[cards this]
::
++ on-watch
|= =path
^- (quip card _this)
?. ?=([%group @ *] path)
(on-watch:def path)
?. (~(has by synced.state) t.path)
(on-watch:def path)
=/ scry-path=^path
:(welp /=group-store/(scot %da now.bowl) t.path /noun)
=/ grp=(unit group)
permission-group-hook: fixed permission associate flow
2019-12-06 02:45:30 +03:00
.^((unit group) %gx scry-path)
static gall: convert group-hook
2019-11-21 02:37:43 +03:00
?~ grp
(on-watch:def path)
:_ this
[%give %fact ~ %group-update !>([%path u.grp t.path])]~
::
++ on-agent
|= [=wire =sign:agent:gall]
^- (quip card _this)
?+ -.sign (on-agent:def wire sign)
::
%watch-ack
?~ p.sign
[~ this]
%- (slog u.p.sign)
group-hook: touch up watch-nack and kick logic In both, we make clear that the wire is always of the /@/group/^ form, and alias the "group path" portion of the wire for clarity. For kick, more obviously reuse the same wire, don't reconstruct it. For watch-nack, only delete from the synced map if the source of the watch-nack is still relevant. While we don't expect this to be relevant considering current mode of operation, this does protect us against strange cases.
2020-03-26 22:16:30 +03:00
?> ?=([@ %group ^] wire)
=/ =ship (slav %p i.wire)
=* group t.t.wire
:: only remove from synced if this watch-nack came from the ship we
:: thought we were actively syncing from
::
=? synced.state
=(ship (~(gut by synced.state) group ship))
(~(del by synced.state) group)
static gall: convert group-hook
2019-11-21 02:37:43 +03:00
[~ this]
::
%kick
group-hook: touch up watch-nack and kick logic In both, we make clear that the wire is always of the /@/group/^ form, and alias the "group path" portion of the wire for clarity. For kick, more obviously reuse the same wire, don't reconstruct it. For watch-nack, only delete from the synced map if the source of the watch-nack is still relevant. While we don't expect this to be relevant considering current mode of operation, this does protect us against strange cases.
2020-03-26 22:16:30 +03:00
?> ?=([@ %group ^] wire)
static gall: convert group-hook
2019-11-21 02:37:43 +03:00
=/ =ship (slav %p i.wire)
group-hook: touch up watch-nack and kick logic In both, we make clear that the wire is always of the /@/group/^ form, and alias the "group path" portion of the wire for clarity. For kick, more obviously reuse the same wire, don't reconstruct it. For watch-nack, only delete from the synced map if the source of the watch-nack is still relevant. While we don't expect this to be relevant considering current mode of operation, this does protect us against strange cases.
2020-03-26 22:16:30 +03:00
=* group t.t.wire
?. (~(has by synced.state) group)
static gall: convert group-hook
2019-11-21 02:37:43 +03:00
[~ this]
group-hook: touch up watch-nack and kick logic In both, we make clear that the wire is always of the /@/group/^ form, and alias the "group path" portion of the wire for clarity. For kick, more obviously reuse the same wire, don't reconstruct it. For watch-nack, only delete from the synced map if the source of the watch-nack is still relevant. While we don't expect this to be relevant considering current mode of operation, this does protect us against strange cases.
2020-03-26 22:16:30 +03:00
=* group-path t.wire
static gall: convert group-hook
2019-11-21 02:37:43 +03:00
:_ this
group-hook: touch up watch-nack and kick logic In both, we make clear that the wire is always of the /@/group/^ form, and alias the "group path" portion of the wire for clarity. For kick, more obviously reuse the same wire, don't reconstruct it. For watch-nack, only delete from the synced map if the source of the watch-nack is still relevant. While we don't expect this to be relevant considering current mode of operation, this does protect us against strange cases.
2020-03-26 22:16:30 +03:00
[%pass wire %agent [ship %group-hook] %watch group-path]~
static gall: convert group-hook
2019-11-21 02:37:43 +03:00
::
%fact
?. ?=(%group-update p.cage.sign)
(on-agent:def wire sign)
=^ cards state
?: (team:title our.bowl src.bowl)
(handle-local:gc !<(group-update q.cage.sign))
(handle-foreign:gc !<(group-update q.cage.sign))
[cards this]
==
--
::
|_ bol=bowl:gall
::
++ poke-group-hook-action
|= act=group-hook-action
^- (quip card _state)
?- -.act
%add
?. (team:title our.bol src.bol)
[~ state]
=/ group-path [%group path.act]
=/ group-wire [(scot %p ship.act) group-path]
?: (~(has by synced.state) path.act)
[~ state]
=. synced.state (~(put by synced.state) path.act ship.act)
:_ state
?: =(ship.act our.bol)
[%pass group-wire %agent [ship.act %group-store] %watch group-path]~
[%pass group-wire %agent [ship.act %group-hook] %watch group-path]~
::
%remove
=/ ship (~(get by synced.state) path.act)
?~ ship
[~ state]
?: &(=(u.ship our.bol) (team:title our.bol src.bol))
:: delete one of our own paths
=/ group-wire [(scot %p our.bol) %group path.act]
:_ state(synced (~(del by synced.state) path.act))
%+ snoc
(pull-wire group-wire path.act)
gall: (list path) in %fact and %kick Instead of providing a (unit path), allows for (list path), which better supports the "update to path and subpath cases". For example, if /things wants updates about everything, and /things/specific wants updates about the specific thing, they'll both need to receive a %fact when the specific thing changes. Previously, these would have been two separate moves. Now, gall handles the multi-targeting for you.
2019-12-22 23:12:28 +03:00
[%give %kick [%group path.act]~ ~]
static gall: convert group-hook
2019-11-21 02:37:43 +03:00
?: |(=(u.ship src.bol) (team:title our.bol src.bol))
:: delete a foreign ship's path
=/ group-wire [(scot %p u.ship) %group path.act]
:_ state(synced (~(del by synced.state) path.act))
(pull-wire group-wire path.act)
:: don't allow
[~ state]
==
::
++ handle-local
|= diff=group-update
^- (quip card _state)
?- -.diff
%keys [~ state]
%path [~ state]
%bundle [~ state]
%add [(update-subscribers [%group pax.diff] diff) state]
%remove [(update-subscribers [%group pax.diff] diff) state]
::
%unbundle
:_ state(synced (~(del by synced.state) pax.diff))
%+ snoc
(update-subscribers [%group pax.diff] diff)
gall: (list path) in %fact and %kick Instead of providing a (unit path), allows for (list path), which better supports the "update to path and subpath cases". For example, if /things wants updates about everything, and /things/specific wants updates about the specific thing, they'll both need to receive a %fact when the specific thing changes. Previously, these would have been two separate moves. Now, gall handles the multi-targeting for you.
2019-12-22 23:12:28 +03:00
[%give %kick [%group pax.diff]~ ~]
static gall: convert group-hook
2019-11-21 02:37:43 +03:00
==
::
++ handle-foreign
|= diff=group-update
^- (quip card _state)
?- -.diff
%keys [~ state]
%bundle [~ state]
::
%path
:_ state
?~ pax.diff ~
=/ ship (~(get by synced.state) pax.diff)
?~ ship ~
?. =(src.bol u.ship) ~
:~ (group-poke pax.diff [%unbundle pax.diff])
(group-poke pax.diff [%bundle pax.diff])
(group-poke pax.diff [%add members.diff pax.diff])
==
::
%add
:_ state
?~ pax.diff ~
=/ ship (~(get by synced.state) pax.diff)
?~ ship ~
?. =(src.bol u.ship) ~
[(group-poke pax.diff diff)]~
::
%remove
:_ state
?~ pax.diff ~
=/ ship (~(get by synced.state) pax.diff)
?~ ship ~
?. =(src.bol u.ship) ~
[(group-poke pax.diff diff)]~
::
%unbundle
?~ pax.diff
[~ state]
=/ ship (~(get by synced.state) pax.diff)
?~ ship
[~ state]
?. =(src.bol u.ship)
[~ state]
:_ state(synced (~(del by synced.state) pax.diff))
[(group-poke pax.diff diff)]~
==
::
++ group-poke
|= [pax=path action=group-action]
^- card
[%pass pax %agent [our.bol %group-store] %poke %group-action !>(action)]
::
++ group-scry
|= pax=path
^- (unit group)
permission-group-hook: fixed permission associate flow
2019-12-06 02:45:30 +03:00
.^((unit group) %gx ;:(weld /=group-store/(scot %da now.bol) pax /noun))
static gall: convert group-hook
2019-11-21 02:37:43 +03:00
::
++ update-subscribers
|= [pax=path diff=group-update]
^- (list card)
gall: (list path) in %fact and %kick Instead of providing a (unit path), allows for (list path), which better supports the "update to path and subpath cases". For example, if /things wants updates about everything, and /things/specific wants updates about the specific thing, they'll both need to receive a %fact when the specific thing changes. Previously, these would have been two separate moves. Now, gall handles the multi-targeting for you.
2019-12-22 23:12:28 +03:00
[%give %fact ~[pax] %group-update !>(diff)]~
static gall: convert group-hook
2019-11-21 02:37:43 +03:00
::
++ pull-wire
|= [wir=wire pax=path]
^- (list card)
=/ shp (~(get by synced.state) pax)
?~ shp
~
?: =(u.shp our.bol)
[%pass wir %agent [our.bol %group-store] %leave ~]~
[%pass wir %agent [u.shp %group-hook] %leave ~]~
::
--
Reference in New Issue Copy Permalink