rustic_server 0.4.4

rustic server - a REST server built in rust to use with rustic and restic.
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
132
133
134
135
136
137
138
139

use std::{
    path::PathBuf,
    sync::{Mutex, OnceLock},
};

use axum::{
    body::Body,
    http::{HeaderValue, Method},
};

use tracing::debug;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

use crate::{
    acl::{init_acl, Acl},
    auth::{init_auth, Auth},
    config::{
        default_data_dir, AclSettings, HtpasswdSettings, RusticServerConfig, StorageSettings,
    },
    storage::{init_storage, LocalStorage, Storage},
};

// ------------------------------------------------
// test facility prevent repeated calls in tests
// ------------------------------------------------

/// Common requests, using a password that should
/// be recognized as OK for the repository we are trying to access.
pub fn request_uri_for_test(uri: &str, method: Method) -> axum::http::Request<Body> {
    axum::http::Request::builder()
        .uri(uri)
        .method(method)
        .header(
            "Authorization",
            basic_auth_header_value("rustic", Some("rustic")),
        )
        .body(Body::empty())
        .unwrap()
}

// ------------------------------------------------
// test facility for tracing
// ------------------------------------------------

pub(crate) fn init_tracing() {
    init_mutex();
}

/// When we initialize the global tracing subscriber, this must only happen once.
/// During tests, each test will initialize, to make sure we have at least tracing once.
/// This means that the `init()` call must be robust for this.
/// Since we do not need this in production code, it is located in the test code.
static TRACER: OnceLock<Mutex<usize>> = OnceLock::new();
fn init_mutex() {
    let _ = TRACER.get_or_init(|| {
        tracing_subscriber::registry()
            .with(
                tracing_subscriber::EnvFilter::try_from_default_env()
                    .unwrap_or_else(|_| "RUSTIC_SERVER_LOG_LEVEL=debug".into()),
            )
            .with(tracing_subscriber::fmt::layer())
            .init();
        Mutex::new(0)
    });
}

// ------------------------------------------------
// test facility for creating a minimum test environment
// ------------------------------------------------

pub(crate) fn test_data_path() -> PathBuf {
    PathBuf::from("tests/fixtures/test_data")
}

pub(crate) fn server_config() -> RusticServerConfig {
    let server_config_path = test_data_path().join("rustic_server.toml");
    RusticServerConfig::from_file(&server_config_path).unwrap()
}

pub(crate) fn init_test_environment(server_config: RusticServerConfig) {
    init_tracing();
    init_static_htpasswd(server_config.auth);
    init_static_auth(server_config.acl);
    init_static_storage(server_config.storage);
}

fn init_static_htpasswd(htpasswd_settings: HtpasswdSettings) {
    let auth = Auth::from_config(&htpasswd_settings, test_data_path().join(".htpasswd")).unwrap();
    debug!(?auth, "Loaded Auth.");
    init_auth(auth).unwrap();
}

fn init_static_auth(acl_settings: AclSettings) {
    let acl = Acl::from_config(&acl_settings.clone(), acl_settings.acl_path).unwrap();
    debug!(?acl, "Loaded Acl.");
    init_acl(acl).unwrap();
}

fn init_static_storage(storage_settings: StorageSettings) {
    let local_storage = LocalStorage::init(
        storage_settings
            .data_dir
            .unwrap_or_else(default_data_dir)
            .as_ref(),
    )
    .unwrap();

    debug!(?local_storage, "Loaded Storage.");

    init_storage(local_storage).unwrap();
}

// ------------------------------------------------
// test facility for authentication
// ------------------------------------------------

/// Creates a header value from a username, and password.
/// Copy for the reqwest crate;
pub(crate) fn basic_auth_header_value<U, P>(username: U, password: Option<P>) -> HeaderValue
where
    U: std::fmt::Display,
    P: std::fmt::Display,
{
    use base64::prelude::BASE64_STANDARD;
    use base64::write::EncoderWriter;
    use std::io::Write;

    let mut buf = b"Basic ".to_vec();
    {
        let mut encoder = EncoderWriter::new(&mut buf, &BASE64_STANDARD);
        let _ = write!(encoder, "{}:", username);
        if let Some(password) = password {
            let _ = write!(encoder, "{}", password);
        }
    }
    let mut header = HeaderValue::from_bytes(&buf).expect("base64 is always valid HeaderValue");
    header.set_sensitive(true);
    header
}