oneio 0.21.0

OneIO is a Rust library that provides unified simple IO interface for reading and writing to and from data files from different sources and compressions.
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

//! Crypto provider initialization for rustls.
//!
//! This module provides a helper function to ensure that rustls has a default
//! crypto provider installed. It attempts to use AWS-LC first, falling back
//! to ring if necessary.

use crate::OneIoError;

/// Ensures that a default crypto provider is installed for rustls.
///
/// This function checks if a crypto provider is already installed, and if not,
/// attempts to install one automatically:
///
/// 1. First tries AWS-LC if available (when rustls is compiled with aws_lc_rs support)
/// 2. Falls back to ring if AWS-LC is not available or installation fails
/// 3. Returns an error if no provider is available
///
/// This should be called early in your application startup, or before any HTTPS/S3
/// operations. It's safe to call multiple times - if a provider is already installed,
/// this function does nothing.
#[cfg(feature = "rustls")]
pub fn ensure_default_provider() -> Result<(), OneIoError> {
    // Check if a provider is already installed
    if rustls_sys::crypto::CryptoProvider::get_default().is_some() {
        return Ok(());
    }

    // Try AWS-LC first (if available)
    match rustls_sys::crypto::aws_lc_rs::default_provider().install_default() {
        Ok(_) => return Ok(()),
        Err(_) => {
            // If installation failed because a provider is already installed, that's OK
            if rustls_sys::crypto::CryptoProvider::get_default().is_some() {
                return Ok(());
            }
            // AWS-LC installation failed for another reason, try ring
        }
    }

    // Try ring as fallback
    match rustls_sys::crypto::ring::default_provider().install_default() {
        Ok(_) => Ok(()),
        Err(e) => {
            // If installation failed because a provider is already installed, that's OK
            if rustls_sys::crypto::CryptoProvider::get_default().is_some() {
                return Ok(());
            }
            // Both failed and no provider is installed
            Err(OneIoError::NotSupported(format!(
                "Failed to install rustls crypto provider: {:?}",
                e
            )))
        }
    }
}

/// Ensures that a default crypto provider is installed for rustls.
///
/// This is a no-op when rustls feature is not enabled.
#[cfg(not(feature = "rustls"))]
pub fn ensure_default_provider() -> Result<(), OneIoError> {
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_ensure_default_provider() {
        let result = ensure_default_provider();
        assert!(result.is_ok(), "ensure_default_provider should succeed");
    }

    #[cfg(feature = "rustls")]
    #[test]
    fn test_provider_installed() {
        ensure_default_provider().unwrap();
        assert!(
            rustls_sys::crypto::CryptoProvider::get_default().is_some(),
            "A crypto provider should be installed"
        );
    }
}