htsget-config 0.22.1

Used to configure htsget-rs by using a config file or reading environment variables.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Local C4GH key storage.
//!

use crate::error::Result;
use crypt4gh::keys::{get_private_key, get_public_key};
use schemars::JsonSchema;
use serde::Deserialize;
use std::fs;
use std::path::PathBuf;

/// Specify keys from a local file.
#[derive(JsonSchema, Deserialize, Debug, Clone, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
pub struct C4GHLocal {
  /// The path to the key.
  key: PathBuf,
}

impl C4GHLocal {
  /// Create a new local C4GH key storage.
  pub fn new(key: PathBuf) -> Self {
    Self { key }
  }

  /// Get the private key if this is a local private key.
  pub fn into_private_key(self) -> Result<Vec<u8>> {
    Ok(get_private_key(self.key, Ok("".to_string()))?)
  }

  /// Get the public key as an encoded string without decoding the inner base64 data.
  pub fn public_key_encoded(&self) -> Result<Vec<u8>> {
    Ok(fs::read(&self.key)?)
  }

  /// Get the public key if this is a local public key.
  pub fn into_public_key(self) -> Result<Vec<u8>> {
    Ok(get_public_key(self.key)?)
  }
}

#[cfg(test)]
mod tests {
  use crate::config::Config;
  use crate::config::tests::test_config_from_file;
  use crate::storage::Backend;
  use crate::storage::c4gh::tests::copy_c4gh_keys;
  use tempfile::TempDir;

  fn test_c4gh_storage_config<F>(storage_config: &str, test_fn: F)
  where
    F: Fn(Config),
  {
    let tmp = TempDir::new().unwrap();
    let (private_key, server_public_key, client_public_key) = copy_c4gh_keys(tmp.path());

    test_config_from_file(
      &format!(
        r#"
        [[locations]]
        regex = "regex"

        [locations.backend]
        {}

        [locations.backend.keys]
        server.private.kind = "File"
        server.private.key = '{}'
        server.public.kind = "File"
        server.public.key = '{}'
        client.public.kind = "File"
        client.public.key = '{}'
        "#,
        storage_config,
        private_key.to_string_lossy(),
        server_public_key.to_string_lossy(),
        client_public_key.to_string_lossy()
      ),
      |config| {
        test_fn(config);
      },
    );
  }
  #[tokio::test]
  async fn config_local_storage_c4gh() {
    test_c4gh_storage_config(r#"kind = "File""#, |config| {
      assert!(matches!(
            config.locations().first().unwrap().backend(),
            Backend::File(file) if file.keys().is_some()
      ));
    });
  }

  #[cfg(feature = "aws")]
  #[tokio::test]
  async fn config_s3_storage_c4gh() {
    test_c4gh_storage_config(
      r#"
        kind = "S3"
        bucket = "bucket"
        "#,
      |config| {
        assert!(matches!(
              config.locations().first().unwrap().backend(),
              Backend::S3(s3) if s3.keys().is_some()
        ));
      },
    );
  }

  #[cfg(feature = "url")]
  #[tokio::test]
  async fn config_url_storage_c4gh() {
    test_c4gh_storage_config(
      r#"
        kind = "Url"
        url = "https://example.com/"
        response_url = "https://example.com/"
        allow_headers_backend = []
        allow_headers_client = []
        deny_headers_backend = []
        deny_headers_client = []
        "#,
      |config| {
        assert!(matches!(
              config.locations().first().unwrap().backend(),
              Backend::Url(url) if url.keys().is_some()
        ));
      },
    );
  }
}