5 · Ciclo de vida e estado#

fn spawn(store: &Store, id: &str, spec: &Spec, rootfs: &Path, stdio: Stdio) -> Result<()> {
    let fifo = store.fifo(id)?;
    mkfifo(&fifo, Mode::from_bits_truncate(0o600))?;
    // O cgroup é preparado ANTES do fork: um erro de delegação chega ao utilizador com o remédio.
    let cgroup = Cgroup::create(id, spec.linux.resources.as_ref())?;

    let (rd, wr) = pipe()?;
    // SAFETY: o processo é single-thread neste ponto (nenhuma thread foi lançada), logo
    // `fork` é seguro; o filho só chama funções async-signal-safe até ao `exec`/`_exit`.
    match unsafe { fork() }? {
        ForkResult::Parent { .. } => {
            drop(wr);
            let report = recv_report(rd)?;
            let pid: i32 = report.parse().map_err(|_| Error::Setup(format!("bad report {report:?}")))?;
            let cg = cgroup.as_ref().map(|c| c.path().to_owned());
            store.update(id, |st| {
                st.pid = pid;
                st.cgroup = cg;
                if st.status == Status::Creating {
                    st.status = Status::Created;
                }
                Ok(())
            })
        }
        ForkResult::Child => {
            drop(rd);
            supervise(store, id, spec, rootfs, &fifo, cgroup, wr, stdio)
        }
    }
}

/// Lê o relatório: `K<texto>` = ok, `E<mensagem>` = erro, EOF = o filho morreu sem dizer nada.
///
/// UMA leitura, não «até ao EOF»: o emissor pode manter o pipe aberto até ao `exec`
/// (o init só o fecha depois do `start`), e esperar por EOF bloquearia o `create` para sempre.
fn recv_report(fd: OwnedFd) -> Result<String> {
    let mut raw = [0u8; 4096];
    let n = fs::File::from(fd).read(&mut raw).ctx(|| "reading start-up report".to_string())?;
    let buf = String::from_utf8_lossy(&raw[..n]).into_owned();
    match buf.split_at_checked(1) {
        Some(("K", rest)) => Ok(rest.to_owned()),
        Some(("E", msg)) => Err(Error::Setup(msg.to_owned())),
        _ => Err(Error::Setup("container process died during setup".into())),
    }
}

/// Para onde vai o stdio do container.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Stdio {
    /// Herda o do chamador (`mc run`: o utilizador vê a saída).
    Inherit,
    /// Vai para `<estado>/output.log` (`mc create`): o container sobrevive ao comando que o criou,
    /// e um chamador que capture a saída por pipe não fica preso à espera de um EOF que só
    /// chegaria quando o container morresse.
    Log,
}

pub fn start(store: &Store, id: &str) -> Result<()> {
    let st = reconcile(store.load(id)?);
    if st.status != Status::Created {
        return Err(Error::WrongState { id: id.into(), status: st.status.to_string(), expected: "created" });
    }
    let mut fifo =
        fs::OpenOptions::new().write(true).open(store.fifo(id)?).ctx(|| "opening start fifo".to_string())?;
    fifo.write_all(&[1]).ctx(|| "signalling start".to_string())?;
    // Compare-and-set: se o container já acabou (comando curto), o supervisor ganhou — não desfazer.
    store.update(id, |s| {
        if s.status == Status::Created {
            s.status = Status::Running;
        }
        Ok(())
    })
}

    /// Read-modify-write sob `flock`. A closure decide o que fazer com o estado ACTUAL.
    pub fn update<T>(&self, id: &str, f: impl FnOnce(&mut State) -> Result<T>) -> Result<T> {
        let dir = self.dir(id)?;
        let lock_file =
            fs::OpenOptions::new().create(true).append(true).open(dir.join("lock")).map_err(|e| {
                if e.kind() == std::io::ErrorKind::NotFound {
                    Error::NotFound(id.into())
                } else {
                    Error::io("opening lock", e)
                }
            })?;
        let _guard = Flock::lock(lock_file, FlockArg::LockExclusive).map_err(|(_, e)| Error::Sys(e))?;
        let mut state = self.load(id)?;
        let out = f(&mut state)?;
        self.write(&state)?;
        Ok(out)
    }

    #[test]
    fn concurrent_updates_do_not_lose_writes() {
        let (_d, s) = store();
        let mut init = st("c");
        init.pid = 0;
        s.create(&init).unwrap();
        let s = std::sync::Arc::new(s);
        let handles: Vec<_> = (0..16)
            .map(|_| {
                let s = s.clone();
                std::thread::spawn(move || {
                    s.update("c", |st| {
                        let v = st.pid;
                        std::thread::sleep(std::time::Duration::from_millis(2));
                        st.pid = v + 1;
                        Ok(())
                    })
                    .unwrap();
                })
            })
            .collect();
        handles.into_iter().for_each(|h| h.join().unwrap());
        assert_eq!(s.load("c").unwrap().pid, 16);
    }

/// O estado em disco pode mentir (o supervisor morreu, a máquina reiniciou): reconcilia com a
/// realidade. Nunca se confia só no ficheiro — a mesma lição do `reconcile_status` do delonix.
pub fn reconcile(mut st: State) -> State {
    if matches!(st.status, Status::Created | Status::Running)
        && nix::sys::signal::kill(nix::unistd::Pid::from_raw(st.pid), None).is_err()
    {
        st.status = Status::Stopped;
    }
    st
}