radrootsd

JSON-RPC bridge for Radroots event publishing
git clone https://radroots.dev/git/radrootsd.git
Log | Files | Refs | README | LICENSE

main.rs (2555B)


      1 #![forbid(unsafe_code)]
      2 
      3 mod rshr_202_step_303_gate;
      4 mod rshr_202_step_303_platform;
      5 mod source_lock;
      6 
      7 fn main() {
      8     if std::env::args().nth(1).as_deref() == Some("source-lock") {
      9         let arguments = std::env::args().skip(2).collect::<Vec<_>>();
     10         if source_lock::run(&arguments).is_err() {
     11             eprintln!("source_lock_failed");
     12             std::process::exit(1);
     13         }
     14         return;
     15     }
     16     if run().is_err() {
     17         eprintln!("step_303_gate_failed");
     18         std::process::exit(1);
     19     }
     20 }
     21 
     22 fn run() -> Result<(), ()> {
     23     let mut arguments = std::env::args().skip(1);
     24     match arguments.next().as_deref() {
     25         Some("rshr-step-303-gate") => {
     26             let args = parse_gate_args(arguments.collect())?;
     27             rshr_202_step_303_gate::run(args).map_err(|_| ())
     28         }
     29         Some("rshr-step-303-platform-probe") if arguments.next().is_none() => {
     30             rshr_202_step_303_platform::run().map_err(|_| ())
     31         }
     32         _ => Err(()),
     33     }
     34 }
     35 
     36 fn parse_gate_args(values: Vec<String>) -> Result<rshr_202_step_303_gate::Arguments, ()> {
     37     let mut step = None;
     38     let mut check_id = None;
     39     let mut source_revision = None;
     40     let mut source_tree = None;
     41     let mut candidate_digest = None;
     42     let mut platform = None;
     43     let mut execution_request_sha256 = None;
     44     for value in values {
     45         let (name, value) = value.split_once('=').ok_or(())?;
     46         let slot = match name {
     47             "--check-id" => &mut check_id,
     48             "--source-revision" => &mut source_revision,
     49             "--source-tree" => &mut source_tree,
     50             "--candidate-digest" => &mut candidate_digest,
     51             "--platform" => &mut platform,
     52             "--execution-request-sha256" => &mut execution_request_sha256,
     53             "--step" => {
     54                 let parsed = value.parse::<u16>().map_err(|_| ())?;
     55                 if step.replace(parsed).is_some() {
     56                     return Err(());
     57                 }
     58                 continue;
     59             }
     60             _ => return Err(()),
     61         };
     62         if value.is_empty() || slot.replace(value.to_owned()).is_some() {
     63             return Err(());
     64         }
     65     }
     66     Ok(rshr_202_step_303_gate::Arguments {
     67         step: step.ok_or(())?,
     68         check_id: check_id.ok_or(())?,
     69         source_revision: source_revision.ok_or(())?,
     70         source_tree: source_tree.ok_or(())?,
     71         candidate_digest: candidate_digest.ok_or(())?,
     72         platform: platform.ok_or(())?,
     73         execution_request_sha256: execution_request_sha256.ok_or(())?,
     74     })
     75 }