unleash-edge 0.2.0

Unleash edge is a proxy for Unleash. It can return both evaluated feature toggles as well as the raw data from Unleash's client API
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

use std::sync::Arc;

use chrono::Duration;
use reqwest::Url;

use crate::{
    auth::token_validator::TokenValidator,
    cli::{CliArgs, EdgeArg, EdgeMode, OfflineArgs},
    http::unleash_client::UnleashClient,
    types::{EdgeResult, EdgeSink, EdgeSource},
};

use super::{
    memory_provider::MemoryProvider, offline_provider::OfflineProvider,
    redis_provider::RedisProvider, repository::DataSourceFacade,
};

pub type DataProviderPair = (Arc<dyn EdgeSource>, Arc<dyn EdgeSink>);

pub struct RepositoryInfo {
    pub source: Arc<dyn EdgeSource>,
    pub sink_info: Option<SinkInfo>,
}

pub struct SinkInfo {
    pub sink: Arc<dyn EdgeSink>,
    pub unleash_client: UnleashClient,
    pub token_validator: Arc<TokenValidator>,
    pub metrics_interval_seconds: u64,
}

fn build_offline(offline_args: OfflineArgs) -> EdgeResult<Arc<dyn EdgeSource>> {
    let provider =
        OfflineProvider::instantiate_provider(offline_args.bootstrap_file, offline_args.tokens)?;

    let source: Arc<dyn EdgeSource> = Arc::new(provider);
    Ok(source)
}

fn build_memory(features_refresh_interval_seconds: Duration) -> EdgeResult<DataProviderPair> {
    let data_source = Arc::new(MemoryProvider::new());
    let facade = Arc::new(DataSourceFacade {
        features_refresh_interval: Some(features_refresh_interval_seconds),
        token_source: data_source.clone(),
        feature_source: data_source.clone(),
        token_sink: data_source.clone(),
        feature_sink: data_source,
    });

    let edge_source: Arc<dyn EdgeSource> = facade.clone();
    let edge_sink: Arc<dyn EdgeSink> = facade;

    Ok((edge_source, edge_sink))
}

fn build_redis(
    redis_url: String,
    features_refresh_interval_seconds: Duration,
) -> EdgeResult<DataProviderPair> {
    let data_source = Arc::new(RedisProvider::new(&redis_url)?);
    let facade = Arc::new(DataSourceFacade {
        token_source: data_source.clone(),
        feature_source: data_source.clone(),
        token_sink: data_source.clone(),
        feature_sink: data_source,
        features_refresh_interval: Some(features_refresh_interval_seconds),
    });

    let edge_source: Arc<dyn EdgeSource> = facade.clone();
    let edge_sink: Arc<dyn EdgeSink> = facade;

    Ok((edge_source, edge_sink))
}

pub async fn build_source_and_sink(args: CliArgs) -> EdgeResult<RepositoryInfo> {
    match args.mode {
        EdgeMode::Offline(offline_args) => {
            let source: Arc<dyn EdgeSource> = build_offline(offline_args)?;
            Ok(RepositoryInfo {
                source,
                sink_info: None,
            })
        }
        EdgeMode::Edge(edge_args) => {
            let refresh_interval = Duration::seconds(edge_args.features_refresh_interval_seconds);
            let arg: EdgeArg = edge_args.clone().into();
            let unleash_client = UnleashClient::from_url(
                Url::parse(edge_args.upstream_url.as_str()).expect("Cannot parse Upstream URL"),
            );
            let (source, sink) = match arg {
                EdgeArg::Redis(redis_url) => build_redis(redis_url, refresh_interval),
                EdgeArg::InMemory => build_memory(refresh_interval),
            }?;

            let token_validator = TokenValidator {
                unleash_client: Arc::new(unleash_client.clone()),
                edge_source: source.clone(),
                edge_sink: sink.clone(),
            };
            if !edge_args.tokens.is_empty() {
                let _ = token_validator.register_tokens(edge_args.tokens).await;
            }
            Ok(RepositoryInfo {
                source,
                sink_info: Some(SinkInfo {
                    sink,
                    unleash_client,
                    token_validator: Arc::new(token_validator),
                    metrics_interval_seconds: edge_args.metrics_interval_seconds,
                }),
            })
        }
    }
}