Method handle_fifo

src/executor/memory/executor.rs:209–289

(
        mut runner_fifo: RunnerFifo,
        ipc: MemtrackIpcServer,
        child: &mut std::process::Child,
    )

impl MemoryExecutor {
    async fn handle_fifo(
        mut runner_fifo: RunnerFifo,
        ipc: MemtrackIpcServer,
        child: &mut std::process::Child,
    ) -> anyhow::Result<(ExecutionTimestamps, std::process::ExitStatus)> {
        // Accept the IPC connection from memtrack and get the sender it sends us
        // Use a timeout to prevent hanging if the process doesn't start properly
        // https://github.com/servo/ipc-channel/issues/261
        let (_, memtrack_sender) = timeout(Duration::from_secs(5), async move {
            tokio::task::spawn_blocking(move || ipc.accept())
                .await
                .context("Failed to spawn blocking task")?
                .context("Failed to accept IPC connection")
        })
        .await
        .context("Timeout waiting for IPC connection from memtrack process")??;
        let ipc_client = Rc::new(MemtrackIpcClient::from_accepted(memtrack_sender));

        let on_cmd = async move |cmd: &FifoCommand| {
            const INVALID_INTEGRATION_ERROR: &str = "This integration doesn't support memory profiling. Please update your integration to a version that supports memory profiling.";

            match cmd {
                FifoCommand::SetIntegration { name, version } => {
                    let min_version = match name.as_str() {
                        "codspeed-rust" => Version::new(4, 2, 0),
                        "codspeed-cpp" => Version::new(2, 1, 0),
                        "pytest-codspeed" => Version::new(4, 3, 0),
                        "codspeed-node" => Version::new(5, 2, 0),
                        "exec-harness" => Version::new(1, 0, 0),
                        _ => {
                            panic!("{INVALID_INTEGRATION_ERROR}")
                        }
                    };

                    let Ok(cur_version) = Version::parse(version) else {
                        panic!("Received invalid integration version");
                    };

                    if cur_version < min_version {
                        panic!("{INVALID_INTEGRATION_ERROR}")
                    }
                }
                FifoCommand::SetVersion(protocol_version) => {
                    if *protocol_version < 2 {
                        bail!(
                            "Memory profiling requires protocol version 2 or higher, but the integration is using version {protocol_version}. \
                            {INVALID_INTEGRATION_ERROR}",
                        );
                    }
                }
                FifoCommand::StartProfiler => {
                    debug!("Enabling memtrack via IPC");
                    if let Err(e) = ipc_client.enable() {
                        error!("Failed to enable memtrack: {e}");
                        return Ok(Some(FifoCommand::Err));
                    }
                }
                FifoCommand::StopProfiler => {