spiffe-rs 0.1.0

Rust port of spiffe-go with SPIFFE IDs, bundles, SVIDs, Workload API client, federation helpers, and rustls-based SPIFFE TLS utilities.
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

use crate::bundle::{jwtbundle, x509bundle};
use crate::svid::{jwtsvid, x509svid};
use crate::workloadapi::{
    Client, ClientOption, Context, JWTBundleWatcher, Result, X509BundleWatcher, X509Context,
    X509ContextWatcher,
};
use std::sync::Arc;

pub async fn fetch_x509_svid<I>(ctx: &Context, options: I) -> Result<x509svid::SVID>
where
    I: IntoIterator<Item = Arc<dyn ClientOption>>,
{
    let client = Client::new(options).await?;
    let result = client.fetch_x509_svid(ctx).await;
    client.close().await?;
    result
}

pub async fn fetch_x509_svids<I>(ctx: &Context, options: I) -> Result<Vec<x509svid::SVID>>
where
    I: IntoIterator<Item = Arc<dyn ClientOption>>,
{
    let client = Client::new(options).await?;
    let result = client.fetch_x509_svids(ctx).await;
    client.close().await?;
    result
}

pub async fn fetch_x509_bundles<I>(ctx: &Context, options: I) -> Result<x509bundle::Set>
where
    I: IntoIterator<Item = Arc<dyn ClientOption>>,
{
    let client = Client::new(options).await?;
    let result = client.fetch_x509_bundles(ctx).await;
    client.close().await?;
    result
}

pub async fn fetch_x509_context<I>(ctx: &Context, options: I) -> Result<X509Context>
where
    I: IntoIterator<Item = Arc<dyn ClientOption>>,
{
    let client = Client::new(options).await?;
    let result = client.fetch_x509_context(ctx).await;
    client.close().await?;
    result
}

pub async fn watch_x509_context<I>(
    ctx: &Context,
    watcher: Arc<dyn X509ContextWatcher>,
    options: I,
) -> Result<()>
where
    I: IntoIterator<Item = Arc<dyn ClientOption>>,
{
    let client = Client::new(options).await?;
    let result = client.watch_x509_context(ctx, watcher).await;
    client.close().await?;
    result
}

pub async fn fetch_jwt_svid<I>(ctx: &Context, params: jwtsvid::Params, options: I) -> Result<jwtsvid::SVID>
where
    I: IntoIterator<Item = Arc<dyn ClientOption>>,
{
    let client = Client::new(options).await?;
    let result = client.fetch_jwt_svid(ctx, params).await;
    client.close().await?;
    result
}

pub async fn fetch_jwt_svids<I>(ctx: &Context, params: jwtsvid::Params, options: I) -> Result<Vec<jwtsvid::SVID>>
where
    I: IntoIterator<Item = Arc<dyn ClientOption>>,
{
    let client = Client::new(options).await?;
    let result = client.fetch_jwt_svids(ctx, params).await;
    client.close().await?;
    result
}

pub async fn fetch_jwt_bundles<I>(ctx: &Context, options: I) -> Result<jwtbundle::Set>
where
    I: IntoIterator<Item = Arc<dyn ClientOption>>,
{
    let client = Client::new(options).await?;
    let result = client.fetch_jwt_bundles(ctx).await;
    client.close().await?;
    result
}

pub async fn watch_jwt_bundles<I>(
    ctx: &Context,
    watcher: Arc<dyn JWTBundleWatcher>,
    options: I,
) -> Result<()>
where
    I: IntoIterator<Item = Arc<dyn ClientOption>>,
{
    let client = Client::new(options).await?;
    let result = client.watch_jwt_bundles(ctx, watcher).await;
    client.close().await?;
    result
}

pub async fn watch_x509_bundles<I>(
    ctx: &Context,
    watcher: Arc<dyn X509BundleWatcher>,
    options: I,
) -> Result<()>
where
    I: IntoIterator<Item = Arc<dyn ClientOption>>,
{
    let client = Client::new(options).await?;
    let result = client.watch_x509_bundles(ctx, watcher).await;
    client.close().await?;
    result
}

pub async fn validate_jwt_svid<I>(ctx: &Context, token: &str, audience: &str, options: I) -> Result<jwtsvid::SVID>
where
    I: IntoIterator<Item = Arc<dyn ClientOption>>,
{
    let client = Client::new(options).await?;
    let result = client.validate_jwt_svid(ctx, token, audience).await;
    client.close().await?;
    result
}