docker-container-log-streamer 0.1.0

A Rust library for streaming docker logs via websocket.
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


#[tokio::test]
async fn test_docker_since(){
    use crate::docker_since;
    assert_eq!(docker_since(0),0);
    assert!(docker_since(30)>0);
}

#[tokio::test]
async fn test_docker_logs(){
    use crate::docker_logs;
    use crate::Logger;
    use futures_util::StreamExt;
    use bollard::{
        Docker,
        container::{
            RemoveContainerOptions,
            CreateContainerOptions, 
            Config,
            LogsOptions, 
            LogOutput
        },
    };
    let mut logger: Logger = Logger::new(&"test-docker-logs.log".to_string());
    let docker = Docker::connect_with_local_defaults().unwrap();
    match docker.create_container(Some(CreateContainerOptions{
        name:"test-random-messages".to_string(),
        platform: None
    }),Config {
        hostname: Some("test-random-messages".to_string()),
        tty: Some(false),
        env: Some(vec![            
            "SLEEP_TIME=0.01".to_string(),
            "LOOP_LIMIT=5".to_string(),
        ]),
        image: Some("random_messages:latest".to_string()),
        ..Default::default()
    }).await {
        Ok(result) => {
            println!("Create Container: {:?}",result);
            match docker.start_container::<String>(&result.id, None ).await {
                Ok(_) => {
                    let container_id: String = result.id.clone();
                    println!("Container ID: {}",container_id);
                    let mut logs = docker_logs(container_id.clone(),30).await;
                    
                    while let Some(log_result) = logs.next().await {
                        match log_result {
                            Ok(log_output) => {
                                match log_output {
                                    LogOutput::Console { message } =>{
                                        logger.write(&message);
                                    }
                                    _ => continue
                                };
                            },
                            Err(error) => {
                                eprintln!("{:?}",error);
                                assert!(false);
                                break;
                            }
                        }
                    }
                    if let Err(error) = docker.remove_container(container_id.as_str(), Some(RemoveContainerOptions{
                        force:true,
                        ..Default::default()
                    })).await {              
                        eprintln!("docker remove container error: {}",error);
                        assert!(false);
                    }
                    else{
                        assert!(true);
                    }
                }
                Err(error) => {
                    eprintln!("start_container error: {}",error);
                    assert!(false);
                }
            }
        }
        Err(error) => {
            eprintln!("Create Container: {:?}",error);
            assert!(false);
        }
    }
    
}