Merge pull request #207 from Neccolini/rekor_logentry_body_info

Changed the type of LogEntry.body from String to Body

src/rekor/apis/entries_api.rs

@@ -14,6 +14,7 @@ use super::{configuration, Error};
 use crate::rekor::apis::ResponseContent;
 use crate::rekor::models::log_entry::LogEntry;
 use serde::{Deserialize, Serialize};
+use std::str::FromStr;
 
 /// struct for typed errors of method [`create_log_entry`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -93,7 +94,7 @@ pub async fn create_log_entry(
     let local_var_content = local_var_resp.text().await?;
 
     if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
-        serde_json::from_str::<LogEntry>(&(parse_response(local_var_content))).map_err(Error::from)
+        LogEntry::from_str(&(parse_response(local_var_content))).map_err(Error::from)
     } else {
         let local_var_entity: Option<CreateLogEntryError> =
             serde_json::from_str(&local_var_content).ok();
@@ -130,7 +131,7 @@ pub async fn get_log_entry_by_index(
     let local_var_content = local_var_resp.text().await?;
 
     if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
-        serde_json::from_str::<LogEntry>(&(parse_response(local_var_content))).map_err(Error::from)
+        LogEntry::from_str(&(parse_response(local_var_content))).map_err(Error::from)
     } else {
         let local_var_entity: Option<GetLogEntryByIndexError> =
             serde_json::from_str(&local_var_content).ok();
@@ -170,7 +171,7 @@ pub async fn get_log_entry_by_uuid(
     let local_var_content = local_var_resp.text().await?;
 
     if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
-        serde_json::from_str::<LogEntry>(&(parse_response(local_var_content))).map_err(Error::from)
+        LogEntry::from_str(&(parse_response(local_var_content))).map_err(Error::from)
     } else {
         let local_var_entity: Option<GetLogEntryByUuidError> =
             serde_json::from_str(&local_var_content).ok();

src/rekor/models/hashedrekord.rs

@@ -37,7 +37,7 @@ impl Hashedrekord {
 }
 
 /// Stores the Signature and Data struct
-#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Spec {
     pub signature: Signature,
@@ -52,7 +52,7 @@ impl Spec {
 }
 
 /// Stores the signature format, signature of the artifact and the PublicKey struct
-#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Signature {
     pub content: String,
@@ -69,7 +69,7 @@ impl Signature {
 }
 
 /// Stores the public key used to sign the artifact
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PublicKey {
     content: String,
@@ -86,7 +86,7 @@ impl PublicKey {
     }
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Data {
     pub hash: Hash,
@@ -98,15 +98,16 @@ impl Data {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[allow(non_camel_case_types)]
 pub enum AlgorithmKind {
+    #[default]
     sha256,
     sha1,
 }
 
 /// Stores the algorithm used to hash the artifact and the value of the hash
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Hash {
     pub algorithm: AlgorithmKind,

src/rekor/models/log_entry.rs

@@ -1,9 +1,12 @@
-use base64::{engine::general_purpose::STANDARD as BASE64_STD_ENGINE, Engine as _};
-use serde::{Deserialize, Serialize};
-
 use crate::errors::SigstoreError;
 use crate::rekor::models::hashedrekord::Spec;
 use crate::rekor::TreeSize;
+use base64::{engine::general_purpose::STANDARD as BASE64_STD_ENGINE, Engine as _};
+
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Error, Value};
+use std::collections::HashMap;
+use std::str::FromStr;
 
 /// Stores the response returned by Rekor after making a new entry
 #[derive(Default, Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
@@ -12,21 +15,31 @@ pub struct LogEntry {
     pub uuid: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub attestation: Option<Attestation>,
-    pub body: String,
+    pub body: Body,
     pub integrated_time: i64,
     pub log_i_d: String,
     pub log_index: i64,
     pub verification: Verification,
 }
 
-impl LogEntry {
-    pub fn decode_body(&self) -> Result<Body, SigstoreError> {
-        let decoded = BASE64_STD_ENGINE.decode(&self.body)?;
-        serde_json::from_slice(&decoded).map_err(SigstoreError::from)
+impl FromStr for LogEntry {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut log_entry_map = serde_json::from_str::<HashMap<&str, Value>>(s)?;
+        log_entry_map.entry("body").and_modify(|body| {
+            let decoded_body = serde_json::to_value(
+                decode_body(body.as_str().expect("Failed to parse Body"))
+                    .expect("Failed to decode Body"),
+            )
+            .expect("Serialization failed");
+            *body = json!(decoded_body);
+        });
+        let log_entry_str = serde_json::to_string(&log_entry_map)?;
+        Ok(serde_json::from_str::<LogEntry>(&log_entry_str).expect("Serialization failed"))
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Default, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Body {
     #[serde(rename = "kind")]
     pub kind: String,
@@ -36,6 +49,11 @@ pub struct Body {
     pub spec: Spec,
 }
 
+fn decode_body(s: &str) -> Result<Body, SigstoreError> {
+    let decoded = BASE64_STD_ENGINE.decode(s)?;
+    serde_json::from_slice(&decoded).map_err(SigstoreError::from)
+}
+
 #[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Attestation {