use crate::fetcher::post_or_comment::PostOrComment;
use activitypub_federation::config::{Data, UrlVerifier};
use async_trait::async_trait;
-use futures::future::join3;
use lemmy_api_common::context::LemmyContext;
use lemmy_db_schema::{
source::{
local_site::LocalSite,
},
traits::Crud,
- utils::DbPool,
+ utils::{ActualDbPool, DbPool},
};
-use lemmy_utils::error::{LemmyError, LemmyResult};
+use lemmy_utils::error::{LemmyError, LemmyErrorType, LemmyResult};
use moka::future::Cache;
use once_cell::sync::Lazy;
use serde::Serialize;
});
#[derive(Clone)]
-pub struct VerifyUrlData(pub DbPool);
+pub struct VerifyUrlData(pub ActualDbPool);
#[async_trait]
impl UrlVerifier for VerifyUrlData {
async fn verify(&self, url: &Url) -> Result<(), &'static str> {
- let local_site_data = local_site_data_cached(&self.0)
+ let local_site_data = local_site_data_cached(&mut (&self.0).into())
.await
.expect("read local site data");
check_apub_id_valid(url, &local_site_data)?;
blocked_instances: Vec<Instance>,
}
-pub(crate) async fn local_site_data_cached(pool: &DbPool) -> LemmyResult<Arc<LocalSiteData>> {
+pub(crate) async fn local_site_data_cached(
+ pool: &mut DbPool<'_>,
+) -> LemmyResult<Arc<LocalSiteData>> {
static CACHE: Lazy<Cache<(), Arc<LocalSiteData>>> = Lazy::new(|| {
Cache::builder()
.max_capacity(1)
Ok(
CACHE
.try_get_with((), async {
- let (local_site, allowed_instances, blocked_instances) = join3(
- LocalSite::read(pool),
- Instance::allowlist(pool),
- Instance::blocklist(pool),
- )
- .await;
+ let (local_site, allowed_instances, blocked_instances) =
+ lemmy_db_schema::try_join_with_pool!(pool => (
+ // LocalSite may be missing
+ |pool| async {
+ Ok(LocalSite::read(pool).await.ok())
+ },
+ Instance::allowlist,
+ Instance::blocklist
+ ))?;
Ok::<_, diesel::result::Error>(Arc::new(LocalSiteData {
- // LocalSite may be missing
- local_site: local_site.ok(),
- allowed_instances: allowed_instances?,
- blocked_instances: blocked_instances?,
+ local_site,
+ allowed_instances,
+ blocked_instances,
}))
})
.await?,
return Ok(());
}
- let local_site_data = local_site_data_cached(context.pool()).await?;
- check_apub_id_valid(apub_id, &local_site_data).map_err(LemmyError::from_message)?;
+ let local_site_data = local_site_data_cached(&mut context.pool()).await?;
+ check_apub_id_valid(apub_id, &local_site_data).map_err(|err| match err {
+ "Federation disabled" => LemmyErrorType::FederationDisabled,
+ "Domain is blocked" => LemmyErrorType::DomainBlocked,
+ "Domain is not in allowlist" => LemmyErrorType::DomainNotInAllowList,
+ _ => panic!("Could not handle apub error!"),
+ })?;
// Only check allowlist if this is a community, and there are instances in the allowlist
if is_strict && !local_site_data.allowed_instances.is_empty() {
let domain = apub_id.domain().expect("apud id has domain").to_string();
if !allowed_and_local.contains(&domain) {
- return Err(LemmyError::from_message(
- "Federation forbidden by strict allowlist",
- ));
+ return Err(LemmyErrorType::FederationDisabledByStrictAllowList)?;
}
}
Ok(())
sensitive: Some(sensitive),
updated: None,
};
- Activity::create(data.pool(), &form).await?;
+ Activity::create(&mut data.pool(), &form).await?;
Ok(())
}