domain/architecture/system/deployment/launchd/effects.bend source

domain/architecture/system/deployment/launchd/effects.bend on the hub · documented module

import Baseimport bend-net-json@0.3.0.0/json.bend as Jsonimport ../../effs/io.bend as Ximport ../../plan/type.bend as Pimport ../nix_darwin/type.bend as NDimport ../nix_darwin/effects.bend as NDEimport ./type.bend as Limport ./ops.bend as LO# What a launchd node needs, from the Mac as it is: each agent's program installed, its plist as declared and# loaded, its port held by nothing else; and each Tailscale serve as declared.def tailscale() -> String:  "/Applications/Tailscale.app/Contents/MacOS/Tailscale"def program_of(a: L.Agent) -> String:  match a:    case L.Agent{_, _, program, _, _, _, _, _}:      program# The program: current, to install from its build, or blocked when it neither builds nor is installed.def program_step(+entry: String, built: Bool, same: Bool, present: Bool, +from: String, +program: String, +what: String) -> List<&2, P.Step>:  Bool.pick(List<&2, P.Step>, String.is_empty(entry),    Bool.pick(List<&2, P.Step>, present, [], [P.Blocked{what, program ++ " is not installed"}]),    Bool.pick(List<&2, P.Step>, Bool.not(built), [P.Blocked{what, entry ++ " does not build"}],      Bool.pick(List<&2, P.Step>, same, [P.Current{"program " ++ program}], [P.Install{from, program}])))# The agent is current only while its program is as built, its plist as declared, and it is loaded; otherwise it# is (re)launched, after its program installs.def agent_step(present: Bool, +current: String, loaded: Bool, +home: String, +domain: String, +what: String, a: L.Agent) -> P.Step:  match a:    case L.Agent{_, +label, +program, _, _, _, _, _}:      +want = LO.plist(home, a)      Bool.pick(P.Step, present && String.eq(current, want) && loaded, P.Current{"launch agent " ++ label},        P.Launch{label, LO.path(home, label), want, domain})def agent_steps(xs: List<&2, L.Agent>, +root: String, +home: String, +domain: String, +socks: List<&2, String>, +what: String) -> IO(List<&2, P.Step>):  match xs:    case []:      IO.pure(List<&2, P.Step>, [])    case +a <> rest:      do IO<List<&2, P.Step>>:        +label : String = LO.label_of(a)        +entry : String = LO.entry_of(a)        +from : String = root ++ "/.git/v-launchd/" ++ label        _ : Bool <- X.succeeds("/bin/mkdir", ["-p", root ++ "/.git/v-launchd"])        built : Bool <- Bool.pick(IO(Bool), String.is_empty(entry), IO.pure(Bool, False{}), X.succeeds(home ++ "/.bend/bin/bend", [root ++ "/" ++ entry, "-o", from]))        +same : Bool <- X.succeeds("/usr/bin/cmp", ["-s", from, program_of(a)])        +installed : Bool <- X.succeeds("/bin/test", ["-x", program_of(a)])        +present : Bool = installed && (String.is_empty(entry) || same)        current : String <- X.read(LO.path(home, label))        loaded : Bool <- X.succeeds("/bin/launchctl", ["print", domain ++ "/" ++ label])        owned : List<&2, String> <- NDE.pids([domain ++ "/" ++ label])        +port : String = U32.show(LO.port_of(a))        +held : List<&2, String> = NDE.dedupe(NDE.holders(socks, port, owned, "IPNExtension"))        more : List<&2, P.Step> <- agent_steps(rest, root, home, domain, socks, what)        return List.append(&2, P.Step, program_step(entry, built, same, installed, from, program_of(a), what),          agent_step(present, current, loaded, home, domain, what, a) <>          List.append(&2, P.Step, Bool.pick(List<&2, P.Step>, U32.is_eq(LO.port_of(a), 0), [], NDE.blocked_by(held, what, "local port " ++ port ++ " is held by ")), more))def observe(+root: String, +what: String, +ld: L.Launchd, +uid: String, lsof: String) -> IO(List<&2, P.Step>):  do IO<List<&2, P.Step>>:    +home : String <- X.home()    status : String <- X.run(tailscale(), ["serve", "status", "--json"])    agents : List<&2, P.Step> <- agent_steps(LO.agents(ld), root, home, "gui/" ++ uid, NDE.sockets(NDE.lines(lsof), "", ""), what)    return List.append(&2, P.Step, agents,      NDE.serve_steps(LO.serves(ld), NDE.at(NDE.or_null(Json.parse(status)), "Web"), NDE.ports(LO.ports(LO.agents(ld))), tailscale(), what))def read_or(unread: Bool, +root: String, +what: String, ld: L.Launchd, uid: String, lsof: String) -> IO(List<&2, P.Step>):  match unread:    case True{}:      IO.pure(List<&2, P.Step>, [P.Blocked{what, "cannot read the Mac: `id -u` or `lsof` failed"}])    case False{}:      observe(root, what, ld, uid, lsof)def checks(+root: String, +node: String, ld: L.Launchd) -> IO(List<&2, P.Step>):  do IO<List<&2, P.Step>>:    +uid : String <- X.run("/usr/bin/id", ["-u"])    +lsof : String <- X.run("/usr/sbin/lsof", ["+c", "0", "-nP", "-iTCP", "-sTCP:LISTEN", "-F", "pcn"])    read_or(String.is_empty(String.trim(uid)) || String.is_empty(lsof), root, "launchd " ++ node, ld, String.trim(uid), lsof)