refactor(config)!: remove object type and specify keys directly

Author: mmalenic

htsget-config/examples/config-files/c4gh.toml

@@ -9,4 +9,5 @@ regex = ".*"
 substitution_string = "$0"
 
 [resolvers.storage]
-object_type = { private_key = "data/c4gh/keys/bob.sec", recipient_public_key = "data/c4gh/keys/alice.pub" } # pragma: allowlist secret
+private_key = "data/c4gh/keys/bob.sec" # pragma: allowlist secret
+recipient_public_key = "data/c4gh/keys/alice.pub"

htsget-config/src/storage/local.rs

@@ -24,6 +24,7 @@ pub struct LocalStorage {
   authority: Authority,
   local_path: String,
   path_prefix: String,
+  #[serde(flatten)]
   object_type: ObjectType,
 }
 

htsget-config/src/storage/mod.rs

@@ -49,7 +49,7 @@ impl ResolvedId {
 
 /// Specify the storage backend to use as config values.
 #[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(untagged, deny_unknown_fields)]
+#[serde(untagged)]
 #[non_exhaustive]
 pub enum Storage {
   Tagged(TaggedStorageTypes),

htsget-config/src/storage/object/c4gh.rs

@@ -60,3 +60,53 @@ impl From<Crypt4GHError> for Error {
     ParseError(err.to_string())
   }
 }
+
+#[cfg(test)]
+mod tests {
+  use crate::config::tests::test_config_from_file;
+  use crate::storage::Storage;
+  use std::fs::copy;
+  use std::path::PathBuf;
+  use tempfile::TempDir;
+
+  #[test]
+  fn config_storage_c4gh() {
+    let tmp = TempDir::new().unwrap();
+    let private_key = tmp.path().join("bob.sec");
+    let recipient_public_key = tmp.path().join("alice.pub");
+
+    let parent = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+      .parent()
+      .unwrap()
+      .to_path_buf();
+
+    copy(parent.join("data/c4gh/keys/bob.sec"), &private_key).unwrap();
+    copy(
+      parent.join("data/c4gh/keys/alice.pub"),
+      &recipient_public_key,
+    )
+    .unwrap();
+
+    test_config_from_file(
+      &format!(
+        r#"
+        [[resolvers]]
+        regex = "regex"
+
+        [resolvers.storage]
+        private_key = "{}"
+        recipient_public_key = "{}"
+        "#,
+        private_key.to_string_lossy(),
+        recipient_public_key.to_string_lossy()
+      ),
+      |config| {
+        println!("{:?}", config.resolvers().first().unwrap().storage());
+        assert!(matches!(
+            config.resolvers().first().unwrap().storage(),
+            Storage::Local { local_storage } if local_storage.object_type().keys().is_some()
+        ));
+      },
+    );
+  }
+}

htsget-config/src/storage/object/mod.rs

@@ -10,14 +10,15 @@ use serde::{Deserialize, Serialize};
 
 /// An object type, can be regular or Crypt4GH encrypted.
 #[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, Eq)]
-#[serde(untagged, deny_unknown_fields)]
-#[non_exhaustive]
-pub enum ObjectType {
-  #[default]
-  Regular,
+pub struct ObjectType {
+  #[serde(skip_serializing, flatten)]
   #[cfg(feature = "experimental")]
-  C4GH {
-    #[serde(flatten, skip_serializing)]
-    keys: C4GHKeys,
-  },
+  keys: Option<C4GHKeys>,
+}
+
+impl ObjectType {
+  /// Get the C4GH keys.
+  pub fn keys(&self) -> Option<&C4GHKeys> {
+    self.keys.as_ref()
+  }
 }

htsget-storage/src/lib.rs

@@ -35,7 +35,6 @@ use crate::s3::S3Storage;
 use crate::types::{BytesPositionOptions, DataBlock, GetOptions, HeadOptions, RangeUrlOptions};
 #[cfg(feature = "url-storage")]
 use crate::url::UrlStorage;
-use htsget_config::storage::object::ObjectType;
 use htsget_config::types::Scheme;
 
 #[cfg(feature = "experimental")]
@@ -132,16 +131,14 @@ impl Storage {
   /// Create from local storage config.
   pub async fn from_local(config: &LocalStorageConfig) -> Result<Storage> {
     let storage = LocalStorage::new(config.local_path(), config.clone())?;
-    match config.object_type() {
-      ObjectType::Regular => Ok(Storage::new(storage)),
+
+    match config.object_type().keys() {
+      None => Ok(Storage::new(storage)),
       #[cfg(feature = "experimental")]
-      ObjectType::C4GH { keys } => Ok(Storage::new(C4GHStorage::new(
+      Some(keys) => Ok(Storage::new(C4GHStorage::new(
         keys.clone().into_inner(),
         storage,
       ))),
-      _ => Err(StorageError::InternalError(
-        "invalid object type".to_string(),
-      )),
     }
   }