rsbuild 0.5.1

A self-sufficient runtime to build projects
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

//! Docker pull command implementations.

use crate::cli::{ExecContext, PullTarget};
use crate::error::Result;
use crate::executor::{check_tool, exec, print_status, print_warning};
use crate::output::{self, BatchResult, CommandResult};
use crate::parallel::{self, TaskResult};
use std::time::Instant;

/// Execute the pull command.
pub fn run(target: PullTarget, ctx: &ExecContext) -> Result<()> {
    check_tool("docker")?;

    match target {
        PullTarget::All => pull_all(ctx),
        PullTarget::Service { name } => pull_service(&name, ctx),
    }
}

/// Pull all configured Docker images.
fn pull_all(ctx: &ExecContext) -> Result<()> {
    let start = Instant::now();
    let services = vec!["vanilla", "sandbox"];

    if ctx.is_parallel() {
        // Parallel execution
        let tasks: Vec<_> = services
            .iter()
            .map(|&service| {
                let ctx = ctx.clone();
                let name = service.to_string();
                (
                    name.clone(),
                    move || -> std::result::Result<String, String> {
                        pull_service_internal(&name, &ctx).map(|_| format!("Pulled {}", name))
                    },
                )
            })
            .collect();

        let results = parallel::execute(tasks, ctx, "Pulling Docker images");
        let duration = start.elapsed();

        if ctx.is_json() {
            let batch = results_to_batch(&results, duration);
            output::emit_json(&batch);
        } else {
            let failed: Vec<_> = results.iter().filter(|r| r.result.is_err()).collect();
            if !failed.is_empty() {
                for r in failed {
                    if let Err(e) = &r.result {
                        print_warning(&format!("Failed to pull '{}': {}", r.name, e), ctx);
                    }
                }
            }
            print_status("Pull all completed", ctx);
        }
    } else {
        // Sequential execution
        print_status("Pulling all Docker images", ctx);

        let mut results = Vec::new();

        for service in &services {
            match pull_service(service, ctx) {
                Ok(_) => {
                    results.push(CommandResult::success(*service, std::time::Duration::ZERO, None));
                }
                Err(e) => {
                    print_warning(&format!("Failed to pull '{}': {}", service, e), ctx);
                    results.push(CommandResult::failed(
                        *service,
                        std::time::Duration::ZERO,
                        e.to_string(),
                    ));
                }
            }
        }

        if ctx.is_json() {
            let batch = BatchResult::from_results(results, start.elapsed());
            output::emit_json(&batch);
        } else {
            print_status("Pull all completed", ctx);
        }
    }

    Ok(())
}

/// Pull a specific Docker Compose service image.
fn pull_service(name: &str, ctx: &ExecContext) -> Result<()> {
    print_status(&format!("Pulling Docker image: {}", name), ctx);
    exec(&format!("docker compose pull {}", name), ctx)?;
    Ok(())
}

/// Internal pull for parallel execution.
fn pull_service_internal(name: &str, ctx: &ExecContext) -> std::result::Result<(), String> {
    exec(&format!("docker compose pull {}", name), ctx).map_err(|e| e.to_string())?;
    Ok(())
}

/// Convert task results to batch result for JSON output.
fn results_to_batch(results: &[TaskResult<String>], duration: std::time::Duration) -> BatchResult {
    let command_results: Vec<CommandResult> = results
        .iter()
        .map(|r| match &r.result {
            Ok(msg) => CommandResult::success(&r.name, std::time::Duration::ZERO, Some(msg.clone())),
            Err(e) => CommandResult::failed(&r.name, std::time::Duration::ZERO, e),
        })
        .collect();

    BatchResult::from_results(command_results, duration)
}