diff --git a/robot-docs/kernel.md b/robot-docs/kernel.md index 42cae10e..b556570f 100644 --- a/robot-docs/kernel.md +++ b/robot-docs/kernel.md @@ -229,6 +229,20 @@ dedupe: and `jobs` only update ownership and observations, which converge; a `done` nobody waits for rewrites the same outcome; traces save by cell id. +## the runtime scheduler + +`harness/runtime/boot.gleam` owns every worker the runtime actor starts. +Booting, attaching, swapping a stale kernel at open, an explicit upgrade, +recomposing for a reload (proposed or desired), and a composition read all +queue as a `BootRequest` and run through `boot_next`, which admits them into +`boot_slots` workers, one class never starving the other. A handler that +queues a request ends in `|> boot.boot_next` in `serve`; nothing spawns a +kernel worker outside `start`. Each worker computes off the actor, then +`deliver`s its message or, when the runtime stopped meanwhile, releases what +it made (`work`). `runtime/state` names the generation lifecycle a request +belongs to: `admit` opens one, `current_waiters` says whether a result is +still for it, `generation_over` ends it and replays what waited. + ## drops - the connection drops (the relay's socket closes, or the bridge dies): the port owner reattaches with backoff (50 ms doubling to diff --git a/src/albedo/harness/runtime.gleam b/src/albedo/harness/runtime.gleam index 22e9d2b6..941208a0 100644 --- a/src/albedo/harness/runtime.gleam +++ b/src/albedo/harness/runtime.gleam @@ -556,12 +556,10 @@ fn serve( True, True -> case runtime_state.upgradable(session) { True -> - actor.continue(upgrade.start_upgrade( - state, - id, - session, - answer, - )) + actor.continue( + upgrade.start_upgrade(state, id, session, answer) + |> boot.boot_next, + ) False -> { answer(Ok(session)) actor.continue(runtime_state.holding( @@ -644,7 +642,9 @@ fn serve( reload.reload(state, id, cwd, change, reply) |> boot.boot_next, ) runtime_state.ReloadDesired(id, cwd, reply) -> - actor.continue(reload.start_desired_reload(state, id, cwd, reply)) + actor.continue( + reload.start_desired_reload(state, id, cwd, reply) |> boot.boot_next, + ) runtime_state.Reloaded(id, generation, previous, outcome, reply) -> actor.continue( reload.reloaded(state, id, generation, previous, outcome, reply) diff --git a/src/albedo/harness/runtime/boot.gleam b/src/albedo/harness/runtime/boot.gleam index d3e05d07..015100c3 100644 --- a/src/albedo/harness/runtime/boot.gleam +++ b/src/albedo/harness/runtime/boot.gleam @@ -2,7 +2,6 @@ //// upgrades, and observations into a bounded set of workers, and reattaches //// recorded kernels after a daemon restart. -import albedo/daemon/session_catalog import albedo/harness/extension import albedo/harness/extensions/python/kernel as python import albedo/harness/protect @@ -47,241 +46,256 @@ pub fn boot_next(state: runtime_state.State) -> runtime_state.State { _ -> 0 }, ) - let self = state.self - let owner = state.work - case request { - runtime_state.Observe(id, home, reply, retries) -> { - let inventory = observation.composition_inventory(state) - // A read captures only this session's bases, never the runtime cache. - let retained = - list.filter_map( - [ - dict.get(state.desired, id) |> option.from_result, - dict.get(state.compositions, id) - |> option.from_result - |> option.then(fn(value) { value.basis }), - ], - option.to_result(_, Nil), - ) - let cached = dict.get(state.compositions, id) |> option.from_result - process.spawn_unlinked(fn() { - let discovered = - protect.attempt(fn() { - case reply { - runtime_state.CompositionReply(_) -> - observation.retained_desired(inventory, retained, home, id) - runtime_state.CatalogReply(_) -> - observation.desired(inventory, retained, home, id) - } - }) - |> result.flatten - let observed = case reply { - runtime_state.CompositionReply(_) -> - runtime_state.CompositionResult({ - use value <- result.try(discovered) - protect.attempt(fn() { - observation.observe_composition_value( - inventory, - cached, - value.snapshot, - id, - ) - }) - |> result.flatten - }) - runtime_state.CatalogReply(_) -> - runtime_state.CatalogResult({ - use _ <- result.try(case discovered { - Error("session not found") -> Error("session not found") - _ -> Ok(Nil) - }) - Ok(runtime_state.CatalogObservation( - result.map(discovered, fn(value) { value.snapshot }), - option.then(cached, fn(value) { value.loaded_revision }), - option.map(cached, fn(value) { - extension.command_entries(value.composition) - }) - |> option.unwrap([]), - option.map(cached, fn(value) { - extension.client_commands(value.composition) - }) - |> option.unwrap([]), - )) - }) - } - // Recheck after plugin observation, not just after file discovery. - let discovered = - protect.attempt(fn() { - use value <- result.try(discovered) - use unchanged <- result.try(case reply { - runtime_state.CompositionReply(_) -> - session_catalog.saved_key(home, inventory, id) - |> result.map(fn(saved) { saved == value.saved }) - runtime_state.CatalogReply(_) -> - session_catalog.inputs(home, inventory, id) - |> result.map(fn(after) { after.key == value.inputs }) - }) - case unchanged { - True -> Ok(value) - False -> - Error("composition inputs changed during observation") - } - }) - |> result.flatten - process.send( - self, - runtime_state.Observed( - id, - home, - retries, - cached, - discovered, - reply, - observed, - ), - ) - }) - } - runtime_state.Compose(id, cwd, generation) -> { - let inventory = observation.composition_inventory(state) - let retained = observation.retained_basis(state) - process.spawn_unlinked(fn() { - let prepared = - protect.attempt(fn() { - preparation.build_cached(inventory, id, cwd, None, [], retained) - }) - |> result.flatten - case runtime_state.owner_alive(self) { - True -> - process.send( - self, - runtime_state.Composed(id, generation, prepared), - ) - False -> { - case prepared { - Ok(cached) -> extension.close(cached.composition) - Error(_) -> Nil - } - } - } - }) - } - runtime_state.BootKernel(id, generation, cached) -> - process.spawn_unlinked(fn() { - let outcome = case - protect.attempt(fn() { kernels.open_kernel(owner, id, cached) }) - { - Ok(result) -> result - Error(crash) -> - Error(python.Unavailable("kernel boot failed: " <> crash)) - } - case runtime_state.owner_alive(self) { - True -> - process.send( - self, - runtime_state.Booted(id, generation, outcome), - ) - False -> { - case outcome { - Ok(session) -> - kernels.drop_kernel("boot for a stopped runtime", session) - Error(_) -> Nil - } - } - } + start(state, request) + boot_next(state) + } + [] -> state + } +} + +/// Runs `compute` off the actor, then `deliver`s its value to the actor, or +/// hands it to `orphaned` when the runtime stopped meanwhile. +fn work( + self: Subject(runtime_state.Message), + compute: fn() -> a, + deliver: fn(a) -> Nil, + orphaned: fn(a) -> Nil, +) -> Nil { + process.spawn_unlinked(fn() { + let value = compute() + case runtime_state.owner_alive(self) { + True -> deliver(value) + False -> orphaned(value) + } + }) + Nil +} + +/// One admitted request's worker. Each captures what it needs from the +/// state here; none holds the state itself. +fn start( + state: runtime_state.State, + request: runtime_state.BootRequest, +) -> Nil { + let self = state.self + let owner = state.work + let inventory = observation.composition_inventory(state) + case request { + runtime_state.Observe(id, home, reply, retries) -> { + let retained = observation.bases_for(state, id) + let cached = dict.get(state.compositions, id) |> option.from_result + work( + self, + fn() { + observation.observe(inventory, retained, cached, home, id, reply) + }, + fn(read) { + let #(discovered, observed) = read + process.send( + self, + runtime_state.Observed( + id, + home, + retries, + cached, + discovered, + reply, + observed, + ), + ) + }, + fn(_) { Nil }, + ) + } + runtime_state.Compose(id, cwd, generation) -> { + let retained = observation.retained_basis(state) + work( + self, + fn() { + protect.attempt(fn() { + preparation.build_cached(inventory, id, cwd, None, [], retained) }) - runtime_state.AttachKernel(id, generation, cached, reply) -> - process.spawn_unlinked(fn() { - let outcome = - protect.attempt(fn() { kernels.resume_kernel(owner, id, cached) }) - |> result.map_error(fn(crash) { - python.Unavailable("kernel reattach failed: " <> crash) - }) - case runtime_state.owner_alive(self) { - True -> - process.send( - self, - runtime_state.Reattached(id, generation, cached, outcome), - ) - False -> { - case outcome { - Ok(Some(session)) -> - kernels.drop_kernel( - "reattach for a stopped runtime", - session, - ) - _ -> Nil - } - } - } - process.send(reply, Nil) + |> result.flatten + }, + fn(prepared) { + process.send(self, runtime_state.Composed(id, generation, prepared)) + }, + fn(prepared) { + case prepared { + Ok(cached) -> extension.close(cached.composition) + Error(_) -> Nil + } + }, + ) + } + runtime_state.BootKernel(id, generation, cached) -> + work( + self, + fn() { + case + protect.attempt(fn() { kernels.open_kernel(owner, id, cached) }) + { + Ok(result) -> result + Error(crash) -> + Error(python.Unavailable("kernel boot failed: " <> crash)) + } + }, + fn(outcome) { + process.send(self, runtime_state.Booted(id, generation, outcome)) + }, + drop_if_booted("boot for a stopped runtime"), + ) + runtime_state.SwapStale(id, generation, cached, session) -> + work( + self, + fn() { upgrade.swap_stale(owner, id, cached, session) }, + fn(outcome) { + process.send(self, runtime_state.Booted(id, generation, outcome)) + }, + drop_if_booted("upgrade for a stopped runtime"), + ) + runtime_state.AttachKernel(id, generation, cached, reply) -> + work( + self, + fn() { + protect.attempt(fn() { kernels.resume_kernel(owner, id, cached) }) + |> result.map_error(fn(crash) { + python.Unavailable("kernel reattach failed: " <> crash) }) - runtime_state.UpgradeKernel(id, generation, cached, previous, answer) -> - process.spawn_unlinked(fn() { - let outcome = - protect.attempt(fn() { - upgrade.upgrade_value(owner, id, cached, previous) - }) - |> result.flatten - case runtime_state.owner_alive(self) { - True -> - process.send( - self, - runtime_state.UpgradedKernel( - id, - generation, - previous, - outcome, - answer, - ), - ) - False -> { - upgrade.discard_upgrade(previous, outcome) - answer(Error("runtime owner stopped during kernel upgrade")) - } - } + }, + fn(outcome) { + process.send( + self, + runtime_state.Reattached(id, generation, cached, outcome), + ) + process.send(reply, Nil) + }, + fn(outcome) { + case outcome { + Ok(Some(session)) -> + kernels.drop_kernel("reattach for a stopped runtime", session) + _ -> Nil + } + process.send(reply, Nil) + }, + ) + runtime_state.UpgradeKernel(id, generation, cached, previous, answer) -> + work( + self, + fn() { + protect.attempt(fn() { + upgrade.upgrade_value(owner, id, cached, previous) }) - runtime_state.RecomposeSelected( - id, - generation, - cwd, - selected, - demanded, - persist, - previous, - reply, - ) -> { - let inventory = observation.composition_inventory(state) - let retained = observation.retained_basis(state) - process.spawn_unlinked(fn() { - let outcome = - protect.attempt(fn() { - reload.recompose_selected( - inventory, - retained, - id, - cwd, - selected, - demanded, - persist, - previous, - ) - }) - |> result.flatten - reload.publish_reload( - self, + |> result.flatten + }, + fn(outcome) { + process.send( + self, + runtime_state.UpgradedKernel( id, generation, previous, outcome, - reply, + answer, + ), + ) + }, + fn(outcome) { + upgrade.discard_upgrade(previous, outcome) + answer(Error("runtime owner stopped during kernel upgrade")) + }, + ) + runtime_state.RecomposeSelected( + id, + generation, + cwd, + selected, + demanded, + persist, + previous, + reply, + ) -> { + let retained = observation.retained_basis(state) + work( + self, + fn() { + protect.attempt(fn() { + reload.recompose_selected( + inventory, + retained, + id, + cwd, + selected, + demanded, + persist, + previous, ) }) - } - } - boot_next(state) + |> result.flatten + }, + deliver_reload(self, id, generation, previous, reply), + reload.orphaned(previous, _, reply), + ) + } + runtime_state.RecomposeDesired( + id, + generation, + cwd, + previous, + active_strategy, + reply, + ) -> { + let retained = observation.retained_basis(state) + work( + self, + fn() { + protect.attempt(fn() { + reload.recompose_desired( + inventory, + retained, + id, + cwd, + previous, + active_strategy, + ) + }) + |> result.map_error(fn(crash) { + "could not reload extensions: " <> crash + }) + |> result.flatten + }, + deliver_reload(self, id, generation, previous, reply), + reload.orphaned(previous, _, reply), + ) + } + } +} + +fn deliver_reload( + self: Subject(runtime_state.Message), + id: String, + generation: Reference, + previous: Option(runtime_state.Session), + reply: Subject(Result(Option(runtime_state.Session), String)), +) -> fn(Result(#(runtime_state.Cached, Option(runtime_state.Session)), String)) -> + Nil { + fn(outcome) { + process.send( + self, + runtime_state.Reloaded(id, generation, previous, outcome, reply), + ) + } +} + +/// A kernel that booted for a runtime that stopped has no one to hold it. +fn drop_if_booted( + context: String, +) -> fn(Result(runtime_state.Session, python.Error)) -> Nil { + fn(outcome) { + case outcome { + Ok(session) -> kernels.drop_kernel(context, session) + Error(_) -> Nil } - [] -> state } } diff --git a/src/albedo/harness/runtime/observation.gleam b/src/albedo/harness/runtime/observation.gleam index 4ef556d1..2623b107 100644 --- a/src/albedo/harness/runtime/observation.gleam +++ b/src/albedo/harness/runtime/observation.gleam @@ -4,6 +4,7 @@ import albedo/daemon/session_catalog import albedo/harness/extension +import albedo/harness/protect import albedo/harness/runtime/state as runtime_state import albedo/harness/settings import albedo/shared @@ -24,6 +25,93 @@ pub fn composition_inventory( ) } +/// The bases an observation of one session may reuse: its own desired +/// discovery and the basis its loaded composition was prepared on, never +/// another session's or the runtime cache. +pub fn bases_for( + state: runtime_state.State, + id: String, +) -> List(runtime_state.Desired) { + list.filter_map( + [ + dict.get(state.desired, id) |> option.from_result, + dict.get(state.compositions, id) + |> option.from_result + |> option.then(fn(cached) { cached.basis }), + ], + option.to_result(_, Nil), + ) +} + +/// One observation worker's reading: what it discovered, rechecked after +/// plugin observation so inputs that changed under it are reported as such, +/// and the answer for `reply`'s kind. +pub fn observe( + inventory: session_catalog.Inventory, + retained: List(runtime_state.Desired), + cached: Option(runtime_state.Cached), + home: String, + id: String, + reply: runtime_state.ObservationReply, +) -> #(Result(runtime_state.Desired, String), runtime_state.ObservationResult) { + let discovered = + protect.attempt(fn() { + case reply { + runtime_state.CompositionReply(_) -> + retained_desired(inventory, retained, home, id) + runtime_state.CatalogReply(_) -> desired(inventory, retained, home, id) + } + }) + |> result.flatten + let observed = case reply { + runtime_state.CompositionReply(_) -> + runtime_state.CompositionResult({ + use value <- result.try(discovered) + protect.attempt(fn() { + observe_composition_value(inventory, cached, value.snapshot, id) + }) + |> result.flatten + }) + runtime_state.CatalogReply(_) -> + runtime_state.CatalogResult({ + use _ <- result.try(case discovered { + Error("session not found") -> Error("session not found") + _ -> Ok(Nil) + }) + Ok(runtime_state.CatalogObservation( + result.map(discovered, fn(value) { value.snapshot }), + option.then(cached, fn(value) { value.loaded_revision }), + option.map(cached, fn(value) { + extension.command_entries(value.composition) + }) + |> option.unwrap([]), + option.map(cached, fn(value) { + extension.client_commands(value.composition) + }) + |> option.unwrap([]), + )) + }) + } + let discovered = + protect.attempt(fn() { + use value <- result.try(discovered) + use unchanged <- result.try(case reply { + runtime_state.CompositionReply(_) -> + session_catalog.saved_key(home, inventory, id) + |> result.map(fn(saved) { saved == value.saved }) + runtime_state.CatalogReply(_) -> + session_catalog.inputs(home, inventory, id) + |> result.map(fn(after) { after.key == value.inputs }) + }) + case unchanged { + True -> Ok(value) + False -> Error("composition inputs changed during observation") + } + }) + |> result.flatten + #(discovered, observed) +} + /// Trusted embeddings may prepare kernels without a daemon session row. They /// have no saved discovery basis; daemon sessions retain the real basis used /// for preparation instead of substituting a later desired revision. diff --git a/src/albedo/harness/runtime/preparation.gleam b/src/albedo/harness/runtime/preparation.gleam index 84979584..c4716938 100644 --- a/src/albedo/harness/runtime/preparation.gleam +++ b/src/albedo/harness/runtime/preparation.gleam @@ -430,9 +430,12 @@ pub fn abandon(state: runtime_state.State, id: String) -> runtime_state.State { runtime_state.AttachKernel(_, _, _, reply) -> process.send(reply, Nil) runtime_state.UpgradeKernel(_, _, _, _, answer) -> answer(Error("the session closed during kernel upgrade")) - runtime_state.RecomposeSelected(_, _, _, _, _, _, _, reply) -> + runtime_state.RecomposeSelected(reply: reply, ..) + | runtime_state.RecomposeDesired(reply: reply, ..) -> process.send(reply, Error("the session closed during reload")) - _ -> Nil + // Its opener waits in the generation and is answered with it below. + runtime_state.SwapStale(..) -> Nil + runtime_state.Compose(..) | runtime_state.BootKernel(..) -> Nil } }) dict.get(state.deferred, id) diff --git a/src/albedo/harness/runtime/reload.gleam b/src/albedo/harness/runtime/reload.gleam index 428bd535..7e3629ad 100644 --- a/src/albedo/harness/runtime/reload.gleam +++ b/src/albedo/harness/runtime/reload.gleam @@ -8,7 +8,6 @@ import albedo/harness/extensions/python/kernel as python import albedo/harness/extensions/python/link import albedo/harness/protect import albedo/harness/runtime/kernels -import albedo/harness/runtime/observation import albedo/harness/runtime/preparation import albedo/harness/runtime/state as runtime_state import albedo/shared @@ -20,10 +19,9 @@ import gleam/option.{type Option, None, Some} import gleam/result import gleam/string -pub fn publish_reload( - subject: Subject(runtime_state.Message), - id: String, - generation: Reference, +/// A recompose whose runtime stopped meanwhile: release whatever kernel the +/// session would have had and tell the caller. +pub fn orphaned( previous: Option(runtime_state.Session), outcome: Result( #(runtime_state.Cached, Option(runtime_state.Session)), @@ -31,33 +29,24 @@ pub fn publish_reload( ), reply: Subject(Result(Option(runtime_state.Session), String)), ) -> Nil { - case runtime_state.owner_alive(subject) { - True -> - process.send( - subject, - runtime_state.Reloaded(id, generation, previous, outcome, reply), - ) - False -> { - case outcome { - Error(_) -> { - case previous { - Some(session) -> - kernels.drop_kernel("reload for a stopped runtime", session) - None -> Nil - } - } - Ok(#(fresh, replacement)) -> { - case replacement { - Some(session) -> - kernels.drop_kernel("reload for a stopped runtime", session) - None -> Nil - } - extension.close(fresh.composition) - } + case outcome { + Error(_) -> { + case previous { + Some(session) -> + kernels.drop_kernel("reload for a stopped runtime", session) + None -> Nil } - process.send(reply, Error("runtime owner stopped during reload")) + } + Ok(#(fresh, replacement)) -> { + case replacement { + Some(session) -> + kernels.drop_kernel("reload for a stopped runtime", session) + None -> Nil + } + extension.close(fresh.composition) } } + process.send(reply, Error("runtime owner stopped during reload")) } /// Why the daemon will not run this extension at all, if it quarantined it. @@ -267,99 +256,114 @@ pub fn start_desired_reload( extension.compaction(extension.extensions(cached.composition)) }) |> option.map(fn(strategy) { strategy.name }) - let inventory = observation.composition_inventory(state) - let self = state.self - let retained = observation.retained_basis(state) - process.spawn_unlinked(fn() { - let outcome = - protect.attempt(fn() { - use selected <- result.try(extension.enabled( - inventory.ledger, - inventory.installed, - inventory.defaults, - id, - )) - use _ <- result.try( - case active_strategy, extension.compaction(selected) { - Some(name), None -> - Error("select another compaction strategy to replace " <> name) - _, _ -> Ok(Nil) - }, - ) - use fresh <- result.try(preparation.build_cached( - inventory, - id, - cwd, - Some(selected), - list.map(selected, fn(item) { item.name }), - retained, - )) - let rebound = - protect.attempt(fn() { - case previous { - None -> Ok(None) - Some(session) -> - case python.alive(session.kernel) { - False -> Ok(None) - True -> - case - session.cwd == cwd - && extension.python_modules(session.composition) - == extension.python_modules(fresh.composition) - { - True -> - python.rebind( - session.kernel, - kernels.kernel_routes( - inventory.ledger, - id, - fresh.composition, - ), - ) - |> result.map(fn(_) { - Some(kernels.session_over( - inventory.ledger, - id, - fresh, - session.kernel, - runtime_state.Kept, - )) - }) - False -> { - python.mark_stale(session.kernel, python.Modules) - case runtime_state.upgradable(session) { - False -> Error(python.Busy) - True -> - kernels.upgrade( - inventory.ledger, - id, - fresh, - session.kernel, - ) - |> result.map_error(fn(failure) { failure.reason }) - |> result.map(fn(upgraded) { Some(upgraded.0) }) - } - } - } - } + let state = + runtime_state.without_session(state, id) + |> runtime_state.admit(id, generation) + runtime_state.State( + ..state, + waiting: list.append(state.waiting, [ + runtime_state.RecomposeDesired( + id, + generation, + cwd, + previous, + active_strategy, + reply, + ), + ]), + ) +} + +/// Builds the composition the saved selection asks for and keeps, rebinds, +/// swaps, or drops the live kernel to match it; run by a scheduler worker. +pub fn recompose_desired( + inventory: session_catalog.Inventory, + retained: List(runtime_state.Desired), + id: String, + cwd: String, + previous: Option(runtime_state.Session), + active_strategy: Option(String), +) -> Result(#(runtime_state.Cached, Option(runtime_state.Session)), String) { + use selected <- result.try(extension.enabled( + inventory.ledger, + inventory.installed, + inventory.defaults, + id, + )) + use _ <- result.try(case active_strategy, extension.compaction(selected) { + Some(name), None -> + Error("select another compaction strategy to replace " <> name) + _, _ -> Ok(Nil) + }) + use fresh <- result.try(preparation.build_cached( + inventory, + id, + cwd, + Some(selected), + list.map(selected, fn(item) { item.name }), + retained, + )) + let rebound = + protect.attempt(fn() { rebound(inventory, id, cwd, previous, fresh) }) + |> result.map_error(fn(crash) { python.Unavailable(crash) }) + |> result.flatten + case rebound { + Ok(session) -> Ok(#(fresh, session)) + Error(error) -> { + extension.close(fresh.composition) + Error("could not reload extensions: " <> string.inspect(error)) + } + } +} + +/// The live kernel over the fresh composition: rebound when its modules are +/// unchanged, swapped when they changed and it can go, and `None` when there +/// is no live kernel, so the next open boots one. +fn rebound( + inventory: session_catalog.Inventory, + id: String, + cwd: String, + previous: Option(runtime_state.Session), + fresh: runtime_state.Cached, +) -> Result(Option(runtime_state.Session), python.Error) { + case previous { + None -> Ok(None) + Some(session) -> + case python.alive(session.kernel) { + False -> Ok(None) + True -> + case + session.cwd == cwd + && extension.python_modules(session.composition) + == extension.python_modules(fresh.composition) + { + True -> + python.rebind( + session.kernel, + kernels.kernel_routes(inventory.ledger, id, fresh.composition), + ) + |> result.map(fn(_) { + Some(kernels.session_over( + inventory.ledger, + id, + fresh, + session.kernel, + runtime_state.Kept, + )) + }) + False -> { + python.mark_stale(session.kernel, python.Modules) + case runtime_state.upgradable(session) { + False -> Error(python.Busy) + True -> + kernels.upgrade(inventory.ledger, id, fresh, session.kernel) + |> result.map_error(fn(failure) { failure.reason }) + |> result.map(fn(upgraded) { Some(upgraded.0) }) + } } - }) - |> result.map_error(fn(crash) { python.Unavailable(crash) }) - |> result.flatten - case rebound { - Ok(session) -> Ok(#(fresh, session)) - Error(error) -> { - extension.close(fresh.composition) - Error("could not reload extensions: " <> string.inspect(error)) } - } - }) - |> result.map_error(fn(crash) { "could not reload extensions: " <> crash }) - |> result.flatten - publish_reload(self, id, generation, previous, outcome, reply) - }) - runtime_state.without_session(state, id) - |> runtime_state.admit(id, generation) + } + } } pub fn reloaded( diff --git a/src/albedo/harness/runtime/state.gleam b/src/albedo/harness/runtime/state.gleam index 0550ca2d..61ee5869 100644 --- a/src/albedo/harness/runtime/state.gleam +++ b/src/albedo/harness/runtime/state.gleam @@ -165,6 +165,19 @@ pub type BootRequest { previous: Option(Session), reply: Subject(Result(Option(Session), String)), ) + /// Recompose from the saved desired selection, keeping the live kernel + /// where its modules allow; `active_strategy` is the compaction the + /// running composition has, which the new one must not silently drop. + RecomposeDesired( + id: String, + generation: Reference, + cwd: String, + previous: Option(Session), + active_strategy: Option(String), + reply: Subject(Result(Option(Session), String)), + ) + /// Swap the stale kernel an open found; the opener waits in `booting`. + SwapStale(id: String, generation: Reference, cached: Cached, session: Session) } pub type Booting { diff --git a/src/albedo/harness/runtime/upgrade.gleam b/src/albedo/harness/runtime/upgrade.gleam index c2010ebc..2108be9e 100644 --- a/src/albedo/harness/runtime/upgrade.gleam +++ b/src/albedo/harness/runtime/upgrade.gleam @@ -1,6 +1,6 @@ -//// Swapping a session's stale kernel for a current one: started off the actor -//// like a boot, carrying what the old namespace could, and settled when the -//// worker reports which kernel the session ends up with. +//// Swapping a session's stale kernel for a current one: queued for the +//// scheduler like a boot, carrying what the old namespace could, and settled +//// when the worker reports which kernel the session ends up with. import albedo/harness/extensions/python/kernel as python import albedo/harness/extensions/python/link @@ -45,47 +45,7 @@ pub fn start_upgrade( state } Ok(cached) -> { - let self = state.self - let owner = state.work let generation = reference.new() - process.spawn_unlinked(fn() { - let upgraded = - protect.attempt(fn() { - kernels.upgrade(owner, id, cached, session.kernel) - }) - let result = case upgraded { - Ok(Ok(#(session, _))) -> Ok(session) - Ok(Error(error)) -> { - io.println_error( - "kernel upgrade waits: " <> string.inspect(error.reason), - ) - case python.alive(session.kernel) { - True -> - Ok(runtime_state.Session(..session, origin: runtime_state.Kept)) - False -> Error(error.reason) - } - } - Error(crash) -> { - io.println_error("kernel upgrade failed: " <> crash) - case python.alive(session.kernel) { - True -> - Ok(runtime_state.Session(..session, origin: runtime_state.Kept)) - False -> Error(python.Unavailable(crash)) - } - } - } - case runtime_state.owner_alive(self) { - True -> - process.send(self, runtime_state.Booted(id, generation, result)) - False -> { - case result { - Ok(session) -> - kernels.drop_kernel("upgrade for a stopped runtime", session) - Error(_) -> Nil - } - } - } - }) runtime_state.State( ..runtime_state.without_session(state, id), booting: dict.insert( @@ -93,11 +53,44 @@ pub fn start_upgrade( id, runtime_state.Booting(generation, [answer]), ), + waiting: list.append(state.waiting, [ + runtime_state.SwapStale(id, generation, cached, session), + ]), ) } } } +/// The swap itself, run by a scheduler worker: the session over its new +/// kernel, or over the old one when the swap must wait and it still lives. +pub fn swap_stale( + owner: work.Store, + id: String, + cached: runtime_state.Cached, + session: runtime_state.Session, +) -> Result(runtime_state.Session, python.Error) { + let kept = runtime_state.Session(..session, origin: runtime_state.Kept) + case + protect.attempt(fn() { kernels.upgrade(owner, id, cached, session.kernel) }) + { + Ok(Ok(#(session, _))) -> Ok(session) + Ok(Error(error)) -> { + io.println_error("kernel upgrade waits: " <> string.inspect(error.reason)) + case python.alive(session.kernel) { + True -> Ok(kept) + False -> Error(error.reason) + } + } + Error(crash) -> { + io.println_error("kernel upgrade failed: " <> crash) + case python.alive(session.kernel) { + True -> Ok(kept) + False -> Error(python.Unavailable(crash)) + } + } + } +} + pub fn start_kernel_upgrade( state: runtime_state.State, id: String,