Struct ServerlessJob 

pub struct ServerlessJob { /* private fields */ }

Available on crate feature serverless only.

A job submitted to a serverless endpoint.

Implements Future to allow awaiting the job result directly.

Examples

let client = RunpodClient::from_env()?;
let endpoint = ServerlessEndpoint::new("ENDPOINT_ID", client);
let job = endpoint.run(&json!({"prompt": "Hello"}))?;

// Await the job to get the output
let output: serde_json::Value = job.await?;
println!("Output: {:?}", output);

Implementations

impl ServerlessJob

pub fn job_id(&self) -> Option<&str>

Returns the job ID (if the job has been submitted)

pub fn endpoint_id(&self) -> &str

Returns the endpoint ID

pub async fn status(&self) -> Result<JobStatus>

Returns the current status of the job.

Example

let client = RunpodClient::from_env()?;
let endpoint = ServerlessEndpoint::new("ENDPOINT_ID", client);
let job = endpoint.run(&json!({"prompt": "Hello"}))?;

let status = job.status().await?;
match status {
    JobStatus::Completed => println!("Job finished"),
    JobStatus::Failed => println!("Job failed"),
    JobStatus::InProgress => println!("Job is running"),
    _ => println!("Job status: {}", status),
}

pub async fn output<O>(&self) -> Result<O>

where O: DeserializeOwned,

Returns the output of the job.

Example

let client = RunpodClient::from_env()?;
let endpoint = ServerlessEndpoint::new("ENDPOINT_ID", client);
let job = endpoint.run(&json!({"prompt": "Hello"}))?;

let output: Output = job.output().await?;
println!("Result: {}", output.text);

pub async fn stream(&self) -> Result<(JobStatus, Vec<StreamChunk>)>

Returns stream chunks from a streaming job.

Example

let client = RunpodClient::from_env()?;
let endpoint = ServerlessEndpoint::new("ENDPOINT_ID", client);
let job = endpoint.run(&json!({"prompt": "Generate text"}))?;

loop {
    let (status, chunks) = job.stream().await?;

    for chunk in chunks {
        println!("Chunk: {:?}", chunk.output);
    }

    if status.is_final() {
        break;
    }

    std::thread::sleep(std::time::Duration::from_secs(1));
}

pub async fn cancel(&self) -> Result<()>

Cancels the job.

Example

let client = RunpodClient::from_env()?;
let endpoint = ServerlessEndpoint::new("ENDPOINT_ID", client);
let job = endpoint.run(&json!({"prompt": "Long running task"}))?;

job.cancel().await?;
println!("Job cancelled");

Trait Implementations

impl Debug for ServerlessJob

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Future for ServerlessJob

type Output = Result<Value, Error>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<'__pin> Unpin for ServerlessJob

where PinnedFieldsOf<__Origin<'__pin>>: Unpin,