X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapub%2Fsrc%2Fobjects%2Fcommunity.rs;h=75eb941b1b3af0589cf29782277e4ef6e388c4c9;hb=92568956353f21649ed9aff68b42699c9d036f30;hp=87646e91fb7660c82ec3c3979a9bb5c25ec85910;hpb=6616e89bcf2e25346281732f3d725984197600a8;p=lemmy.git diff --git a/crates/apub/src/objects/community.rs b/crates/apub/src/objects/community.rs index 87646e91..75eb941b 100644 --- a/crates/apub/src/objects/community.rs +++ b/crates/apub/src/objects/community.rs @@ -1,30 +1,35 @@ use crate::{ - check_is_apub_id_valid, - collections::{community_moderators::ApubCommunityModerators, CommunityContext}, - generate_moderators_url, - generate_outbox_url, + check_apub_id_valid, + local_site_data_cached, objects::instance::fetch_instance_actor_for_object, protocol::{ - objects::{group::Group, tombstone::Tombstone, Endpoints}, + objects::{group::Group, Endpoints, LanguageTag}, ImageObject, Source, }, }; -use activitystreams_kinds::actor::GroupType; +use activitypub_federation::{ + config::Data, + kinds::actor::GroupType, + traits::{Actor, Object}, +}; use chrono::NaiveDateTime; -use itertools::Itertools; -use lemmy_api_common::blocking; -use lemmy_apub_lib::{ - object_id::ObjectId, - traits::{ActorType, ApubObject}, +use lemmy_api_common::{ + context::LemmyContext, + utils::{generate_featured_url, generate_moderators_url, generate_outbox_url}, +}; +use lemmy_db_schema::{ + source::{ + actor_language::CommunityLanguage, + community::{Community, CommunityUpdateForm}, + }, + traits::{ApubActor, Crud}, }; -use lemmy_db_schema::{source::community::Community, traits::ApubActor}; -use lemmy_db_views_actor::community_follower_view::CommunityFollowerView; +use lemmy_db_views_actor::structs::CommunityFollowerView; use lemmy_utils::{ - utils::{convert_datetime, markdown_to_html}, - LemmyError, + error::LemmyError, + utils::{markdown::markdown_to_html, time::convert_datetime}, }; -use lemmy_websocket::LemmyContext; use std::ops::Deref; use tracing::debug; use url::Url; @@ -41,141 +46,135 @@ impl Deref for ApubCommunity { impl From for ApubCommunity { fn from(c: Community) -> Self { - ApubCommunity { 0: c } + ApubCommunity(c) } } -#[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 TombstoneType = Tombstone; + type Kind = Group; + type Error = LemmyError; fn last_refreshed_at(&self) -> Option { Some(self.last_refreshed_at) } #[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( - blocking(context.pool(), move |conn| { - Community::read_from_apub_id(conn, &object_id.into()) - }) - .await?? - .map(Into::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> { - blocking(context.pool(), move |conn| { - Community::update_deleted(conn, self.id, true) - }) - .await??; + async fn delete(self, context: &Data) -> Result<(), LemmyError> { + let form = CommunityUpdateForm::builder().deleted(Some(true)).build(); + Community::update(&mut context.pool(), self.id, &form).await?; Ok(()) } #[tracing::instrument(skip_all)] - async fn into_apub(self, _context: &LemmyContext) -> Result { + async fn into_json(self, data: &Data) -> Result { + let community_id = self.id; + 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: self.title.clone(), + name: Some(self.title.clone()), summary: self.description.as_ref().map(|b| markdown_to_html(b)), source: self.description.clone().map(Source::new), icon: self.icon.clone().map(ImageObject::new), image: self.banner.clone().map(ImageObject::new), sensitive: Some(self.nsfw), - moderators: Some(ObjectId::::new( - generate_moderators_url(&self.actor_id)?, - )), + 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), + posting_restricted_to_mods: Some(self.posting_restricted_to_mods), + attributed_to: Some(generate_moderators_url(&self.actor_id)?.into()), }; Ok(group) } - fn to_tombstone(&self) -> Result { - Ok(Tombstone::new(self.actor_id())) - } - #[tracing::instrument(skip_all)] 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 form = Group::into_form(group.clone()); + 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, &mut context.pool()).await?; + + let community = Community::create(&mut context.pool(), &form).await?; + CommunityLanguage::update(&mut context.pool(), languages, community.id).await?; + + let community: ApubCommunity = community.into(); // 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. - let community: ApubCommunity = - blocking(context.pool(), move |conn| Community::upsert(conn, &form)) - .await?? - .into(); - let outbox_data = CommunityContext(community.clone(), context.clone()); - - group - .outbox - .dereference(&outbox_data, context.client(), request_counter) - .await - .map_err(|e| debug!("{}", e)) - .ok(); - - if let Some(moderators) = &group.moderators { - moderators - .dereference(&outbox_data, context.client(), 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 ActorType for ApubCommunity { - fn actor_id(&self) -> Url { - self.actor_id.to_owned().into() +impl Actor for ApubCommunity { + fn id(&self) -> Url { + self.actor_id.inner().clone() } - fn public_key(&self) -> String { - self.public_key.to_owned() + + fn public_key_pem(&self) -> &str { + &self.public_key } - fn private_key(&self) -> Option { - self.private_key.to_owned() + + fn private_key_pem(&self) -> Option { + self.private_key.clone() } - fn inbox_url(&self) -> Url { + fn inbox(&self) -> Url { self.inbox_url.clone().into() } - fn shared_inbox_url(&self) -> Option { - self.shared_inbox_url.clone().map(|s| s.into()) + fn shared_inbox(&self) -> Option { + self.shared_inbox_url.clone().map(Into::into) } } @@ -188,23 +187,15 @@ impl ApubCommunity { ) -> Result, LemmyError> { let id = self.id; - let follows = blocking(context.pool(), move |conn| { - CommunityFollowerView::for_community(conn, 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_is_apub_id_valid(inbox, false, &context.settings()).is_ok()) + .filter(|inbox| check_apub_id_valid(inbox, &local_site_data).is_ok()) .collect(); Ok(inboxes) @@ -213,38 +204,39 @@ 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(); + let context = init_context().await; let site = parse_lemmy_instance(&context).await; let community = parse_lemmy_community(&context).await; @@ -252,7 +244,9 @@ pub(crate) mod tests { assert!(!community.local); assert_eq!(community.description.as_ref().unwrap().len(), 132); - Community::delete(&*context.pool().get().unwrap(), community.id).unwrap(); - Site::delete(&*context.pool().get().unwrap(), site.id).unwrap(); + Community::delete(&mut context.pool(), community.id) + .await + .unwrap(); + Site::delete(&mut context.pool(), site.id).await.unwrap(); } }