cgd 0.1.0-alpha.2

Official command-line interface for Coragrid source-linked private-market data infrastructure
Documentation
use std::io;

#[cfg(unix)]
use nix::sys::signal::Signal;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ShutdownSignal {
    Interrupt,
    Terminate,
}

pub struct ShutdownSignals {
    #[cfg(unix)]
    terminate: tokio::signal::unix::Signal,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TuiSignal {
    Interrupt,
    Terminate,
    #[cfg(unix)]
    Suspend,
}

pub struct TuiSignals {
    shutdown: ShutdownSignals,
    #[cfg(unix)]
    suspend: tokio::signal::unix::Signal,
}

impl ShutdownSignals {
    pub fn new() -> io::Result<Self> {
        #[cfg(unix)]
        {
            Ok(Self {
                terminate: tokio::signal::unix::signal(
                    tokio::signal::unix::SignalKind::terminate(),
                )?,
            })
        }
        #[cfg(not(unix))]
        {
            Ok(Self {})
        }
    }

    pub async fn recv(&mut self) -> io::Result<ShutdownSignal> {
        #[cfg(unix)]
        {
            tokio::select! {
                result = tokio::signal::ctrl_c() => {
                    result?;
                    Ok(ShutdownSignal::Interrupt)
                }
                signal = self.terminate.recv() => {
                    signal.ok_or_else(|| {
                        io::Error::new(
                            io::ErrorKind::UnexpectedEof,
                            "SIGTERM listener closed unexpectedly",
                        )
                    })?;
                    Ok(ShutdownSignal::Terminate)
                }
            }
        }
        #[cfg(not(unix))]
        {
            tokio::signal::ctrl_c().await?;
            Ok(ShutdownSignal::Interrupt)
        }
    }
}

impl TuiSignals {
    pub fn new() -> io::Result<Self> {
        Ok(Self {
            shutdown: ShutdownSignals::new()?,
            #[cfg(unix)]
            suspend: tokio::signal::unix::signal(tokio::signal::unix::SignalKind::from_raw(
                Signal::SIGTSTP as i32,
            ))?,
        })
    }

    pub async fn recv(&mut self) -> io::Result<TuiSignal> {
        #[cfg(unix)]
        {
            tokio::select! {
                signal = self.shutdown.recv() => {
                    Ok(match signal? {
                        ShutdownSignal::Interrupt => TuiSignal::Interrupt,
                        ShutdownSignal::Terminate => TuiSignal::Terminate,
                    })
                }
                signal = self.suspend.recv() => {
                    signal.ok_or_else(|| {
                        io::Error::new(
                            io::ErrorKind::UnexpectedEof,
                            "SIGTSTP listener closed unexpectedly",
                        )
                    })?;
                    Ok(TuiSignal::Suspend)
                }
            }
        }
        #[cfg(not(unix))]
        {
            Ok(match self.shutdown.recv().await? {
                ShutdownSignal::Interrupt => TuiSignal::Interrupt,
                ShutdownSignal::Terminate => TuiSignal::Terminate,
            })
        }
    }
}