dns-orchestrator-provider 0.1.2

DNS provider abstraction library for multiple cloud platforms (Cloudflare, Aliyun, DNSPod, Huaweicloud)
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

//! Provider factory functions and metadata.

use std::sync::Arc;

use crate::error::Result;
use crate::traits::DnsProvider;
use crate::types::{ProviderCredentials, ProviderMetadata};

#[cfg(feature = "aliyun")]
use crate::providers::AliyunProvider;
#[cfg(feature = "cloudflare")]
use crate::providers::CloudflareProvider;
#[cfg(feature = "dnspod")]
use crate::providers::DnspodProvider;
#[cfg(feature = "huaweicloud")]
use crate::providers::HuaweicloudProvider;

/// Creates a [`DnsProvider`] instance from the given credentials.
///
/// The concrete provider type is determined by the [`ProviderCredentials`] variant.
/// The returned provider is wrapped in `Arc<dyn DnsProvider>` for easy sharing
/// across async tasks.
///
/// # Examples
///
/// ```rust,no_run
/// use dns_orchestrator_provider::{create_provider, ProviderCredentials};
///
/// let provider = create_provider(ProviderCredentials::Cloudflare {
///     api_token: "your-token".to_string(),
/// }).unwrap();
/// ```
pub fn create_provider(credentials: ProviderCredentials) -> Result<Arc<dyn DnsProvider>> {
    match credentials {
        #[cfg(feature = "cloudflare")]
        ProviderCredentials::Cloudflare { api_token } => {
            Ok(Arc::new(CloudflareProvider::new(api_token)))
        }
        #[cfg(feature = "aliyun")]
        ProviderCredentials::Aliyun {
            access_key_id,
            access_key_secret,
        } => Ok(Arc::new(AliyunProvider::new(
            access_key_id,
            access_key_secret,
        ))),
        #[cfg(feature = "dnspod")]
        ProviderCredentials::Dnspod {
            secret_id,
            secret_key,
        } => Ok(Arc::new(DnspodProvider::new(secret_id, secret_key))),
        #[cfg(feature = "huaweicloud")]
        ProviderCredentials::Huaweicloud {
            access_key_id,
            secret_access_key,
        } => Ok(Arc::new(HuaweicloudProvider::new(
            access_key_id,
            secret_access_key,
        ))),
    }
}

/// Returns metadata for all providers enabled via feature flags.
///
/// Useful for building dynamic UIs that enumerate available providers
/// and their required credential fields.
pub fn get_all_provider_metadata() -> Vec<ProviderMetadata> {
    vec![
        #[cfg(feature = "cloudflare")]
        CloudflareProvider::metadata(),
        #[cfg(feature = "aliyun")]
        AliyunProvider::metadata(),
        #[cfg(feature = "dnspod")]
        DnspodProvider::metadata(),
        #[cfg(feature = "huaweicloud")]
        HuaweicloudProvider::metadata(),
    ]
}