plane 0.5.5

Session backend orchestrator for ambitious browser-based apps.
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

use chrono::Duration;
use futures_util::Future;
use std::net::{IpAddr, ToSocketAddrs};
use tokio::task::JoinHandle;

pub fn format_duration(duration: Duration) -> String {
    let mut parts = vec![];

    let days = duration.num_days();
    if days > 0 {
        parts.push(format!("{}d", days));
    }

    let hours = duration.num_hours() % 24;
    if hours > 0 {
        parts.push(format!("{}h", hours));
    }

    let minutes = duration.num_minutes() % 60;
    if minutes > 0 {
        parts.push(format!("{}m", minutes));
    }

    let seconds = duration.num_seconds() % 60;
    if seconds > 0 {
        parts.push(format!("{}s", seconds));
    }

    if parts.is_empty() {
        "0s".to_string()
    } else {
        parts.join(" ")
    }
}

#[derive(Debug)]
pub struct GuardHandle {
    handle: JoinHandle<()>,
}

impl GuardHandle {
    pub fn new<F>(future: F) -> Self
    where
        F: Future<Output = ()> + Send + 'static,
    {
        let handle = tokio::spawn(future);
        Self { handle }
    }
}

impl Drop for GuardHandle {
    fn drop(&mut self) {
        self.handle.abort();
    }
}

/// Resolve a hostname to an IP address.
pub fn resolve_hostname(hostname: &str) -> Option<IpAddr> {
    // The port is arbitrary, but needs to be provided.
    let socket_addrs = format!("{}:0", hostname).to_socket_addrs().ok()?;

    for socket_addr in socket_addrs {
        if let IpAddr::V4(ip) = socket_addr.ip() {
            tracing::info!("Resolved hostname to IP: {}", ip);
            return Some(ip.into());
        }
    }

    None
}