Struct Job 

pub struct Job { /* private fields */ }

Implementations

impl Job

pub fn from_uuid( _api_client: &ApiClient, uuid: &str, auth_token: Option<&str>, ) -> Result<Self>

pub fn id(&self) -> &str

Examples found in repository

examples/run_app.rs (line 78)

fn _example_non_blocking() {
    let app = biolib::load("test-team/hello-world:0.0.2").expect("Failed to load app");

    let mut job = app
        .cli(None, None, None, false)
        .expect("Failed to start job");

    println!("Job ID: {}", job.id());
    println!("Share link: {}", job.get_shareable_link());

    job.wait(None).expect("Failed to wait for job");

    let exit_code = job.get_exit_code().unwrap();
    println!("Exit code: {exit_code}");
}

pub fn auth_token(&self) -> &str

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

pub fn get_status(&mut self) -> Result<String>

pub fn is_finished(&mut self) -> Result<bool>

pub fn wait(&mut self, timeout: Option<u64>) -> Result<()>

Examples found in repository

examples/run_app.rs (line 81)

fn _example_non_blocking() {
    let app = biolib::load("test-team/hello-world:0.0.2").expect("Failed to load app");

    let mut job = app
        .cli(None, None, None, false)
        .expect("Failed to start job");

    println!("Job ID: {}", job.id());
    println!("Share link: {}", job.get_shareable_link());

    job.wait(None).expect("Failed to wait for job");

    let exit_code = job.get_exit_code().unwrap();
    println!("Exit code: {exit_code}");
}

pub fn get_stdout(&mut self) -> Result<Vec<u8>>

Examples found in repository

examples/run_app.rs (line 10)

fn main() {
    let app = biolib::load("test-team/hello-world:0.0.2").expect("Failed to load app");
    println!("Loaded app: {}", app.uri());

    let mut job = app.cli(None, None, None, true).expect("Failed to run app");

    let exit_code = job.get_exit_code().expect("Failed to get exit code");
    let stdout = job.get_stdout().expect("Failed to get stdout");
    let stderr = job.get_stderr().expect("Failed to get stderr");

    println!("Exit code: {exit_code}");
    println!("Stdout: {}", String::from_utf8_lossy(&stdout));
    if !stderr.is_empty() {
        eprintln!("Stderr: {}", String::from_utf8_lossy(&stderr));
    }

    let files = job.list_output_files().expect("Failed to list files");
    for file in &files {
        println!("Output file: {}", file.path);
    }
}

fn _example_with_args() {
    let app = biolib::load("test-team/hello-world:0.0.2").expect("Failed to load app");

    let args = vec!["--name".to_string(), "World".to_string()];
    let mut job = app
        .cli(Some(args), None, None, true)
        .expect("Failed to run app");

    println!(
        "Stdout: {}",
        String::from_utf8_lossy(&job.get_stdout().unwrap())
    );
}

fn _example_with_files() {
    let app = biolib::load("test-team/hello-world:0.0.2").expect("Failed to load app");

    let mut files = HashMap::new();
    files.insert("input.txt".to_string(), b"Hello from file".to_vec());

    let mut job = app
        .cli(None, None, Some(files), true)
        .expect("Failed to run app");

    let exit_code = job.get_exit_code().unwrap();
    println!("Exit code: {exit_code}");

    job.save_files("output_dir", true)
        .expect("Failed to save files");
}

fn _example_search() {
    let results = biolib::search(Some("hello"), None, 5).expect("Search failed");
    for uri in &results {
        println!("Found: {uri}");
    }
}

fn _example_get_result() {
    let job_id = "some-job-uuid";
    let mut job = biolib::get_result(job_id, None).expect("Failed to get result");

    let stdout = job.get_stdout().expect("Failed to get stdout");
    println!("Stdout: {}", String::from_utf8_lossy(&stdout));
}

pub fn get_stderr(&mut self) -> Result<Vec<u8>>

Examples found in repository

examples/run_app.rs (line 11)

fn main() {
    let app = biolib::load("test-team/hello-world:0.0.2").expect("Failed to load app");
    println!("Loaded app: {}", app.uri());

    let mut job = app.cli(None, None, None, true).expect("Failed to run app");

    let exit_code = job.get_exit_code().expect("Failed to get exit code");
    let stdout = job.get_stdout().expect("Failed to get stdout");
    let stderr = job.get_stderr().expect("Failed to get stderr");

    println!("Exit code: {exit_code}");
    println!("Stdout: {}", String::from_utf8_lossy(&stdout));
    if !stderr.is_empty() {
        eprintln!("Stderr: {}", String::from_utf8_lossy(&stderr));
    }

    let files = job.list_output_files().expect("Failed to list files");
    for file in &files {
        println!("Output file: {}", file.path);
    }
}

pub fn get_exit_code(&mut self) -> Result<u16>

Examples found in repository

examples/run_app.rs (line 9)

