tsunami 0.11.1

Toolkit for running short-lived jobs on cloud VMs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use color_eyre::{eyre, Report};
use structopt::StructOpt;
use tsunami::Tsunami;

#[derive(Debug)]
enum Providers {
    AWS,
    Azure,
}

impl std::str::FromStr for Providers {
    type Err = Report;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(match s {
            "aws" => Providers::AWS,
            "azure" => Providers::Azure,
            x => eyre::bail!("unknown provider {:?}", x),
        })
    }
}

#[derive(StructOpt)]
struct Opt {
    #[structopt(short = "p", long = "provider")]
    provider: Providers,
    #[structopt(short = "r", long = "region")]
    region: String,
}

fn wait_for_continue() {
    eprintln!("pausing for manual instance inspection, press enter to continue");

    use std::io::prelude::*;
    let stdin = std::io::stdin();
    let mut iterator = stdin.lock().lines();
    iterator.next().unwrap().unwrap();
}

// just launch an instance in the specified region and wait.
#[tokio::main]
async fn main() -> Result<(), Report> {
    let opt = Opt::from_args();
    tracing_subscriber::fmt::init();
    color_eyre::install()?;

    match opt.provider {
        Providers::AWS => {
            let mut l: tsunami::providers::aws::Launcher<_> = Default::default();
            l.open_ports();
            let m = tsunami::providers::aws::Setup::default()
                .region_with_ubuntu_ami(opt.region.parse()?)
                .await?
                .instance_type("t3.medium");

            l.spawn(vec![(String::from(""), m)], None).await?;
            wait_for_continue();
            l.terminate_all().await?;
        }
        Providers::Azure => {
            let mut l: tsunami::providers::azure::Launcher = Default::default();
            let m = tsunami::providers::azure::Setup::default().region(opt.region.parse()?);

            l.spawn(vec![(String::from(""), m)], None).await?;
            wait_for_continue();
            l.terminate_all().await?;
        }
    }

    Ok(())
}