Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
7.9 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

use crate::{
    api::{
        client::{AdminApiClient, ApiResultExt},
        types::{
            AccountIdentityMode, AccountIdentitySettings, InstanceConfigResponse, PremiumBranding,
            ReportReasonEntry,
        },
    },
    config::AdminConfig,
    sso::{self, ProviderMetadata},
};
use std::{
    sync::{Arc, Mutex},
    time::{Duration, Instant},
};

const PREMIUM_BRANDING_TTL: Duration = Duration::from_secs(60);
const ACCOUNT_IDENTITY_TTL: Duration = Duration::from_secs(60);
const ACCOUNT_IDENTITY_RETRY_TTL: Duration = Duration::from_secs(10);
const SSO_DISCOVERY_TTL: Duration = Duration::from_secs(3600);

#[derive(Clone)]
pub struct AppState {
    inner: Arc<AppStateInner>,
}

struct AppStateInner {
    pub config: AdminConfig,
    pub http_client: reqwest::Client,
    sso_http_client: reqwest::Client,
    premium_branding: Mutex<Option<(Instant, PremiumBranding)>>,
    account_identity: Mutex<Option<(Instant, AccountIdentitySettings)>>,
    report_reasons: Mutex<Option<Arc<[ReportReasonEntry]>>>,
    sso_provider: Mutex<Option<(Instant, ProviderMetadata)>>,
}

impl AppState {
    pub fn new(config: AdminConfig) -> Self {
        let http_client = reqwest::Client::builder()
            .user_agent(format!("FluxerAdmin/{} (Rust)", config.build_version))
            .build()
            .expect("failed to create HTTP client");
        let sso_http_client = sso::http_client(&config.build_version);
        Self {
            inner: Arc::new(AppStateInner {
                config,
                http_client,
                sso_http_client,
                premium_branding: Mutex::new(None),
                account_identity: Mutex::new(None),
                report_reasons: Mutex::new(None),
                sso_provider: Mutex::new(None),
            }),
        }
    }

    pub fn config(&self) -> &AdminConfig {
        &self.inner.config
    }

    pub fn http_client(&self) -> &reqwest::Client {
        &self.inner.http_client
    }

    pub fn sso_http_client(&self) -> &reqwest::Client {
        &self.inner.sso_http_client
    }

    pub fn cached_premium_branding(&self) -> Option<PremiumBranding> {
        let cache = self
            .inner
            .premium_branding
            .lock()
            .unwrap_or_else(|poisoned| poisoned.into_inner());
        cache
            .as_ref()
            .filter(|(fetched_at, _)| fetched_at.elapsed() < PREMIUM_BRANDING_TTL)
            .map(|(_, branding)| branding.clone())
    }

    pub fn remember_premium_branding(&self, branding: PremiumBranding) {
        *self
            .inner
            .premium_branding
            .lock()
            .unwrap_or_else(|poisoned| poisoned.into_inner()) = Some((Instant::now(), branding));
    }

    pub fn remember_instance_config_branding(&self, instance_config: &InstanceConfigResponse) {
        self.merge_instance_config_branding(PremiumBranding::from_instance_config(instance_config));
    }

    fn merge_instance_config_branding(&self, branding: PremiumBranding) {
        let mut cache = self
            .inner
            .premium_branding
            .lock()
            .unwrap_or_else(|poisoned| poisoned.into_inner());
        if let Some((fetched_at, previous)) = cache.as_ref() {
            let branding = PremiumBranding {
                discovery_enabled: previous.discovery_enabled,
                ..branding
            };
            *cache = Some((*fetched_at, branding));
        }
    }

    pub async fn premium_branding(&self, client: &AdminApiClient) -> Option<PremiumBranding> {
        if let Some(branding) = self.cached_premium_branding() {
            return Some(branding);
        }
        let branding = PremiumBranding::from_discovery(
            &client
                .get_instance_premium_discovery()
                .await
                .log_error("load premium branding")?,
        );
        self.remember_premium_branding(branding.clone());
        Some(branding)
    }

