bollard 0.21.0

An asynchronous Docker daemon API
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

//! Example demonstrating WebSocket container attach
//!
//! Run with: cargo run --features websocket --example websocket_attach
//!
//! NOTE: Docker's WebSocket attach endpoint (`/attach/ws`) uses `golang.org/x/net/websocket`
//! server-side, which has compatibility issues with standard RFC 6455 WebSocket implementations.
//! Data may not flow correctly on some Docker versions. For reliable container attach, use the
//! regular `attach_container()` method instead.

use bollard::container::AttachContainerResults;
use bollard::models::ContainerCreateBody;
use bollard::Docker;

use futures_util::{StreamExt, TryStreamExt};
use tokio::io::AsyncWriteExt;

const IMAGE: &str = "alpine:3";
const CONTAINER_NAME: &str = "websocket_attach_example";

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + 'static>> {
    let docker = Docker::connect_with_local_defaults()?;

    // Pull image
    println!("Pulling {IMAGE}...");
    docker
        .create_image(
            Some(
                bollard::query_parameters::CreateImageOptionsBuilder::default()
                    .from_image(IMAGE)
                    .build(),
            ),
            None,
            None,
        )
        .try_collect::<Vec<_>>()
        .await?;

    // Remove existing container if any
    let _ = docker
        .remove_container(
            CONTAINER_NAME,
            Some(
                bollard::query_parameters::RemoveContainerOptionsBuilder::default()
                    .force(true)
                    .build(),
            ),
        )
        .await;

    // Create and start container
    println!("Creating container...");
    let config = ContainerCreateBody {
        image: Some(String::from(IMAGE)),
        tty: Some(true),
        attach_stdin: Some(true),
        attach_stdout: Some(true),
        attach_stderr: Some(true),
        open_stdin: Some(true),
        cmd: Some(vec![String::from("/bin/sh")]),
        ..Default::default()
    };

    docker
        .create_container(
            Some(bollard::query_parameters::CreateContainerOptions {
                name: Some(String::from(CONTAINER_NAME)),
                ..Default::default()
            }),
            config,
        )
        .await?;

    println!("Starting container...");
    docker
        .start_container(
            CONTAINER_NAME,
            None::<bollard::query_parameters::StartContainerOptions>,
        )
        .await?;

    // Attach via WebSocket
    println!("Attaching via WebSocket...");
    let options = bollard::query_parameters::AttachContainerOptionsBuilder::default()
        .stdin(true)
        .stdout(true)
        .stderr(true)
        .stream(true)
        .build();

    let AttachContainerResults { output, mut input } = docker
        .attach_container_websocket(CONTAINER_NAME, Some(options))
        .await?;

    println!("WebSocket connection established!");
    println!("Note: Due to Docker server-side limitations, data may not flow correctly.\n");

    // Send a command
    println!("Sending: echo 'Hello from WebSocket!'");
    input.write_all(b"echo 'Hello from WebSocket!'\n").await?;
    input.flush().await?;

    // Read output with timeout
    println!("--- Container Output (3 second timeout) ---");
    let mut output = output;
    let output_result = tokio::time::timeout(std::time::Duration::from_secs(3), async {
        let mut count = 0;
        while let Some(result) = output.next().await {
            match result {
                Ok(log) => {
                    print!("{}", log);
                    count += 1;
                    if count >= 5 {
                        break;
                    }
                }
                Err(e) => {
                    eprintln!("Read error: {}", e);
                    break;
                }
            }
        }
        count
    })
    .await;

    match output_result {
        Ok(count) => println!("\nReceived {} output items", count),
        Err(_) => println!("\n(timeout - expected due to Docker WebSocket limitations)"),
    }
    println!("--- End Output ---\n");

    // Cleanup
    println!("Cleaning up...");
    let _ = docker
        .remove_container(
            CONTAINER_NAME,
            Some(
                bollard::query_parameters::RemoveContainerOptionsBuilder::default()
                    .force(true)
                    .build(),
            ),
        )
        .await;

    println!("Done!");
    Ok(())
}