Implement instance actor (#1798)

[lemmy.git] / crates / apub / src / activities / mod.rs

diff --git a/crates/apub/src/activities/mod.rs b/crates/apub/src/activities/mod.rs
index a6c7537647b54a3f1ac606ecc42529e17c2bae6d..343633c8f104169f51b68740fa4436985df7f411 100644 (file)
--- a/crates/apub/src/activities/mod.rs
+++ b/crates/apub/src/activities/mod.rs
@@ -5,8 +5,7 @@ use crate::{
   insert_activity,
   objects::{community::ApubCommunity, person::ApubPerson},
 };
-use activitystreams::public;
-use anyhow::anyhow;
+use activitystreams_kinds::public;
 use lemmy_api_common::blocking;
 use lemmy_apub_lib::{
   activity_queue::send_activity,
@@ -21,11 +20,12 @@ use lemmy_db_views_actor::{
 };
 use lemmy_utils::{settings::structs::Settings, LemmyError};
 use lemmy_websocket::LemmyContext;
-use log::info;
 use serde::Serialize;
+use tracing::info;
 use url::{ParseError, Url};
 use uuid::Uuid;
 
+pub mod block;
 pub mod comment;
 pub mod community;
 pub mod deletion;
@@ -36,36 +36,43 @@ pub mod voting;
 
 /// Checks that the specified Url actually identifies a Person (by fetching it), and that the person
 /// doesn't have a site ban.
+#[tracing::instrument(skip_all)]
 async fn verify_person(
   person_id: &ObjectId<ApubPerson>,
   context: &LemmyContext,
   request_counter: &mut i32,
 ) -> Result<(), LemmyError> {
-  let person = person_id.dereference(context, request_counter).await?;
+  let person = person_id
+    .dereference(context, context.client(), request_counter)
+    .await?;
   if person.banned {
-    return Err(anyhow!("Person {} is banned", person_id).into());
+    let error = LemmyError::from(anyhow::anyhow!("Person {} is banned", person_id));
+    return Err(error.with_message("banned"));
   }
   Ok(())
 }
 
 /// Fetches the person and community to verify their type, then checks if person is banned from site
 /// or community.
+#[tracing::instrument(skip_all)]
 pub(crate) async fn verify_person_in_community(
   person_id: &ObjectId<ApubPerson>,
   community: &ApubCommunity,
   context: &LemmyContext,
   request_counter: &mut i32,
 ) -> Result<(), LemmyError> {
-  let person = person_id.dereference(context, request_counter).await?;
+  let person = person_id
+    .dereference(context, context.client(), request_counter)
+    .await?;
   if person.banned {
-    return Err(anyhow!("Person is banned from site").into());
+    return Err(LemmyError::from_message("Person is banned from site"));
   }
   let person_id = person.id;
   let community_id = community.id;
   let is_banned =
     move |conn: &'_ _| CommunityPersonBanView::get(conn, person_id, community_id).is_ok();
   if blocking(context.pool(), is_banned).await? {
-    return Err(anyhow!("Person is banned from community").into());
+    return Err(LemmyError::from_message("Person is banned from community"));
   }
 
   Ok(())
@@ -80,6 +87,7 @@ fn verify_activity(id: &Url, actor: &Url, settings: &Settings) -> Result<(), Lem
 /// Verify that the actor is a community mod. This check is only run if the community is local,
 /// because in case of remote communities, admins can also perform mod actions. As admin status
 /// is not federated, we cant verify their actions remotely.
+#[tracing::instrument(skip_all)]
 pub(crate) async fn verify_mod_action(
   actor_id: &ObjectId<ApubPerson>,
   community: &ApubCommunity,
@@ -87,7 +95,9 @@ pub(crate) async fn verify_mod_action(
   request_counter: &mut i32,
 ) -> Result<(), LemmyError> {
   if community.local {
-    let actor = actor_id.dereference(context, request_counter).await?;
+    let actor = actor_id
+      .dereference(context, context.client(), request_counter)
+      .await?;
 
     // Note: this will also return true for admins in addition to mods, but as we dont know about
     //       remote admins, it doesnt make any difference.
@@ -98,7 +108,7 @@ pub(crate) async fn verify_mod_action(
     })
     .await?;
     if !is_mod_or_admin {
-      return Err(anyhow!("Not a mod").into());
+      return Err(LemmyError::from_message("Not a mod"));
     }
   }
   Ok(())
@@ -111,21 +121,23 @@ fn verify_add_remove_moderator_target(
   community: &ApubCommunity,
 ) -> Result<(), LemmyError> {
   if target != &generate_moderators_url(&community.actor_id)?.into() {
-    return Err(anyhow!("Unkown target url").into());
+    return Err(LemmyError::from_message("Unkown target url"));
   }
   Ok(())
 }
 
 pub(crate) fn verify_is_public(to: &[Url], cc: &[Url]) -> Result<(), LemmyError> {
-  if !to.contains(&public()) && !cc.contains(&public()) {
-    return Err(anyhow!("Object is not public").into());
+  if ![to, cc].iter().any(|set| set.contains(&public())) {
+    return Err(LemmyError::from_message("Object is not public"));
   }
   Ok(())
 }
 
 pub(crate) fn check_community_deleted_or_removed(community: &Community) -> Result<(), LemmyError> {
   if community.deleted || community.removed {
-    Err(anyhow!("New post or comment cannot be created in deleted or removed community").into())
+    Err(LemmyError::from_message(
+      "New post or comment cannot be created in deleted or removed community",
+    ))
   } else {
     Ok(())
   }
@@ -146,6 +158,7 @@ where
   Url::parse(&id)
 }
 
+#[tracing::instrument(skip_all)]
 async fn send_lemmy_activity<T: Serialize>(
   context: &LemmyContext,
   activity: &T,
@@ -171,19 +184,14 @@ async fn send_lemmy_activity<T: Serialize>(
 
   let serialised_activity = serde_json::to_string(&activity)?;
 
-  insert_activity(
-    activity_id,
-    serialised_activity.clone(),
-    true,
-    sensitive,
-    context.pool(),
-  )
-  .await?;
+  let object_value = serde_json::to_value(&activity)?;
+  insert_activity(activity_id, object_value, true, sensitive, context.pool()).await?;
 
   send_activity(
-    serialised_activity,
+    activity_id,
     actor,
     inboxes,
+    serialised_activity,
     context.client(),
     context.activity_queue(),
   )