    pub async fn self_hosted_branding(&self) -> Option<PremiumBranding> {
        if !self.config().self_hosted {
            return None;
        }
        self.premium_branding(&AdminApiClient::anonymous(
            self.http_client(),
            self.config(),
        ))
        .await
    }

    pub fn forget_instance_settings(&self) {
        *self
            .inner
            .premium_branding
            .lock()
            .unwrap_or_else(|poisoned| poisoned.into_inner()) = None;
        *self
            .inner
            .account_identity
            .lock()
            .unwrap_or_else(|poisoned| poisoned.into_inner()) = None;
    }

    pub async fn account_identity(&self, client: &AdminApiClient) -> AccountIdentityMode {
        self.account_identity_settings(client).await.mode
    }

    pub async fn account_identity_settings(
        &self,
        client: &AdminApiClient,
    ) -> AccountIdentitySettings {
        if !self.config().self_hosted {
            return AccountIdentitySettings::default();
        }
        let previous = *self
            .inner
            .account_identity
            .lock()
            .unwrap_or_else(|poisoned| poisoned.into_inner());
        if let Some((expires_at, settings)) = previous
            && Instant::now() < expires_at
        {
            return settings;
        }
        let (settings, ttl) = match client
            .get_instance_account_identity()
            .await
            .log_error("load account identity mode")
        {
            Some(settings) => (settings, ACCOUNT_IDENTITY_TTL),
            None => (
                previous.map_or(AccountIdentitySettings::default(), |(_, settings)| settings),
                ACCOUNT_IDENTITY_RETRY_TTL,
            ),
        };
        *self
            .inner
            .account_identity
            .lock()
            .unwrap_or_else(|poisoned| poisoned.into_inner()) =
            Some((Instant::now() + ttl, settings));
        settings
    }

    pub async fn sso_provider(&self) -> Option<ProviderMetadata> {
        let sso = self.config().sso.as_ref()?;
        let cached = self
            .inner
            .sso_provider
            .lock()
            .unwrap_or_else(|poisoned| poisoned.into_inner())
            .as_ref()
            .filter(|(fetched_at, _)| fetched_at.elapsed() < SSO_DISCOVERY_TTL)
            .map(|(_, metadata)| metadata.clone());
        if let Some(metadata) = cached {
            return Some(metadata);
        }
        let metadata = match sso::discover(self.sso_http_client(), sso).await {
            Ok(metadata) => metadata,
            Err(error) => {
                tracing::error!(%error, issuer = %sso.issuer, "SSO provider discovery failed");
                return None;
            }
        };
        *self
            .inner
            .sso_provider
            .lock()
            .unwrap_or_else(|poisoned| poisoned.into_inner()) =
            Some((Instant::now(), metadata.clone()));
        Some(metadata)
    }

    pub async fn report_reasons(
        &self,
        client: &AdminApiClient,
    ) -> Option<Arc<[ReportReasonEntry]>> {
        if let Some(reasons) = self.cached_report_reasons() {
            return Some(reasons);
        }
        let reasons: Arc<[ReportReasonEntry]> = client
            .list_report_reasons()
            .await
            .log_error("load report reasons")?
            .reasons
            .into();
        *self
            .inner
            .report_reasons
            .lock()
            .unwrap_or_else(|poisoned| poisoned.into_inner()) = Some(reasons.clone());
        Some(reasons)
    }

    fn cached_report_reasons(&self) -> Option<Arc<[ReportReasonEntry]>> {
        self.inner
            .report_reasons
            .lock()
            .unwrap_or_else(|poisoned| poisoned.into_inner())
            .clone()
    }
}

impl axum::extract::FromRef<AppState> for AdminConfig {
    fn from_ref(state: &AppState) -> Self {
        state.inner.config.clone()
    }
}