forest-filecoin 0.33.2

Rust Filecoin implementation.
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

// Copyright 2019-2026 ChainSafe Systems
// SPDX-License-Identifier: Apache-2.0, MIT

use std::{
    io::{Write, stdout},
    time::Duration,
};

use crate::health::DEFAULT_HEALTHCHECK_PORT;
use crate::rpc;
use clap::Subcommand;
use http::StatusCode;

#[derive(Debug, Subcommand)]
pub enum HealthcheckCommand {
    /// Display readiness status
    Ready {
        /// Don't exit until node is ready
        #[arg(long)]
        wait: bool,
        /// Healthcheck port
        #[arg(long, default_value_t=DEFAULT_HEALTHCHECK_PORT)]
        healthcheck_port: u16,
    },
    /// Display liveness status
    Live {
        /// Don't exit until node is ready
        #[arg(long)]
        wait: bool,
        /// Healthcheck port
        #[arg(long, default_value_t=DEFAULT_HEALTHCHECK_PORT)]
        healthcheck_port: u16,
    },
    /// Display health status
    Healthy {
        /// Don't exit until node is ready
        #[arg(long)]
        wait: bool,
        /// Healthcheck port
        #[arg(long, default_value_t=DEFAULT_HEALTHCHECK_PORT)]
        healthcheck_port: u16,
    },
}

impl HealthcheckCommand {
    pub async fn run(self, client: rpc::Client) -> anyhow::Result<()> {
        match self {
            Self::Ready {
                wait,
                healthcheck_port,
            } => Self::check(&client, "readyz", healthcheck_port, wait).await,
            Self::Live {
                wait,
                healthcheck_port,
            } => Self::check(&client, "livez", healthcheck_port, wait).await,
            Self::Healthy {
                wait,
                healthcheck_port,
            } => Self::check(&client, "healthz", healthcheck_port, wait).await,
        }
    }

    async fn check(
        client: &rpc::Client,
        endpoint: &str,
        healthcheck_port: u16,
        wait: bool,
    ) -> anyhow::Result<()> {
        let mut stdout = stdout();

        let url = format!(
            "http://{}:{healthcheck_port}/{endpoint}?verbose",
            client.base_url().host_str().unwrap_or("localhost"),
        );

        let mut interval = tokio::time::interval(Duration::from_secs(1));
        loop {
            interval.tick().await;
            let (status, text) = {
                match reqwest::get(&url).await {
                    Ok(response) => {
                        let status = response.status();
                        let text = match response.text().await {
                            Ok(t) => t,
                            Err(e) if wait => e.to_string(),
                            Err(e) => anyhow::bail!("{e}"),
                        };
                        (status, text)
                    }
                    Err(e) if wait => {
                        eprintln!("{e}");
                        (http::StatusCode::INTERNAL_SERVER_ERROR, "".into())
                    }
                    Err(e) => anyhow::bail!("{e}"),
                }
            };

            println!("{text}");

            if !wait {
                break;
            }
            if status == StatusCode::OK {
                println!("Done!");
                break;
            }

            for _ in 0..(text.matches('\n').count() + 1) {
                write!(
                    stdout,
                    "\r{}{}",
                    anes::MoveCursorUp(1),
                    anes::ClearLine::All,
                )?;
            }
        }
        Ok(())
    }
}