shuttle-runtime 0.49.0

Runtime to run a service on the Shuttle platform
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use shuttle_proto::runtime::{LoadRequest, StartRequest, StopReason, SubscribeStopRequest};
use shuttle_service::Environment;

use crate::helpers::{spawn_runtime, TestRuntime};

#[tokio::test]
async fn bind_panic() {
    let project_path = format!("{}/tests/resources/bind-panic", env!("CARGO_MANIFEST_DIR"));

    let TestRuntime {
        bin_path,
        secrets,
        mut runtime_client,
        runtime_address,
        runtime: _runtime, // Keep it to not be dropped and have the process killed.
    } = spawn_runtime(project_path.as_str()).await.unwrap();

    let load_request = tonic::Request::new(LoadRequest {
        path: bin_path,
        env: Environment::Local.to_string(),
        project_name: "bind-panic".to_owned(),
        resources: Default::default(),
        secrets,
    });
    runtime_client.load(load_request).await.unwrap();
    let mut stream = runtime_client
        .subscribe_stop(tonic::Request::new(SubscribeStopRequest {}))
        .await
        .unwrap()
        .into_inner();

    let start_request = StartRequest {
        ip: runtime_address.to_string(),
        resources: Default::default(),
    };
    runtime_client
        .start(tonic::Request::new(start_request))
        .await
        .unwrap();

    let resp = stream.message().await.unwrap().unwrap();
    assert_eq!(resp.reason, StopReason::Crash as i32);
    assert_eq!(resp.message, "panic in bind");
}

#[tokio::test]
async fn loader_panic() {
    let project_path = format!(
        "{}/tests/resources/loader-panic",
        env!("CARGO_MANIFEST_DIR")
    );

    let TestRuntime {
        bin_path,
        secrets,
        mut runtime_client,
        runtime_address: _,
        runtime: _runtime, // Keep it to not be dropped and have the process killed.
    } = spawn_runtime(project_path.as_str()).await.unwrap();

    let load_request = tonic::Request::new(LoadRequest {
        path: bin_path,
        env: Environment::Local.to_string(),
        project_name: "loader-panic".to_owned(),
        resources: Default::default(),
        secrets,
    });
    let resp = runtime_client
        .load(load_request)
        .await
        .unwrap()
        .into_inner();

    assert_eq!(resp.message, "panic in load");
}

#[tokio::test]
async fn main_panic() {
    let project_path = format!("{}/tests/resources/main-panic", env!("CARGO_MANIFEST_DIR"));

    let TestRuntime {
        bin_path,
        secrets,
        mut runtime_client,
        runtime_address,
        runtime: _runtime, // Keep it to not be dropped and have the process killed.
    } = spawn_runtime(project_path.as_str()).await.unwrap();

    let load_request = tonic::Request::new(LoadRequest {
        path: bin_path,
        env: Environment::Local.to_string(),
        project_name: "main-panic".to_owned(),
        resources: Default::default(),
        secrets,
    });

    runtime_client.load(load_request).await.unwrap();
    let mut stream = runtime_client
        .subscribe_stop(tonic::Request::new(SubscribeStopRequest {}))
        .await
        .unwrap()
        .into_inner();

    let start_request = StartRequest {
        ip: runtime_address.to_string(),
        resources: Default::default(),
    };
    runtime_client
        .start(tonic::Request::new(start_request))
        .await
        .unwrap();

    let resp = stream.message().await.unwrap().unwrap();
    assert_eq!(resp.reason, StopReason::Crash as i32);
    assert_eq!(resp.message, "panic in main");
}