rustainers 0.15.1

A simple, opinionated way to run containers for tests.
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

//! Common test images.

use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use std::process::Command;

use rustainers::runner::{RunOption, Runner};
use rustainers::{
    ContainerStatus, ExposedPort, HealthCheck, ImageName, PortError, RunnableContainer,
    RunnableContainerBuilder, ToRunnableContainer, WaitStrategy,
};

/// A web server only accessible when sharing the same network
#[derive(Debug)]
pub struct InternalWebServer;

impl ToRunnableContainer for InternalWebServer {
    fn to_runnable(&self, builder: RunnableContainerBuilder) -> RunnableContainer {
        builder
            .with_image(ImageName::new("docker.io/nginx"))
            .with_wait_strategy(
                HealthCheck::builder()
                    .with_command("curl -sf http://127.0.0.1") //DevSkim: ignore DS137138
                    .build(),
            )
            .build()
    }
}

/// Curl image.
#[derive(Debug)]
pub struct Curl {
    /// URL to be checked.
    pub url: String,
}

/// cURL in a container
///
/// # Errors
///
/// Fail if the container cannot be started
pub async fn curl(
    runner: &Runner,
    url: impl Into<String>,
    options: RunOption,
) -> anyhow::Result<()> {
    let url = url.into();
    let image = Curl { url };
    let _container = runner.start_with_options(image, options).await?;

    Ok(())
}

impl ToRunnableContainer for Curl {
    fn to_runnable(&self, builder: RunnableContainerBuilder) -> RunnableContainer {
        builder
            .with_image(ImageName::new("docker.io/curlimages/curl"))
            .with_wait_strategy(WaitStrategy::State(ContainerStatus::Exited))
            .with_command(["-fsv", "--connect-timeout", "1", &self.url])
            .build()
    }
}

/// A web server accessible from host
#[derive(Debug)]
pub struct WebServer(ExposedPort);

impl Default for WebServer {
    fn default() -> Self {
        Self(ExposedPort::new(80))
    }
}

impl ToRunnableContainer for WebServer {
    fn to_runnable(&self, builder: RunnableContainerBuilder) -> RunnableContainer {
        builder
            .with_image(ImageName::new("docker.io/nginx"))
            .with_port_mappings([self.0.clone()])
            .with_wait_strategy(WaitStrategy::http("/"))
            .build()
    }
}

impl WebServer {
    /// Container path that contains the static HTML pages
    pub const STATIC_HTML: &'static str = "/usr/share/nginx/html";

    /// Get the text content
    ///
    /// # Errors
    ///
    /// Fail if we cannot retrieve the result
    pub async fn get(&self, path: &str) -> anyhow::Result<String> {
        let port = self.0.host_port().await?;
        let url = format!("http://127.0.0.1:{port}/{}", path.trim_start_matches('/')); //DevSkim: ignore DS137138
        let out = Command::new("curl").arg(&url).output()?;
        let result = String::from_utf8_lossy(&out.stdout);
        Ok(result.to_string())
    }
}

/// Netcat
#[derive(Debug)]
pub struct Netcat(ExposedPort);

impl Netcat {
    const PORT: u16 = 8888;

    /// Get the socket address
    ///
    /// # Errors
    ///
    /// Fail if the container is not started (port not bound)
    pub async fn addr(&self) -> Result<SocketAddr, PortError> {
        let port = self.0.host_port().await?;
        let result = SocketAddr::new(IpAddr::from(Ipv4Addr::LOCALHOST), port.into());
        Ok(result)
    }
}

impl Default for Netcat {
    fn default() -> Self {
        Self(ExposedPort::new(Self::PORT))
    }
}

impl ToRunnableContainer for Netcat {
    fn to_runnable(&self, builder: RunnableContainerBuilder) -> RunnableContainer {
        builder
            .with_image(ImageName::new("docker.io/alpine"))
            .with_port_mappings([self.0.clone()])
            .with_wait_strategy(WaitStrategy::scan_port(Self::PORT))
            .with_command(["nc", "-vl", "8888"])
            .build()
    }
}