Merge pull request #6 from unytco/register-dna

Register dna

Author: neonphog

src/bin/log-sender.rs

@@ -49,6 +49,31 @@ enum Cmd {
         conductor_config_path: Vec<std::path::PathBuf>,
     },
 
+    /// Register DNA hashes with agreements and optional price sheets for a
+    /// drone.
+    RegisterDna {
+        /// Specify a full path to a config file,
+        /// e.g. `/var/run/log-sender-runtime.json`.
+        #[arg(long, env = "LOG_SENDER_CONFIG_FILE")]
+        config_file: std::path::PathBuf,
+
+        /// The dna hash to register.
+        #[arg(long, env = "LOG_SENDER_DNA_HASH")]
+        dna_hash: String,
+
+        /// The agreement id to register.
+        #[arg(long, env = "LOG_SENDER_AGREEMENT_ID")]
+        agreement_id: String,
+
+        /// Optionally attach a price-sheet hash.
+        #[arg(long, env = "LOG_SENDER_PRICE_SHEET_HASH")]
+        price_sheet_hash: Option<String>,
+
+        /// Optionally include additional json metadata.
+        #[arg(long, env = "LOG_SENDER_METADATA")]
+        metadata: Option<String>,
+    },
+
     /// Run the service, polling a log-file directory for metrics to
     /// publish to the log-collector.
     Service {
@@ -98,6 +123,24 @@ async fn main() {
         )
         .await
         .unwrap(),
+        Cmd::RegisterDna {
+            config_file,
+            dna_hash,
+            agreement_id,
+            price_sheet_hash,
+            metadata,
+        } => {
+            let out = log_sender::register_dna(
+                config_file,
+                dna_hash,
+                agreement_id,
+                price_sheet_hash,
+                metadata.map(|s| serde_json::from_str(&s).unwrap()),
+            )
+            .await
+            .unwrap();
+            println!("{}", serde_json::to_string_pretty(&out).unwrap());
+        }
         Cmd::Service { config_file } => {
             log_sender::run_service(config_file).await.unwrap()
         }

src/client.rs

@@ -134,6 +134,96 @@ impl Client {
         Err(std::io::Error::other(format!("invalid response: {res:?}")))
     }
 
+    /// Make a "register-dna" call.
+    pub async fn register_dna(
+        &self,
+        config: &RuntimeConfigFile,
+        dna_hash: String,
+        agreement_id: String,
+        price_sheet_hash: Option<String>,
+        metadata: Option<serde_json::Value>,
+    ) -> Result<serde_json::Value> {
+        let mut url = self.url.clone();
+        url.set_path("/register-dna");
+
+        #[derive(serde::Serialize)]
+        #[serde(rename_all = "camelCase")]
+        struct Req {
+            drone_pub_key: String,
+            dna_hash: String,
+            agreement_id: String,
+            price_sheet_hash: Option<String>,
+            drone_signature: String,
+            signature_timestamp: u64,
+            metadata: Option<serde_json::Value>,
+        }
+
+        let drone_pub_key = config.drone_pub_key.clone();
+        let signature_timestamp = std::time::SystemTime::UNIX_EPOCH
+            .elapsed()
+            .expect("can get time")
+            .as_millis() as u64;
+
+        #[derive(serde::Serialize)]
+        #[serde(rename_all = "camelCase")]
+        struct Sig {
+            drone_pub_key: String,
+            dna_hash: String,
+            agreement_id: String,
+            timestamp: u64,
+            #[serde(skip_serializing_if = "Option::is_none")]
+            price_sheet_hash: Option<String>,
+            #[serde(skip_serializing_if = "Option::is_none")]
+            metadata: Option<serde_json::Value>,
+        }
+
+        let sig = serde_json::to_string(&Sig {
+            drone_pub_key: drone_pub_key.clone(),
+            dna_hash: dna_hash.clone(),
+            agreement_id: agreement_id.clone(),
+            timestamp: signature_timestamp,
+            price_sheet_hash: price_sheet_hash.clone(),
+            metadata: metadata.clone(),
+        })?;
+
+        let drone_signature = config.rt_drone_sec_key.sign(sig.as_bytes())?;
+
+        let res = self
+            .client
+            .post(url)
+            .json(&Req {
+                drone_pub_key,
+                dna_hash,
+                agreement_id,
+                price_sheet_hash,
+                drone_signature,
+                signature_timestamp,
+                metadata,
+            })
+            .send()
+            .await
+            .map_err(std::io::Error::other)?;
+
+        if res.error_for_status_ref().is_err() {
+            return Err(std::io::Error::other(
+                res.text().await.map_err(std::io::Error::other)?,
+            ));
+        }
+
+        let res: serde_json::Value =
+            res.json().await.map_err(std::io::Error::other)?;
+
+        if let Some(obj) = res.as_object()
+            && let Some(p) = obj.get("success")
+            && let Some(b) = p.as_bool()
+            && b
+        {
+            return Ok(res);
+        }
+
+        Err(std::io::Error::other(format!("invalid response: {res:?}")))
+    }
+
     /// Submit metrics to the endpoint.
     pub async fn metrics(
         &self,

src/lib.rs

@@ -52,6 +52,34 @@ pub async fn initialize(
     Ok(())
 }
 
+/// Register DNA hashes with agreements and optional price sheets for a drone.
+pub async fn register_dna(
+    config_file: std::path::PathBuf,
+    dna_hash: String,
+    agreement_id: String,
+    price_sheet_hash: Option<String>,
+    metadata: Option<serde_json::Value>,
+) -> Result<serde_json::Value> {
+    let config = RuntimeConfigFile::with_load(config_file).await?;
+
+    let url =
+        reqwest::Url::parse(&config.endpoint).map_err(std::io::Error::other)?;
+
+    let client = Client::new(url).await?;
+
+    client.health().await?;
+
+    client
+        .register_dna(
+            &config,
+            dna_hash,
+            agreement_id,
+            price_sheet_hash,
+            metadata,
+        )
+        .await
+}
+
 /// Run the service checking for report logs and reporting them.
 pub async fn run_service(config_file: std::path::PathBuf) -> Result<()> {
     let mut config = RuntimeConfigFile::with_load(config_file).await?;