docker-tools 0.0.2

Docker tools, including docker, docker-compose and dockerd
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

use clap::{Parser, Subcommand};
use docker::Docker;
use serde_json::to_string_pretty;

#[derive(Parser)]
#[command(version, about, long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Run a container
    Run {
        /// Image name
        image: String,
        /// Container name
        #[arg(short, long)]
        name: Option<String>,
        /// Port mappings (host:container)
        #[arg(short, long)]
        port: Vec<String>,
    },
    /// List containers
    Ps {
        /// Show all containers (default shows just running)
        #[arg(short, long)]
        all: bool,
    },
    /// Stop a container
    Stop {
        /// Container ID or name
        container: String,
    },
    /// Remove a container
    Rm {
        /// Container ID or name
        container: String,
    },
    /// Build an image
    Build {
        /// Build context path
        context: String,
        /// Image name
        #[arg(short, long)]
        tag: String,
        /// Path to Dockerfile
        #[arg(short, long)]
        dockerfile: Option<String>,
        /// Do not use cache
        #[arg(long)]
        no_cache: bool,
        /// Target stage for multi-stage builds
        #[arg(long)]
        target: Option<String>,
    },
    /// List images
    Images,
    /// Pull an image
    Pull {
        /// Image name
        image: String,
        /// Tag name
        #[arg(short, long, default_value = "latest")]
        tag: String,
    },
}

#[tokio::main]
async fn main() {
    let cli = Cli::parse();
    let mut docker = match Docker::new() {
        Ok(docker) => docker,
        Err(e) => {
            eprintln!("Error initializing Podman: {:?}", e);
            std::process::exit(1);
        }
    };

    match cli.command {
        Commands::Run { image, name, port } => match docker.run(image, name, port, None, None, None, false, false).await {
            Ok(container) => println!("Container created: {}", container.id),
            Err(e) => eprintln!("Error running container: {:?}", e),
        },
        Commands::Ps { all } => match docker.list_containers(all).await {
            Ok(containers) => {
                for container in containers {
                    println!("{}", to_string_pretty(&container).unwrap());
                }
            }
            Err(e) => eprintln!("Error listing containers: {:?}", e),
        },
        Commands::Stop { container } => match docker.stop_container(&container).await {
            Ok(_) => println!("Container stopped: {}", container),
            Err(e) => eprintln!("Error stopping container: {:?}", e),
        },
        Commands::Rm { container } => match docker.remove_container(&container).await {
            Ok(_) => println!("Container removed: {}", container),
            Err(e) => eprintln!("Error removing container: {:?}", e),
        },
        Commands::Build {
            context,
            tag,
            dockerfile: _,
            no_cache,
            target: _,
        } => match docker
            .build_image(
                &context,
                &tag,
                false,
                no_cache,
                false,
            )
            .await
        {
            Ok(image) => println!("Image built: {}", image.id),
            Err(e) => eprintln!("Error building image: {:?}", e),
        },
        Commands::Images => match docker.list_images().await {
            Ok(images) => {
                for image in images {
                    println!("{}", to_string_pretty(&image).unwrap());
                }
            }
            Err(e) => eprintln!("Error listing images: {:?}", e),
        },
        Commands::Pull { image, tag } => match docker.pull_image(&image, &tag).await {
            Ok(image_info) => println!("Image pulled: {}", image_info.id),
            Err(e) => eprintln!("Error pulling image: {:?}", e),
        },
    }
}