Skip to main content

autoconnect_settings/
app_state.rs

1use std::{sync::Arc, time::Duration};
2
3#[cfg(feature = "bigtable")]
4use autopush_common::db::bigtable::BigTableClientImpl;
5#[cfg(feature = "postgres")]
6use autopush_common::db::postgres::PgClientImpl;
7#[cfg(feature = "redis")]
8use autopush_common::db::redis::RedisClientImpl;
9use cadence::StatsdClient;
10use config::ConfigError;
11use fernet::{Fernet, MultiFernet};
12use tokio::sync::RwLock;
13
14use autoconnect_common::{
15    broadcast::BroadcastChangeTracker, megaphone::init_and_spawn_megaphone_updater,
16    registry::ClientRegistry,
17};
18use autopush_common::db::{DbSettings, StorageType, client::DbClient};
19use autopush_common::delivery_metrics::DeliveryMetrics;
20#[cfg(feature = "reliable_report")]
21use autopush_common::reliability::PushReliability;
22
23use crate::{ENV_PREFIX, Settings};
24
25#[derive(Clone)]
26pub struct AppState {
27    /// Handle to the data storage object
28    pub db: Box<dyn DbClient>,
29    pub metrics: Arc<StatsdClient>,
30    /// Prometheus histograms served from the internal router's `/metrics`
31    pub delivery_metrics: Arc<DeliveryMetrics>,
32    pub http: reqwest::Client,
33
34    /// Encryption object for the endpoint URL
35    pub fernet: MultiFernet,
36    /// The connected WebSocket clients
37    pub clients: Arc<ClientRegistry>,
38    /// The Megaphone Broadcast change tracker
39    pub broadcaster: Arc<RwLock<BroadcastChangeTracker>>,
40
41    pub settings: Settings,
42    pub router_url: String,
43    pub endpoint_url: String,
44
45    #[cfg(feature = "reliable_report")]
46    pub reliability: Arc<PushReliability>,
47}
48
49impl AppState {
50    pub fn from_settings(settings: Settings) -> Result<Self, ConfigError> {
51        let crypto_keys = &settings.crypto_keys;
52        if !(crypto_keys.starts_with('[') && crypto_keys.ends_with(']')) {
53            return Err(ConfigError::Message(format!(
54                "Invalid {ENV_PREFIX}_CRYPTO_KEYS"
55            )));
56        }
57        let crypto_keys = &crypto_keys[1..crypto_keys.len() - 1];
58        debug!("🔐 Fernet keys: {:?}", &crypto_keys);
59        let fernets: Vec<Fernet> = crypto_keys
60            .split(',')
61            .map(|s| s.trim().to_string())
62            .map(|key| {
63                Fernet::new(&key).unwrap_or_else(|| panic!("Invalid {ENV_PREFIX}_CRYPTO_KEYS"))
64            })
65            .collect();
66        let fernet = MultiFernet::new(fernets);
67        let metrics = autopush_common::metrics::builder(
68            &settings.statsd_label,
69            &settings.statsd_host,
70            settings.statsd_port,
71        )
72        .map_err(|e| ConfigError::Message(e.to_string()))?
73        // Temporary tag to distinguish from the legacy autopush(connect)
74        .with_tag("autoconnect", "true")
75        .build();
76        let metrics = Arc::new(metrics);
77
78        let db_settings = DbSettings {
79            dsn: settings.db_dsn.clone(),
80            db_settings: settings.db_settings.clone(),
81        };
82        let storage_type = StorageType::from_dsn(&db_settings.dsn);
83
84        #[allow(unused)]
85        let db: Box<dyn DbClient> = match storage_type {
86            #[cfg(feature = "bigtable")]
87            StorageType::BigTable => {
88                let client = BigTableClientImpl::new(metrics.clone(), &db_settings)
89                    .map_err(|e| ConfigError::Message(e.to_string()))?;
90                Box::new(client)
91            }
92            #[cfg(feature = "postgres")]
93            StorageType::Postgres => {
94                let client = PgClientImpl::new(metrics.clone(), &db_settings)
95                    .map_err(|e| ConfigError::Message(e.to_string()))?;
96                Box::new(client)
97            }
98            #[cfg(feature = "redis")]
99            StorageType::Redis => Box::new(
100                RedisClientImpl::new(metrics.clone(), &db_settings)
101                    .map_err(|e| ConfigError::Message(e.to_string()))?,
102            ),
103            _ => panic!(
104                "Invalid Storage type {:?}. Check {}__DB_DSN.",
105                storage_type,
106                ENV_PREFIX.to_uppercase()
107            ),
108        };
109
110        #[cfg(feature = "reliable_report")]
111        let reliability = Arc::new(
112            PushReliability::new(
113                &settings.reliability_dsn,
114                db.clone(),
115                &metrics,
116                settings.reliability_retry_count,
117            )
118            .map_err(|e| {
119                ConfigError::Message(format!("Could not start Reliability connection: {e:?}"))
120            })?,
121        );
122        let http = reqwest::Client::builder()
123            .timeout(Duration::from_secs(1))
124            .pool_max_idle_per_host(settings.pool_max_idle_per_host)
125            .pool_idle_timeout(Duration::from_secs(settings.pool_idle_timeout_secs))
126            .build()
127            .unwrap_or_else(|e| panic!("Error while building reqwest::Client: {e}"));
128        let broadcaster = Arc::new(RwLock::new(BroadcastChangeTracker::new(Vec::new())));
129
130        let router_url = settings.router_url();
131        let endpoint_url = settings.endpoint_url();
132
133        Ok(Self {
134            db,
135            metrics,
136            delivery_metrics: Arc::new(DeliveryMetrics::new()),
137            http,
138            fernet,
139            clients: Arc::new(ClientRegistry::with_channel_capacity(
140                settings.client_channel_capacity,
141            )),
142            broadcaster,
143            settings,
144            router_url,
145            endpoint_url,
146            #[cfg(feature = "reliable_report")]
147            reliability,
148        })
149    }
150
151    /// Initialize the `BroadcastChangeTracker`
152    ///
153    /// Via `autoconnect_common::megaphone::init_and_spawn_megaphone_updater`
154    pub async fn init_and_spawn_megaphone_updater(&self) -> Result<(), ConfigError> {
155        let Some(ref url) = self.settings.megaphone_api_url else {
156            return Ok(());
157        };
158        init_and_spawn_megaphone_updater(
159            &self.broadcaster,
160            &self.http,
161            &self.metrics,
162            url,
163            self.settings.megaphone_poll_interval,
164        )
165        .await
166        .map_err(|e| ConfigError::Message(e.to_string()))?;
167        Ok(())
168    }
169}
170
171/// For tests
172#[cfg(debug_assertions)]
173impl Default for AppState {
174    fn default() -> Self {
175        Self::from_settings(Settings::test_settings()).unwrap()
176    }
177}