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
136
137
138
139
140
141
142
143
144
145

use crate::{
    Container, ExposedPort, ImageName, Port, PortError, RunnableContainer,
    RunnableContainerBuilder, ToRunnableContainer, WaitStrategy,
};

const NATS_IMAGE: &ImageName = &ImageName::new("docker.io/nats");

const CLIENT_PORT: Port = Port(4222);
const CLUSTER_PORT: Port = Port(6222);
const MONITORING_PORT: Port = Port(8222);

/// A `Nats` image
///
/// # Example
///
/// ```rust, no_run
/// # async fn run() -> anyhow::Result<()> {
/// use rustainers::images::Nats;
///
/// let default_image = Nats::default();
///
/// let custom_image = Nats::default()
///        .with_tag("2.7.4");
///
/// # let runner = rustainers::runner::Runner::auto()?;
/// // ...
/// let container = runner.start(default_image).await?;
/// let endpoint = container.client_endpoint().await?;
/// // ...
/// # Ok(())
/// # }
#[derive(Debug)]
pub struct Nats {
    image: ImageName,
    client_port: ExposedPort,
    cluster_port: ExposedPort,
    monitoring_port: ExposedPort,
}

impl Nats {
    /// Set the image tag
    #[must_use]
    pub fn with_tag(self, tag: impl Into<String>) -> Self {
        let Self { mut image, .. } = self;
        image.set_tag(tag);
        Self { image, ..self }
    }

    /// Set the image digest
    #[must_use]
    pub fn with_digest(self, digest: impl Into<String>) -> Self {
        let Self { mut image, .. } = self;
        image.set_digest(digest);
        Self { image, ..self }
    }

    /// Set the client port
    #[must_use]
    pub fn with_client_port(mut self, port: ExposedPort) -> Self {
        self.client_port = port;
        self
    }

    /// Set the cluster port
    #[must_use]
    pub fn with_cluster_port(mut self, port: ExposedPort) -> Self {
        self.cluster_port = port;
        self
    }

    /// Set the monitoring port
    #[must_use]
    pub fn with_monitoring_port(mut self, port: ExposedPort) -> Self {
        self.monitoring_port = port;
        self
    }
}

impl Default for Nats {
    fn default() -> Self {
        Self {
            image: NATS_IMAGE.clone(),
            client_port: ExposedPort::new(CLIENT_PORT),
            cluster_port: ExposedPort::new(CLUSTER_PORT),
            monitoring_port: ExposedPort::new(MONITORING_PORT),
        }
    }
}

impl Container<Nats> {
    /// Get endpoint URL for the client port
    ///
    /// # Errors
    ///
    /// Could fail if the port is not bind
    pub async fn client_endpoint(&self) -> Result<String, PortError> {
        let port = self.client_port.host_port().await?;
        let host_ip = self.runner.container_host_ip().await?;
        let url = format!("nats://{host_ip}:{port}");

        Ok(url)
    }

    /// Get endpoint URL for the monitoring port
    ///
    /// # Errors
    ///
    /// Could fail if the port is not bind
    pub async fn monitoring_endpoint(&self) -> Result<String, PortError> {
        let port = self.monitoring_port.host_port().await?;
        let host_ip = self.runner.container_host_ip().await?;
        let url = format!("http://{host_ip}:{port}");

        Ok(url)
    }

    /// Get endpoint URL for the cluster port
    ///
    /// # Errors
    ///
    /// Could fail if the port is not bind
    pub async fn cluster_endpoint(&self) -> Result<String, PortError> {
        let port = self.cluster_port.host_port().await?;
        let host_ip = self.runner.container_host_ip().await?;
        let url = format!("nats-route://{host_ip}:{port}");

        Ok(url)
    }
}

impl ToRunnableContainer for Nats {
    fn to_runnable(&self, builder: RunnableContainerBuilder) -> RunnableContainer {
        builder
            .with_image(self.image.clone())
            .with_wait_strategy(WaitStrategy::stderr_contains(
                "Listening for client connections",
            ))
            .with_port_mappings([
                self.client_port.clone(),
                self.cluster_port.clone(),
                self.monitoring_port.clone(),
            ])
            .build()
    }
}