X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapub%2Fsrc%2Fobjects%2Fcommunity.rs;h=75eb941b1b3af0589cf29782277e4ef6e388c4c9;hb=92568956353f21649ed9aff68b42699c9d036f30;hp=9f8cfae60b4eacb51c0e6da404244a7e6bc9f4b6;hpb=62663a9f2e91e3e909d96c921c21bea598a57f91;p=lemmy.git diff --git a/crates/apub/src/objects/community.rs b/crates/apub/src/objects/community.rs index 9f8cfae6..75eb941b 100644 --- a/crates/apub/src/objects/community.rs +++ b/crates/apub/src/objects/community.rs @@ -1,23 +1,19 @@ use crate::{ - check_apub_id_valid_with_strictness, - collections::CommunityContext, - fetch_local_site_data, - local_instance, + check_apub_id_valid, + local_site_data_cached, objects::instance::fetch_instance_actor_for_object, protocol::{ objects::{group::Group, Endpoints, LanguageTag}, ImageObject, Source, }, - ActorType, }; use activitypub_federation::{ - core::object_id::ObjectId, - traits::{Actor, ApubObject}, + config::Data, + kinds::actor::GroupType, + traits::{Actor, Object}, }; -use activitystreams_kinds::actor::GroupType; use chrono::NaiveDateTime; -use itertools::Itertools; use lemmy_api_common::{ context::LemmyContext, utils::{generate_featured_url, generate_moderators_url, generate_outbox_url}, @@ -26,7 +22,6 @@ use lemmy_db_schema::{ source::{ actor_language::CommunityLanguage, community::{Community, CommunityUpdateForm}, - instance::Instance, }, traits::{ApubActor, Crud}, }; @@ -55,11 +50,10 @@ impl From for ApubCommunity { } } -#[async_trait::async_trait(?Send)] -impl ApubObject for ApubCommunity { +#[async_trait::async_trait] +impl Object for ApubCommunity { type DataType = LemmyContext; - type ApubType = Group; - type DbType = Community; + type Kind = Group; type Error = LemmyError; fn last_refreshed_at(&self) -> Option { @@ -67,33 +61,33 @@ impl ApubObject for ApubCommunity { } #[tracing::instrument(skip_all)] - async fn read_from_apub_id( + async fn read_from_id( object_id: Url, - context: &LemmyContext, + context: &Data, ) -> Result, LemmyError> { Ok( - Community::read_from_apub_id(context.pool(), &object_id.into()) + Community::read_from_apub_id(&mut context.pool(), &object_id.into()) .await? .map(Into::into), ) } #[tracing::instrument(skip_all)] - async fn delete(self, context: &LemmyContext) -> Result<(), LemmyError> { + async fn delete(self, context: &Data) -> Result<(), LemmyError> { let form = CommunityUpdateForm::builder().deleted(Some(true)).build(); - Community::update(context.pool(), self.id, &form).await?; + Community::update(&mut context.pool(), self.id, &form).await?; Ok(()) } #[tracing::instrument(skip_all)] - async fn into_apub(self, data: &LemmyContext) -> Result { + async fn into_json(self, data: &Data) -> Result { let community_id = self.id; - let langs = CommunityLanguage::read(data.pool(), community_id).await?; - let language = LanguageTag::new_multiple(langs, data.pool()).await?; + let langs = CommunityLanguage::read(&mut data.pool(), community_id).await?; + let language = LanguageTag::new_multiple(langs, &mut data.pool()).await?; let group = Group { kind: GroupType::Group, - id: ObjectId::new(self.actor_id()), + id: self.id().into(), preferred_username: self.name.clone(), name: Some(self.title.clone()), summary: self.description.as_ref().map(|b| markdown_to_html(b)), @@ -101,15 +95,14 @@ impl ApubObject for ApubCommunity { icon: self.icon.clone().map(ImageObject::new), image: self.banner.clone().map(ImageObject::new), sensitive: Some(self.nsfw), - moderators: Some(generate_moderators_url(&self.actor_id)?.into()), featured: Some(generate_featured_url(&self.actor_id)?.into()), inbox: self.inbox_url.clone().into(), - outbox: ObjectId::new(generate_outbox_url(&self.actor_id)?), + outbox: generate_outbox_url(&self.actor_id)?.into(), followers: self.followers_url.clone().into(), endpoints: self.shared_inbox_url.clone().map(|s| Endpoints { shared_inbox: s.into(), }), - public_key: self.get_public_key(), + public_key: self.public_key(), language, published: Some(convert_datetime(self.published)), updated: self.updated.map(convert_datetime), @@ -123,59 +116,59 @@ impl ApubObject for ApubCommunity { async fn verify( group: &Group, expected_domain: &Url, - context: &LemmyContext, - _request_counter: &mut i32, + context: &Data, ) -> Result<(), LemmyError> { group.verify(expected_domain, context).await } /// Converts a `Group` to `Community`, inserts it into the database and updates moderators. #[tracing::instrument(skip_all)] - async fn from_apub( + async fn from_json( group: Group, - context: &LemmyContext, - request_counter: &mut i32, + context: &Data, ) -> Result { - let apub_id = group.id.inner().clone(); - let instance = Instance::create_from_actor_id(context.pool(), &apub_id).await?; + let instance_id = fetch_instance_actor_for_object(&group.id, context).await?; - let form = Group::into_insert_form(group.clone(), instance.id); - let languages = LanguageTag::to_language_id_multiple(group.language, context.pool()).await?; + let form = Group::into_insert_form(group.clone(), instance_id); + let languages = + LanguageTag::to_language_id_multiple(group.language, &mut context.pool()).await?; - let community = Community::create(context.pool(), &form).await?; - CommunityLanguage::update(context.pool(), languages, community.id).await?; + let community = Community::create(&mut context.pool(), &form).await?; + CommunityLanguage::update(&mut context.pool(), languages, community.id).await?; let community: ApubCommunity = community.into(); - let outbox_data = CommunityContext(community.clone(), context.clone()); // Fetching mods and outbox is not necessary for Lemmy to work, so ignore errors. Besides, // we need to ignore these errors so that tests can work entirely offline. - group - .outbox - .dereference(&outbox_data, local_instance(context).await, request_counter) - .await - .map_err(|e| debug!("{}", e)) - .ok(); - - if let Some(moderators) = group.attributed_to.or(group.moderators) { - moderators - .dereference(&outbox_data, local_instance(context).await, request_counter) - .await - .map_err(|e| debug!("{}", e)) - .ok(); + let fetch_outbox = group.outbox.dereference(&community, context); + + if let Some(moderators) = group.attributed_to { + let fetch_moderators = moderators.dereference(&community, context); + // Fetch mods and outbox in parallel + let res = tokio::join!(fetch_outbox, fetch_moderators); + res.0.map_err(|e| debug!("{}", e)).ok(); + res.1.map_err(|e| debug!("{}", e)).ok(); + } else { + fetch_outbox.await.map_err(|e| debug!("{}", e)).ok(); } - fetch_instance_actor_for_object(community.actor_id(), context, request_counter).await; - Ok(community) } } impl Actor for ApubCommunity { - fn public_key(&self) -> &str { + fn id(&self) -> Url { + self.actor_id.inner().clone() + } + + fn public_key_pem(&self) -> &str { &self.public_key } + fn private_key_pem(&self) -> Option { + self.private_key.clone() + } + fn inbox(&self) -> Url { self.inbox_url.clone().into() } @@ -185,15 +178,6 @@ impl Actor for ApubCommunity { } } -impl ActorType for ApubCommunity { - fn actor_id(&self) -> Url { - self.actor_id.clone().into() - } - fn private_key(&self) -> Option { - self.private_key.clone() - } -} - impl ApubCommunity { /// For a given community, returns the inboxes of all followers. #[tracing::instrument(skip_all)] @@ -203,24 +187,15 @@ impl ApubCommunity { ) -> Result, LemmyError> { let id = self.id; - let local_site_data = fetch_local_site_data(context.pool()).await?; - let follows = CommunityFollowerView::for_community(context.pool(), id).await?; + let local_site_data = local_site_data_cached(&mut context.pool()).await?; + let follows = + CommunityFollowerView::get_community_follower_inboxes(&mut context.pool(), id).await?; let inboxes: Vec = follows .into_iter() - .filter(|f| !f.follower.local) - .map(|f| { - f.follower - .shared_inbox_url - .unwrap_or(f.follower.inbox_url) - .into() - }) - .unique() + .map(Into::into) .filter(|inbox: &Url| inbox.host_str() != Some(&context.settings().hostname)) // Don't send to blocked instances - .filter(|inbox| { - check_apub_id_valid_with_strictness(inbox, false, &local_site_data, context.settings()) - .is_ok() - }) + .filter(|inbox| check_apub_id_valid(inbox, &local_site_data).is_ok()) .collect(); Ok(inboxes) @@ -229,36 +204,36 @@ impl ApubCommunity { #[cfg(test)] pub(crate) mod tests { + #![allow(clippy::unwrap_used)] + #![allow(clippy::indexing_slicing)] + use super::*; use crate::{ objects::{instance::tests::parse_lemmy_instance, tests::init_context}, protocol::tests::file_to_json_object, }; + use activitypub_federation::fetch::collection_id::CollectionId; use lemmy_db_schema::{source::site::Site, traits::Crud}; use serial_test::serial; - pub(crate) async fn parse_lemmy_community(context: &LemmyContext) -> ApubCommunity { + pub(crate) async fn parse_lemmy_community(context: &Data) -> ApubCommunity { + // use separate counter so this doesnt affect tests + let context2 = context.reset_request_count(); let mut json: Group = file_to_json_object("assets/lemmy/objects/group.json").unwrap(); // change these links so they dont fetch over the network - json.moderators = None; json.attributed_to = None; json.outbox = - ObjectId::new(Url::parse("https://enterprise.lemmy.ml/c/tenforward/not_outbox").unwrap()); + CollectionId::parse("https://enterprise.lemmy.ml/c/tenforward/not_outbox").unwrap(); let url = Url::parse("https://enterprise.lemmy.ml/c/tenforward").unwrap(); - let mut request_counter = 0; - ApubCommunity::verify(&json, &url, context, &mut request_counter) - .await - .unwrap(); - let community = ApubCommunity::from_apub(json, context, &mut request_counter) - .await - .unwrap(); + ApubCommunity::verify(&json, &url, &context2).await.unwrap(); + let community = ApubCommunity::from_json(json, &context2).await.unwrap(); // this makes one requests to the (intentionally broken) outbox collection - assert_eq!(request_counter, 1); + assert_eq!(context2.request_count(), 1); community } - #[actix_rt::test] + #[tokio::test] #[serial] async fn test_parse_lemmy_community() { let context = init_context().await; @@ -269,9 +244,9 @@ pub(crate) mod tests { assert!(!community.local); assert_eq!(community.description.as_ref().unwrap().len(), 132); - Community::delete(context.pool(), community.id) + Community::delete(&mut context.pool(), community.id) .await .unwrap(); - Site::delete(context.pool(), site.id).await.unwrap(); + Site::delete(&mut context.pool(), site.id).await.unwrap(); } }