add convenient info

distance-oracle/src/bin/distance_precompute.rs

@@ -4,8 +4,12 @@ use fnv::{FnvHashMap, FnvHashSet};
 use log::debug;
 use std::{io::Write, path::PathBuf};
 
-// computes distance result for all identities with status other than Revoked
-// this allows to have a recent estimate of the distance computation
+// this script is mainly copied from distance oracle code
+// it adds values not necessary in distance computation but convenient to have
+// it allows to have a recent estimate of the distance computation
+// intended use:
+// - compute distance result for all identities with received certifications
+// - put the result in a json file to be served publicly
 
 use clap::Parser;
 
@@ -20,12 +24,15 @@ struct Cli {
     log: log::LevelFilter,
 }
 
-//
+/// computation result as it will be serialized in json
 #[derive(serde::Serialize)]
 struct PrecomputationResult {
+    height: u32,
     block: sp_core::H256,
+    referees_count: u32,
+    member_count: u32,
+    min_certs_for_referee: u32,
     results: FnvHashMap<IdtyIndex, u32>,
-    referees: u32,
 }
 
 #[tokio::main]
@@ -38,13 +45,13 @@ async fn main() {
         .unwrap();
 
     let client = &distance_oracle::api::client(cli.rpc_url.clone()).await;
-    let parent_hash = api::parent_hash(client).await; // get hash of recent block
+    let block_hash = api::parent_hash(client).await; // get hash of recent block
+    let block_height = client.blocks().at(block_hash).await.unwrap().number();
     let max_depth = api::max_referee_distance(client).await; // get param
-    let evaluation_block = parent_hash;
 
     // get certs and member iterators
-    let mut certs_iter = api::cert_iter(client, evaluation_block).await;
-    let mut members_iter = api::member_iter(client, evaluation_block).await;
+    let mut certs_iter = api::cert_iter(client, block_hash).await;
+    let mut members_iter = api::member_iter(client, block_hash).await;
 
     // initialize hashmaps
     // member idty -> issued certs count (will only retain referees)
@@ -61,9 +68,10 @@ async fn main() {
     {
         members.insert(member_idty, 0);
     }
+    let member_count = members.len();
 
     // compute certification threshold as a function of the total member count
-    let min_certs_for_referee = (members.len() as f32).powf(1. / (max_depth as f32)).ceil() as u32;
+    let min_certs_for_referee = (member_count as f32).powf(1. / (max_depth as f32)).ceil() as u32;
 
     // collect certifications and updates members map at the same time
     while let Some((receiver, issuers)) = certs_iter
@@ -94,32 +102,37 @@ async fn main() {
     // Only retain referees
     members.retain(|_idty, issued_certs| *issued_certs >= min_certs_for_referee);
     let referees = members;
+    let referees_count = referees.len();
 
     // initialize map of distance results
     let mut results = FnvHashMap::<IdtyIndex, u32>::default();
 
-    // compute all distances
-    received_certs.keys().into_iter().for_each(|idty| {
+    // compute all distances (optimization: parallel)
+    received_certs.keys().for_each(|idty| {
         results.insert(
             *idty,
             distance_rule(&received_certs, &referees, max_depth, *idty) as u32,
         );
     });
 
-    // structure
+    // put results in a struct for serialization
     let precomputation_result = PrecomputationResult {
-        block: evaluation_block,
-        results: results,
-        referees: referees.len() as u32,
+        height: block_height,
+        block: block_hash,
+        min_certs_for_referee,
+        referees_count: referees_count as u32,
+        member_count: member_count as u32,
+        results,
     };
 
     // ---- SAVE
-    let evaluation_result_path =
-        Into::<PathBuf>::into(cli.evaluation_result_dir).join("todo-block-number".to_string());
+    const FILENAME: &str = "latest_distance.json";
+    let evaluation_result_path = Into::<PathBuf>::into(cli.evaluation_result_dir).join(FILENAME);
     debug!("Saving distance evaluation result to file `{evaluation_result_path:?}`");
     let mut evaluation_result_file = std::fs::OpenOptions::new()
         .write(true)
-        .create_new(true)
+        .create(true)
+        .truncate(true)
         .open(&evaluation_result_path)
         .unwrap_or_else(|e| {
             panic!(
@@ -137,7 +150,7 @@ async fn main() {
         });
 }
 
-// alternative function which returns number of reached referees
+// alternative function which returns number of reached referees instead of percentage
 fn distance_rule(
     received_certs: &FnvHashMap<IdtyIndex, Vec<IdtyIndex>>,
     referees: &FnvHashMap<IdtyIndex, u32>,