subc-daemon 0.44.2

Embeddable subc daemon: bootstrap, module supervision, and opaque-byte splice routing.
Documentation
use super::*;
use subc_protocol::session::{AgentCommandFinished, AgentCommandRoot};
mod queue;
pub(super) use queue::Queues;

pub(super) fn check_batch(
    frame: &Frame,
    started: usize,
    finished: usize,
    known: usize,
) -> Result<Option<Frame>, RouterError> {
    for (field, len, cap) in [
        ("started", started, 256),
        ("finished", finished, 256),
        ("known", known, 1_024),
    ] {
        if len > cap {
            return control_error_frame(
                frame,
                "invalid_request",
                format!("{field} contains more than {cap} roots"),
            )
            .map(Some);
        }
    }
    Ok(None)
}

impl ControlHandler {
    pub(crate) fn with_daemon_version(mut self, daemon_version: String) -> Self {
        self.resource_tracker = Arc::new(crate::resource_totals::Tracker::new(daemon_version));
        self
    }

    pub(crate) fn spawn_resource_sampler(self: &Arc<Self>) {
        crate::resource_totals::spawn(
            self,
            self.supervisor.clone(),
            Arc::clone(&self.resource_tracker),
        );
    }

    pub(super) fn handle_agent_commands(
        &self,
        connection_id: ConnectionId,
        frame: Frame,
        started: Vec<AgentCommandRoot>,
        finished: Vec<AgentCommandFinished>,
        known: Option<Vec<AgentCommandRoot>>,
    ) -> Result<Vec<Frame>, RouterError> {
        self.handle_agent_commands_fenced(
            connection_id,
            frame,
            started,
            finished,
            known,
            &crate::resource_totals::CommitFence::default(),
        )
    }

    fn handle_agent_commands_fenced(
        &self,
        connection_id: ConnectionId,
        frame: Frame,
        started: Vec<AgentCommandRoot>,
        finished: Vec<AgentCommandFinished>,
        known: Option<Vec<AgentCommandRoot>>,
        fence: &crate::resource_totals::CommitFence,
    ) -> Result<Vec<Frame>, RouterError> {
        if let Some(error) = check_batch(
            &frame,
            started.len(),
            finished.len(),
            known.as_ref().map_or(0, Vec::len),
        )? {
            return Ok(vec![error]);
        }
        let registration = self
            .registry
            .get_module_by_connection(connection_id)
            .map_err(|err| RouterError::backend(0, frame.header.corr, err.to_string()))?;
        let Some(registration) = registration else {
            return Ok(vec![control_error_frame(
                &frame,
                "not_supervised",
                "agent commands require the module's supervised connection",
            )?]);
        };
        let id = registration.manifest.module_id;
        let nonce = self.supervisor.spawn_launch_nonce_for(&id);
        let authorized = self
            .hello_launch_nonces
            .lock()
            .unwrap_or_else(|p| p.into_inner())
            .presented(connection_id, nonce.as_deref());
        let module = self.supervisor.get(&id).filter(|_| authorized);
        let Some(module) = module else {
            return Ok(vec![control_error_frame(
                &frame,
                "not_supervised",
                "agent commands require the module's current supervised launch",
            )?]);
        };
        let launch = module.resource_launch().ok_or_else(|| {
            RouterError::backend(
                0,
                frame.header.corr,
                "module launch snapshot is busy; retry",
            )
        })?;
        let Some(pid) = launch.pid.filter(|_| launch.enabled && launch.alive) else {
            return Ok(vec![control_error_frame(
                &frame,
                "not_supervised",
                "declaring module has no live process",
            )?]);
        };
        let Some(_start) = subc_os::start_time(pid).filter(|start| launch.start == Some(*start))
        else {
            return Ok(vec![control_error_frame(
                &frame,
                "not_supervised",
                "declaring module process identity is no longer live",
            )?]);
        };
        let mut receipt = crate::resource_totals::Receipt::default();
        for attempt in 0..4 {
            let prepared = self.resource_tracker.prepare(
                &id,
                launch.generation(),
                pid,
                launch.target.clone(),
                crate::resource_totals::Declaration {
                    started: started.clone(),
                    finished: finished.clone(),
                    known: known.clone(),
                },
                &mut receipt,
            );
            let Some(prepared) = prepared else {
                if attempt < 3 {
                    std::thread::yield_now();
                    continue;
                }
                return Err(RouterError::backend(
                    0,
                    frame.header.corr,
                    "process ownership or membership is unknown; retry",
                ));
            };
            let committed = self.supervisor.with_current_resource_launch(
                &id,
                nonce.as_deref().unwrap_or_default(),
                &launch,
                || {
                    self.resource_tracker
                        .commit_fenced(&id, launch.generation(), prepared, fence)
                },
            );
            let rejected = match committed {
                Ok(rejected) => rejected,
                Err(crate::supervise::ResourceCommitError::Busy) => {
                    if attempt < 3 {
                        std::thread::yield_now();
                        continue;
                    }
                    return Ok(vec![control_error_frame(
                        &frame,
                        "busy",
                        "module launch commit is busy; retry",
                    )?]);
                }
                Err(crate::supervise::ResourceCommitError::Changed) => {
                    return Ok(vec![control_error_frame(
                        &frame,
                        "not_supervised",
                        "the declaring module launch changed during validation",
                    )?]);
                }
            };
            if rejected.is_none() && attempt < 3 {
                std::thread::yield_now();
                continue;
            }
            let Some(rejected) = rejected else {
                return Ok(vec![control_error_frame(
                    &frame,
                    "busy",
                    "resource state is busy after revalidation; retry",
                )?]);
            };
            let roots_full = rejected.roots_full;
            for root in rejected.rejected {
                tracing::warn!(
                    module_id = id,
                    pid = root.pid,
                    start_time_ms = root.start_time_ms,
                    "agent command root was not admitted"
                );
            }
            if roots_full {
                return Ok(vec![control_error_frame(&frame, subc_protocol::error_codes::AGENT_ROOTS_FULL,
                    "live agent command root limit reached; retry unaccepted roots after capacity is available")?]);
            }
            return Ok(vec![control_response_body_frame(
                &frame,
                &serde_json::json!({}),
                "agent command acknowledgement",
            )?]);
        }
        Ok(vec![control_error_frame(
            &frame,
            "busy",
            "resource accounting could not commit; retry",
        )?])
    }
}