radrootsd

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

main.rs (2238B)


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