lightshuttle-runtime 0.5.0

Container runtime backends and lifecycle manager for LightShuttle
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! Integration tests that require a running Docker daemon.
//!
//! Run with `cargo test --test integration_docker -- --ignored` on a
//! machine where `docker info` succeeds. These tests are excluded from
//! the standard CI run.

use std::collections::HashMap;
use std::io::Write;
use std::time::Duration;

use lightshuttle_runtime::{
    ContainerRuntime, ContainerSpec, ContainerStatus, DockerRuntime, ImageSource,
};

fn small_image_spec(name: &str) -> ContainerSpec {
    let mut spec = ContainerSpec::new(
        name.to_owned(),
        "lightshuttle_it".to_owned(),
        name.to_owned(),
        ImageSource::Pull("alpine:3.20".to_owned()),
    );
    spec.command = Some(vec!["sh".to_owned(), "-c".to_owned(), "sleep 5".to_owned()]);
    spec
}

#[tokio::test]
#[ignore = "requires a running Docker daemon"]
async fn start_inspect_stop_alpine() {
    let runtime = DockerRuntime::connect().expect("Docker daemon reachable");
    let spec = small_image_spec("lightshuttle_it_start_inspect_stop");

    let id = runtime.start(&spec).await.expect("container starts");

    let status = runtime.inspect(&id).await.expect("inspect succeeds");
    assert!(matches!(
        status,
        ContainerStatus::Running | ContainerStatus::Starting | ContainerStatus::Healthy
    ));

    runtime
        .stop(&id, Duration::from_secs(2))
        .await
        .expect("stop succeeds");
}

#[tokio::test]
#[ignore = "requires a running Docker daemon"]
async fn builds_and_runs_a_dockerfile_resource() {
    let context = tempfile::tempdir().expect("temp dir created");

    // Minimal Dockerfile: small image, instant exit.
    let dockerfile_path = context.path().join("Dockerfile");
    let mut dockerfile = std::fs::File::create(&dockerfile_path).expect("Dockerfile created");
    writeln!(dockerfile, "FROM alpine:3.20").expect("write line");
    writeln!(dockerfile, "CMD [\"sh\", \"-c\", \"sleep 5\"]").expect("write line");
    drop(dockerfile);

    // Verify that .dockerignore filtering does not break the build:
    // include one ignored file plus an entry in .dockerignore.
    std::fs::write(context.path().join("noisy.tmp"), b"junk").expect("noisy file written");
    std::fs::write(context.path().join(".dockerignore"), b"*.tmp\n").expect("ignore written");

    let runtime = DockerRuntime::connect().expect("Docker daemon reachable");
    let spec = ContainerSpec::new(
        "lightshuttle_it_build_run".to_owned(),
        "lightshuttle_it".to_owned(),
        "build_run".to_owned(),
        ImageSource::Build {
            context: context.path().to_string_lossy().into_owned(),
            dockerfile: "Dockerfile".to_owned(),
            build_args: HashMap::new(),
            target: None,
            tag: "lightshuttle/it_build_run:dev".to_owned(),
        },
    );

    let id = runtime
        .start(&spec)
        .await
        .expect("dockerfile resource builds and starts");

    runtime
        .stop(&id, Duration::from_secs(2))
        .await
        .expect("container stops cleanly");
}

#[tokio::test]
#[ignore = "requires a running Docker daemon"]
async fn project_network_lifecycle_is_idempotent() {
    let runtime = DockerRuntime::connect().expect("Docker daemon reachable");

    runtime
        .ensure_project_network("it-net-test")
        .await
        .expect("network created on first call");

    runtime
        .ensure_project_network("it-net-test")
        .await
        .expect("ensure is idempotent");

    runtime
        .teardown_project_network("it-net-test")
        .await
        .expect("network removed");

    runtime
        .teardown_project_network("it-net-test")
        .await
        .expect("teardown is idempotent");
}

#[tokio::test]
#[ignore = "requires a running Docker daemon"]
async fn builds_buildkit_only_dockerfile() {
    let context = tempfile::tempdir().expect("temp dir created");

    let dockerfile_path = context.path().join("Dockerfile");
    let mut dockerfile = std::fs::File::create(&dockerfile_path).expect("Dockerfile created");
    writeln!(dockerfile, "# syntax=docker/dockerfile:1").expect("write line");
    writeln!(dockerfile, "FROM alpine:3.20").expect("write line");
    writeln!(
        dockerfile,
        "RUN --mount=type=cache,target=/var/cache/apk echo cached"
    )
    .expect("write line");
    writeln!(dockerfile, "CMD [\"sh\", \"-c\", \"sleep 5\"]").expect("write line");
    drop(dockerfile);

    let runtime = DockerRuntime::connect().expect("Docker daemon reachable");
    let spec = ContainerSpec::new(
        "lightshuttle_it_buildkit".to_owned(),
        "lightshuttle_it".to_owned(),
        "buildkit".to_owned(),
        ImageSource::Build {
            context: context.path().to_string_lossy().into_owned(),
            dockerfile: "Dockerfile".to_owned(),
            build_args: HashMap::new(),
            target: None,
            tag: "lightshuttle/it_buildkit:dev".to_owned(),
        },
    );

    let id = runtime
        .start(&spec)
        .await
        .expect("BuildKit-only Dockerfile builds and starts");

    runtime
        .stop(&id, Duration::from_secs(2))
        .await
        .expect("container stops cleanly");
}