hylix 0.10.0

Build, test & deploy verifiable apps on Hyli
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
149

use crate::error::{HylixError, HylixResult};
use crate::logging::{log_error, log_success, log_warning, ProgressExecutor};
use crate::{constants, docker::ContainerSpec};

use super::context::DevnetContext;

/// Container status enum
#[derive(Debug, Clone, PartialEq)]
pub enum ContainerStatus {
    Running,
    Stopped,
    NotExisting,
}

pub async fn get_docker_container_status(container_name: &str) -> HylixResult<ContainerStatus> {
    use tokio::process::Command;

    // First check if container exists at all (running or stopped)
    let output = Command::new("docker")
        .args(["ps", "-a", "-q", "-f", &format!("name=^{container_name}$")])
        .output()
        .await
        .map_err(|e| HylixError::process(format!("Failed to check Docker container: {e}")))?;

    if output.stdout.is_empty() {
        return Ok(ContainerStatus::NotExisting);
    }

    // If container exists, check if it's running
    let running_output = Command::new("docker")
        .args(["ps", "-q", "-f", &format!("name={container_name}")])
        .output()
        .await
        .map_err(|e| HylixError::process(format!("Failed to check Docker container: {e}")))?;

    if running_output.stdout.is_empty() {
        Ok(ContainerStatus::Stopped)
    } else {
        Ok(ContainerStatus::Running)
    }
}

pub async fn check_docker_container(
    _context: &DevnetContext,
    container_name: &str,
) -> HylixResult<ContainerStatus> {
    let status = get_docker_container_status(container_name).await?;
    match status {
        ContainerStatus::Running => {
            log_success(&format!("Container {container_name} is running"));
        }
        ContainerStatus::Stopped => {
            log_warning(&format!("Container {container_name} is stopped"));
        }
        ContainerStatus::NotExisting => {
            log_error(&format!("Container {container_name} does not exist"));
        }
    }
    Ok(status)
}

pub async fn start_containers(context: &DevnetContext) -> HylixResult<()> {
    const CONTAINERS: [&str; 7] = constants::containers::ALL;
    let executor = ProgressExecutor::new();
    for container in CONTAINERS {
        if get_docker_container_status(container).await? == ContainerStatus::Stopped {
            start_container(&executor, context, container).await?;
        }
    }
    executor.clear()?;
    Ok(())
}

pub async fn start_container(
    executor: &ProgressExecutor,
    _context: &DevnetContext,
    container_name: &str,
) -> HylixResult<()> {
    let success = executor
        .execute_command(
            format!("Starting container {container_name}"),
            "docker",
            &["start", container_name],
            None,
        )
        .await?;
    if success {
        log_success(&format!("Started container {container_name}"));
    } else {
        return Err(HylixError::process(format!(
            "Failed to start {container_name}"
        )));
    }
    Ok(())
}

/// Stop and remove a Docker container
pub async fn stop_and_remove_container(
    pb: &indicatif::ProgressBar,
    container_name: &str,
    display_name: &str,
) -> HylixResult<()> {
    use tokio::process::Command;

    // If container does not exist, skip
    if get_docker_container_status(container_name).await? == ContainerStatus::NotExisting {
        pb.set_message(format!("{display_name} does not exist, skipping..."));
        return Ok(());
    }

    // Stop the container
    pb.set_message(format!("Stopping {display_name}..."));
    let output = Command::new("docker")
        .args(["stop", container_name])
        .output()
        .await
        .map_err(|e| HylixError::process(format!("Failed to stop Docker container: {e}")))?;

    if !output.status.success() {
        log_warning(&format!("{}", String::from_utf8_lossy(&output.stderr)));
    } else {
        pb.set_message(format!("{display_name} stopped successfully"));
    }

    // Remove the container
    pb.set_message(format!("Removing {display_name}..."));
    let output = Command::new("docker")
        .args(["rm", container_name])
        .output()
        .await
        .map_err(|e| HylixError::process(format!("Failed to remove Docker container: {e}")))?;

    if !output.status.success() {
        log_warning(&format!("{}", String::from_utf8_lossy(&output.stderr)));
    } else {
        pb.set_message(format!("{display_name} removed successfully"));
    }

    Ok(())
}

/// Start a container using ContainerManager
pub async fn start_managed_container(
    executor: &ProgressExecutor,
    spec: ContainerSpec,
    pull: bool,
) -> HylixResult<()> {
    crate::docker::ContainerManager::start_container(executor, spec, pull).await
}