Enum JobHandleError

Source

pub enum JobHandleError {
    JobCancelled,
    JobPanicked(PanicInfo),
    CancelJobError(SendError<()>),
    JobResultError(RecvError),
    JobResultWrapperError {
        from: &'static str,
        to: &'static str,
    },
}

Expand description

a job-handle error.

Variants§

§

JobResultWrapperError

Fields

§from: &'static str

§to: &'static str

Implementations§

Source §

impl JobHandleError

Source

pub fn is_panic(&self) -> bool

Returns true if the error was caused by the task panicking.

use neptune_job_queue::JobQueue;
use neptune_job_queue::traits::*;

struct PanicJob;

#[async_trait::async_trait]
impl Job for PanicJob {
    fn is_async(&self) -> bool {
        true
    }
    async fn run_async(&self) -> Box<dyn JobResult> {
       panic!("{}", "boom");
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let job_queue = JobQueue::start();
    let job_handle = job_queue.add_job(PanicJob, 1)?;

    let err = job_handle.await?.unwrap_err();
    assert!(err.is_panic());

    Ok(())
}

Source

pub fn into_panic(self) -> Box<dyn Any + Send + 'static>

into_panic() panics if the Error does not represent the underlying task terminating with a panic. Use is_panic to check the error reason or try_into_panic for a variant that does not panic.

use neptune_job_queue::JobQueue;
use neptune_job_queue::traits::*;

struct PanicJob;

#[async_trait::async_trait]
impl Job for PanicJob {
    fn is_async(&self) -> bool {
        true
    }
    async fn run_async(&self) -> Box<dyn JobResult> {
       panic!("{}", "boom");
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let job_queue = JobQueue::start();
    let job_handle = job_queue.add_job(PanicJob, 1)?;

    let err = job_handle.await?.unwrap_err();

    // Resume the panic on the main task
    std::panic::resume_unwind(err.into_panic());

    Ok(())
}

Source

pub fn try_into_panic(self) -> Result<Box<dyn Any + Send + 'static>, Self>

Consumes the JobHandleError, returning the object with which the task panicked if the task terminated due to a panic. Otherwise, self is returned.

use neptune_job_queue::JobQueue;
use neptune_job_queue::traits::*;

struct PanicJob;

#[async_trait::async_trait]
impl Job for PanicJob {
    fn is_async(&self) -> bool {
        true
    }
    async fn run_async(&self) -> Box<dyn JobResult> {
       panic!("{}", "boom");
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let job_queue = JobQueue::start();
    let job_handle = job_queue.add_job(PanicJob, 1)?;

    let err = job_handle.await?.unwrap_err();

    // Resume the panic on the main task
    let panic = err.try_into_panic()?;
    std::panic::resume_unwind(panic);

    Ok(())
}

Source

pub fn panic_message(&self) -> Option<String>

returns panic message, if available

returns None if Error variant is not JobPanicked or panic info cannot be downcast to a string representation

use neptune_job_queue::JobQueue;
use neptune_job_queue::traits::*;

struct PanicJob;

#[async_trait::async_trait]
impl Job for PanicJob {
    fn is_async(&self) -> bool {
        true
    }
    async fn run_async(&self) -> Box<dyn JobResult> {
       panic!("{}", "boom");
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let job_queue = JobQueue::start();
    let job_handle = job_queue.add_job(PanicJob, 1)?;

    let err = job_handle.await?.unwrap_err();
    assert_eq!( Some("boom".to_string()), err.panic_message());

    Ok(())
}