fn main() {
    let app = biolib::load("test-team/hello-world:0.0.2").expect("Failed to load app");
    println!("Loaded app: {}", app.uri());

    let mut job = app.cli(None, None, None, true).expect("Failed to run app");

    let exit_code = job.get_exit_code().expect("Failed to get exit code");
    let stdout = job.get_stdout().expect("Failed to get stdout");
    let stderr = job.get_stderr().expect("Failed to get stderr");

    println!("Exit code: {exit_code}");
    println!("Stdout: {}", String::from_utf8_lossy(&stdout));
    if !stderr.is_empty() {
        eprintln!("Stderr: {}", String::from_utf8_lossy(&stderr));
    }

    let files = job.list_output_files().expect("Failed to list files");
    for file in &files {
        println!("Output file: {}", file.path);
    }
}

fn _example_with_args() {
    let app = biolib::load("test-team/hello-world:0.0.2").expect("Failed to load app");

    let args = vec!["--name".to_string(), "World".to_string()];
    let mut job = app
        .cli(Some(args), None, None, true)
        .expect("Failed to run app");

    println!(
        "Stdout: {}",
        String::from_utf8_lossy(&job.get_stdout().unwrap())
    );
}

fn _example_with_files() {
    let app = biolib::load("test-team/hello-world:0.0.2").expect("Failed to load app");

    let mut files = HashMap::new();
    files.insert("input.txt".to_string(), b"Hello from file".to_vec());

    let mut job = app
        .cli(None, None, Some(files), true)
        .expect("Failed to run app");

    let exit_code = job.get_exit_code().unwrap();
    println!("Exit code: {exit_code}");

    job.save_files("output_dir", true)
        .expect("Failed to save files");
}

fn _example_search() {
    let results = biolib::search(Some("hello"), None, 5).expect("Search failed");
    for uri in &results {
        println!("Found: {uri}");
    }
}

fn _example_get_result() {
    let job_id = "some-job-uuid";
    let mut job = biolib::get_result(job_id, None).expect("Failed to get result");

    let stdout = job.get_stdout().expect("Failed to get stdout");
    println!("Stdout: {}", String::from_utf8_lossy(&stdout));
}

fn _example_non_blocking() {
    let app = biolib::load("test-team/hello-world:0.0.2").expect("Failed to load app");

    let mut job = app
        .cli(None, None, None, false)
        .expect("Failed to start job");

    println!("Job ID: {}", job.id());
    println!("Share link: {}", job.get_shareable_link());

    job.wait(None).expect("Failed to wait for job");

    let exit_code = job.get_exit_code().unwrap();
    println!("Exit code: {exit_code}");
}

pub fn list_output_files(&mut self) -> Result<Vec<OutputFile>>

Examples found in repository

examples/run_app.rs (line 19)

fn main() {
    let app = biolib::load("test-team/hello-world:0.0.2").expect("Failed to load app");
    println!("Loaded app: {}", app.uri());

    let mut job = app.cli(None, None, None, true).expect("Failed to run app");

    let exit_code = job.get_exit_code().expect("Failed to get exit code");
    let stdout = job.get_stdout().expect("Failed to get stdout");
    let stderr = job.get_stderr().expect("Failed to get stderr");

    println!("Exit code: {exit_code}");
    println!("Stdout: {}", String::from_utf8_lossy(&stdout));
    if !stderr.is_empty() {
        eprintln!("Stderr: {}", String::from_utf8_lossy(&stderr));
    }

    let files = job.list_output_files().expect("Failed to list files");
    for file in &files {
        println!("Output file: {}", file.path);
    }
}

pub fn save_files(&mut self, output_dir: &str, overwrite: bool) -> Result<()>

Examples found in repository

examples/run_app.rs (line 52)

fn _example_with_files() {
    let app = biolib::load("test-team/hello-world:0.0.2").expect("Failed to load app");

    let mut files = HashMap::new();
    files.insert("input.txt".to_string(), b"Hello from file".to_vec());

    let mut job = app
        .cli(None, None, Some(files), true)
        .expect("Failed to run app");

    let exit_code = job.get_exit_code().unwrap();
    println!("Exit code: {exit_code}");

    job.save_files("output_dir", true)
        .expect("Failed to save files");
}

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

pub fn delete(&mut self) -> Result<()>

pub fn rename(&mut self, name: &str) -> Result<()>

pub fn get_shareable_link(&self) -> String

Examples found in repository

examples/run_app.rs (line 79)

fn _example_non_blocking() {
    let app = biolib::load("test-team/hello-world:0.0.2").expect("Failed to load app");

    let mut job = app
        .cli(None, None, None, false)
        .expect("Failed to start job");

    println!("Job ID: {}", job.id());
    println!("Share link: {}", job.get_shareable_link());

    job.wait(None).expect("Failed to wait for job");

    let exit_code = job.get_exit_code().unwrap();
    println!("Exit code: {exit_code}");
}

pub fn stream_logs(&mut self) -> Result<()>

pub fn start_in_cloud( _api_client: &ApiClient, app_uri: &str, app_version_uuid: &str, module_input: &[u8], override_command: bool, machine: Option<&str>, experiment_id: Option<&str>, result_prefix: Option<&str>, timeout: Option<u64>, notify: bool, requested_machine_count: Option<u32>, ) -> Result<Self>

pub fn fetch_jobs( _api_client: &ApiClient, count: usize, status: Option<&str>, ) -> Result<Vec<Job>>