autoconnect_settings/
app_state.rs1use 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 pub db: Box<dyn DbClient>,
29 pub metrics: Arc<StatsdClient>,
30 pub delivery_metrics: Arc<DeliveryMetrics>,
32 pub http: reqwest::Client,
33
34 pub fernet: MultiFernet,
36 pub clients: Arc<ClientRegistry>,
38 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 .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 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#[cfg(debug_assertions)]
173impl Default for AppState {
174 fn default() -> Self {
175 Self::from_settings(Settings::test_settings()).unwrap()
176 }
177}