Function handle_job_forget

crates/hyperqueue/src/server/client/mod.rs:792–826

Forgetting jobs can release a lot of memory and perform a lot of destructors. Since this happens in synchronous code, it can stall the event loop, which can lead to e.g. missing worker heartbeats and other problems. We thus return the forgotten jobs, so that we can drop them later in a separate thread.

(
    state_ref: &StateRef,
    senders: &Senders,
    selector: &IdSelector,
    allowed_statuses: Vec<Status>,
)

///
/// We thus return the forgotten jobs, so that we can drop them later in a separate thread.
fn handle_job_forget(
    state_ref: &StateRef,
    senders: &Senders,
    selector: &IdSelector,
    allowed_statuses: Vec<Status>,
) -> (ToClientMessage, Vec<Job>) {
    let mut state = state_ref.get_mut();
    let job_ids: Vec<JobId> = get_job_ids(&state, selector);
    let mut forgotten: usize = 0;

    let mut forgotten_jobs = Vec::with_capacity(job_ids.len());
    for &job_id in &job_ids {
        let can_be_forgotten = state
            .get_job(job_id)
            .map(|j| {
                j.is_terminated() && allowed_statuses.contains(&job_status(&j.make_job_info(false)))
            })
            .unwrap_or(false);
        if can_be_forgotten {
            if let Some(job) = state.forget_job(job_id) {
                forgotten_jobs.push(job);
            }
            forgotten += 1;
        }
    }
    state.try_release_memory();
    senders.server_control.try_release_memory();

    let ignored = job_ids.len() - forgotten;

    (
        ToClientMessage::ForgetJobResponse(ForgetJobResponse { forgotten, ignored }),
        forgotten_jobs,
    )
}

fn handle_get_list(state_ref: &StateRef, workers: bool) -> ToClientMessage {
    let state = state_ref.get();