myc

Self-custodial remote signer for Radroots apps
git clone https://radroots.dev/git/myc.git
Log | Files | Refs | README | LICENSE

main.rs (2473B)


      1 #![forbid(unsafe_code)]
      2 
      3 use std::{io::Write as _, process::ExitCode};
      4 
      5 use myc::{MycLogRecord, MycProcessResult};
      6 
      7 struct MycOsSignalSource {
      8     #[cfg(unix)]
      9     interrupt: tokio::signal::unix::Signal,
     10     #[cfg(unix)]
     11     terminate: tokio::signal::unix::Signal,
     12 }
     13 
     14 impl MycOsSignalSource {
     15     fn new() -> Option<Self> {
     16         #[cfg(unix)]
     17         {
     18             let interrupt =
     19                 tokio::signal::unix::signal(tokio::signal::unix::SignalKind::interrupt()).ok()?;
     20             let terminate =
     21                 tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).ok()?;
     22             Some(Self {
     23                 interrupt,
     24                 terminate,
     25             })
     26         }
     27         #[cfg(not(unix))]
     28         {
     29             Some(Self {})
     30         }
     31     }
     32 }
     33 
     34 impl myc::MycProcessSignalSource for MycOsSignalSource {
     35     fn next_signal(&mut self) -> myc::MycProcessSignalFuture<'_> {
     36         #[cfg(unix)]
     37         {
     38             Box::pin(async move {
     39                 tokio::select! {
     40                     observed = self.interrupt.recv() => observed.map(|()| myc::MycProcessSignal::Interrupt),
     41                     observed = self.terminate.recv() => observed.map(|()| myc::MycProcessSignal::Terminate),
     42                 }
     43             })
     44         }
     45         #[cfg(not(unix))]
     46         {
     47             Box::pin(async move {
     48                 tokio::signal::ctrl_c()
     49                     .await
     50                     .ok()
     51                     .map(|()| myc::MycProcessSignal::Interrupt)
     52             })
     53         }
     54     }
     55 }
     56 
     57 fn main() -> ExitCode {
     58     match myc::parse_myc_cli_v1_from(std::env::args_os()) {
     59         Ok(invocation) => {
     60             let result =
     61                 myc::execute_myc_cli_v1_with_signal_source(invocation, MycOsSignalSource::new);
     62             eprintln!("{}", MycLogRecord::process_result(result));
     63             result.exit_code()
     64         }
     65         Err(error) => {
     66             if let Some(help) = error.help_text() {
     67                 if std::io::stdout().lock().write_all(help.as_bytes()).is_ok() {
     68                     return ExitCode::SUCCESS;
     69                 }
     70                 let result = MycProcessResult::InputOrConfiguration;
     71                 eprintln!("{}", MycLogRecord::process_result(result));
     72                 return result.exit_code();
     73             }
     74             let result = MycProcessResult::InputOrConfiguration;
     75             eprintln!("{}", MycLogRecord::process_result(result));
     76             result.exit_code()
     77         }
     78     }
     79 }