LemmyNet/lemmy
2
0
Fork 0
mirror of https://github.com/LemmyNet/lemmy.git synced 2024-11-22 20:31:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #1897 from LemmyNet/mastodon-compat

Browse source 
Mastodon compat
This commit is contained in:
Dessalines 2021-11-17 09:12:01 -05:00 committed by GitHub
commit 5f6419ff76
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
67 changed files with 660 additions and 595 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Cargo.lock generated
View file

@ -1962,7 +1962,7 @@ dependencies = [
"diesel",
"lazy_static",
"lemmy_api_common",
"lemmy_apub_lib",
"lemmy_apub",
"lemmy_db_schema",
"lemmy_db_views",
"lemmy_db_views_actor",

11
crates/api/src/site.rs
View file

@ -11,10 +11,13 @@ use lemmy_api_common::{
site::*,
};
use lemmy_apub::{
fetcher::search::{search_by_apub_id, SearchableObjects},
get_actor_id_from_name,
fetcher::{
search::{search_by_apub_id, SearchableObjects},
webfinger::webfinger_resolve,
},
objects::community::ApubCommunity,
EndpointType,
};
use lemmy_apub_lib::webfinger::WebfingerType;
use lemmy_db_schema::{
from_opt_str_to_opt_enum,
newtypes::PersonId,
@ -175,7 +178,7 @@ impl Perform for Search {
let search_type: SearchType = from_opt_str_to_opt_enum(&data.type_).unwrap_or(SearchType::All);
let community_id = data.community_id;
let community_actor_id = if let Some(name) = &data.community_name {
get_actor_id_from_name(WebfingerType::Group, name, context)
webfinger_resolve::<ApubCommunity>(name, EndpointType::Community, context, &mut 0)
.await
.ok()
} else {

1
crates/api_crud/src/comment/create.rs
View file

@ -152,6 +152,7 @@ impl PerformCrud for CreateComment {
&local_user_view.person.clone().into(),
CreateOrUpdateType::Create,
context,
&mut 0,
)
.await?;
let object = PostOrComment::Comment(Box::new(apub_comment));

60
crates/api_crud/src/comment/delete.rs
View file

@ -7,7 +7,7 @@ use lemmy_api_common::{
get_local_user_view_from_jwt,
is_mod_or_admin,
};
use lemmy_apub::activities::deletion::{send_apub_delete, send_apub_remove};
use lemmy_apub::activities::deletion::{send_apub_delete, send_apub_remove, DeletableObjects};
use lemmy_db_schema::{
source::{
comment::Comment,
@ -69,20 +69,6 @@ impl PerformCrud for DeleteComment {
.await?
.map_err(|e| ApiError::err("couldnt_update_comment", e))?;
// Send the apub message
let community = blocking(context.pool(), move |conn| {
Community::read(conn, orig_comment.post.community_id)
})
.await??;
send_apub_delete(
&local_user_view.person.clone().into(),
&community.clone().into(),
updated_comment.ap_id.clone().into(),
deleted,
context,
)
.await?;
let post_id = updated_comment.post_id;
let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
let recipient_ids = send_local_notifs(
@ -95,6 +81,20 @@ impl PerformCrud for DeleteComment {
)
.await?;
// Send the apub message
let community = blocking(context.pool(), move |conn| {
Community::read(conn, orig_comment.post.community_id)
})
.await??;
send_apub_delete(
&local_user_view.person.clone().into(),
&community.clone().into(),
DeletableObjects::Comment(Box::new(updated_comment.into())),
deleted,
context,
)
.await?;
send_comment_ws_message(
data.comment_id,
UserOperationCrud::DeleteComment,
@ -162,21 +162,6 @@ impl PerformCrud for RemoveComment {
})
.await??;
// Send the apub message
let community = blocking(context.pool(), move |conn| {
Community::read(conn, orig_comment.post.community_id)
})
.await??;
send_apub_remove(
&local_user_view.person.clone().into(),
&community.into(),
updated_comment.ap_id.clone().into(),
data.reason.clone().unwrap_or_else(|| "".to_string()),
removed,
context,
)
.await?;
let post_id = updated_comment.post_id;
let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
let recipient_ids = send_local_notifs(
@ -189,6 +174,21 @@ impl PerformCrud for RemoveComment {
)
.await?;
// Send the apub message
let community = blocking(context.pool(), move |conn| {
Community::read(conn, orig_comment.post.community_id)
})
.await??;
send_apub_remove(
&local_user_view.person.clone().into(),
&community.into(),
DeletableObjects::Comment(Box::new(updated_comment.into())),
data.reason.clone().unwrap_or_else(|| "".to_string()),
removed,
context,
)
.await?;
send_comment_ws_message(
data.comment_id,
UserOperationCrud::RemoveComment,

9
crates/api_crud/src/comment/read.rs
View file

@ -1,8 +1,11 @@
use crate::PerformCrud;
use actix_web::web::Data;
use lemmy_api_common::{blocking, comment::*, get_local_user_view_from_jwt_opt};
use lemmy_apub::get_actor_id_from_name;
use lemmy_apub_lib::webfinger::WebfingerType;
use lemmy_apub::{
fetcher::webfinger::webfinger_resolve,
objects::community::ApubCommunity,
EndpointType,
};
use lemmy_db_schema::{
from_opt_str_to_opt_enum,
traits::DeleteableOrRemoveable,
@ -36,7 +39,7 @@ impl PerformCrud for GetComments {
let community_id = data.community_id;
let community_actor_id = if let Some(name) = &data.community_name {
get_actor_id_from_name(WebfingerType::Group, name, context)
webfinger_resolve::<ApubCommunity>(name, EndpointType::Community, context, &mut 0)
.await
.ok()
} else {

1
crates/api_crud/src/comment/update.rs
View file

@ -91,6 +91,7 @@ impl PerformCrud for EditComment {
&local_user_view.person.into(),
CreateOrUpdateType::Update,
context,
&mut 0,
)
.await?;

6
crates/api_crud/src/community/delete.rs
View file

@ -1,7 +1,7 @@
use crate::PerformCrud;
use actix_web::web::Data;
use lemmy_api_common::{blocking, community::*, get_local_user_view_from_jwt, is_admin};
use lemmy_apub::activities::deletion::{send_apub_delete, send_apub_remove};
use lemmy_apub::activities::deletion::{send_apub_delete, send_apub_remove, DeletableObjects};
use lemmy_db_schema::{
source::{
community::Community,
@ -51,7 +51,7 @@ impl PerformCrud for DeleteCommunity {
send_apub_delete(
&local_user_view.person.clone().into(),
&updated_community.clone().into(),
updated_community.actor_id.clone().into(),
DeletableObjects::Community(Box::new(updated_community.into())),
deleted,
context,
)
@ -111,7 +111,7 @@ impl PerformCrud for RemoveCommunity {
send_apub_remove(
&local_user_view.person.clone().into(),
&updated_community.clone().into(),
updated_community.actor_id.clone().into(),
DeletableObjects::Community(Box::new(updated_community.into())),
data.reason.clone().unwrap_or_else(|| "".to_string()),
removed,
context,

11
crates/api_crud/src/community/read.rs
View file

@ -1,8 +1,12 @@
use crate::PerformCrud;
use actix_web::web::Data;
use lemmy_api_common::{blocking, community::*, get_local_user_view_from_jwt_opt};
use lemmy_apub::{get_actor_id_from_name, objects::community::ApubCommunity};
use lemmy_apub_lib::{object_id::ObjectId, webfinger::WebfingerType};
use lemmy_apub::{
fetcher::webfinger::webfinger_resolve,
objects::community::ApubCommunity,
EndpointType,
};
use lemmy_apub_lib::object_id::ObjectId;
use lemmy_db_schema::{
from_opt_str_to_opt_enum,
traits::DeleteableOrRemoveable,
@ -35,7 +39,8 @@ impl PerformCrud for GetCommunity {
None => {
let name = data.name.to_owned().unwrap_or_else(|| "main".to_string());
let community_actor_id =
get_actor_id_from_name(WebfingerType::Group, &name, context).await?;
webfinger_resolve::<ApubCommunity>(&name, EndpointType::Community, context, &mut 0)
.await?;
ObjectId::<ApubCommunity>::new(community_actor_id)
.dereference(context, &mut 0)

6
crates/api_crud/src/post/delete.rs
View file

@ -8,7 +8,7 @@ use lemmy_api_common::{
is_mod_or_admin,
post::*,
};
use lemmy_apub::activities::deletion::{send_apub_delete, send_apub_remove};
use lemmy_apub::activities::deletion::{send_apub_delete, send_apub_remove, DeletableObjects};
use lemmy_db_schema::{
source::{
community::Community,
@ -70,7 +70,7 @@ impl PerformCrud for DeletePost {
send_apub_delete(
&local_user_view.person.clone().into(),
&community.into(),
updated_post.ap_id.into(),
DeletableObjects::Post(Box::new(updated_post.into())),
deleted,
context,
)
@ -146,7 +146,7 @@ impl PerformCrud for RemovePost {
send_apub_remove(
&local_user_view.person.clone().into(),
&community.into(),
updated_post.ap_id.into(),
DeletableObjects::Post(Box::new(updated_post.into())),
data.reason.clone().unwrap_or_else(|| "".to_string()),
removed,
context,

9
crates/api_crud/src/post/read.rs
View file

@ -1,8 +1,11 @@
use crate::PerformCrud;
use actix_web::web::Data;
use lemmy_api_common::{blocking, get_local_user_view_from_jwt_opt, mark_post_as_read, post::*};
use lemmy_apub::get_actor_id_from_name;
use lemmy_apub_lib::webfinger::WebfingerType;
use lemmy_apub::{
fetcher::webfinger::webfinger_resolve,
objects::community::ApubCommunity,
EndpointType,
};
use lemmy_db_schema::{
from_opt_str_to_opt_enum,
traits::DeleteableOrRemoveable,
@ -138,7 +141,7 @@ impl PerformCrud for GetPosts {
let limit = data.limit;
let community_id = data.community_id;
let community_actor_id = if let Some(name) = &data.community_name {
get_actor_id_from_name(WebfingerType::Group, name, context)
webfinger_resolve::<ApubCommunity>(name, EndpointType::Community, context, &mut 0)
.await
.ok()
} else {

11
crates/api_crud/src/user/read.rs
View file

@ -1,8 +1,12 @@
use crate::PerformCrud;
use actix_web::web::Data;
use lemmy_api_common::{blocking, get_local_user_view_from_jwt_opt, person::*};
use lemmy_apub::{get_actor_id_from_name, objects::person::ApubPerson};
use lemmy_apub_lib::{object_id::ObjectId, webfinger::WebfingerType};
use lemmy_apub::{
fetcher::webfinger::webfinger_resolve,
objects::person::ApubPerson,
EndpointType,
};
use lemmy_apub_lib::object_id::ObjectId;
use lemmy_db_schema::{from_opt_str_to_opt_enum, SortType};
use lemmy_db_views::{comment_view::CommentQueryBuilder, post_view::PostQueryBuilder};
use lemmy_db_views_actor::{
@ -42,7 +46,8 @@ impl PerformCrud for GetPersonDetails {
.username
.to_owned()
.unwrap_or_else(|| "admin".to_string());
let actor_id = get_actor_id_from_name(WebfingerType::Person, &name, context).await?;
let actor_id =
webfinger_resolve::<ApubPerson>(&name, EndpointType::Person, context, &mut 0).await?;
let person = ObjectId::<ApubPerson>::new(actor_id)
.dereference(context, &mut 0)

8
crates/apub/assets/lemmy/activities/create_or_update/create_note.json
View file

@ -23,7 +23,13 @@
"http://enterprise.lemmy.ml/c/main",
"http://ds9.lemmy.ml/u/lemmy_alpha"
],
"tag": [],
"tag": [
{
"href": "http://ds9.lemmy.ml/u/lemmy_alpha",
"type": "Mention",
"name": "@lemmy_alpha@ds9.lemmy.ml"
}
],
"type": "Create",
"id": "http://ds9.lemmy.ml/activities/create/1e77d67c-44ac-45ed-bf2a-460e21f60236"
}

5
crates/apub/assets/lemmy/activities/deletion/delete_page.json
View file

@ -3,7 +3,10 @@
"to": [
"https://www.w3.org/ns/activitystreams#Public"
],
"object": "http://ds9.lemmy.ml/post/1",
"object": {
"id": "http://ds9.lemmy.ml/post/1",
"type": "Tombstone"
},
"cc": [
"http://enterprise.lemmy.ml/c/main"
],

5
crates/apub/assets/lemmy/activities/deletion/remove_note.json
View file

@ -3,7 +3,10 @@
"to": [
"https://www.w3.org/ns/activitystreams#Public"
],
"object": "http://ds9.lemmy.ml/comment/1",
"object": {
"id": "http://ds9.lemmy.ml/comment/1",
"type": "Tombstone"
},
"cc": [
"http://enterprise.lemmy.ml/c/main"
],

5
crates/apub/assets/lemmy/activities/deletion/undo_delete_page.json
View file

@ -8,7 +8,10 @@
"to": [
"https://www.w3.org/ns/activitystreams#Public"
],
"object": "http://ds9.lemmy.ml/post/1",
"object": {
"id": "http://ds9.lemmy.ml/post/1",
"type": "Tombstone"
},
"cc": [
"http://enterprise.lemmy.ml/c/main"
],

5
crates/apub/assets/lemmy/activities/deletion/undo_remove_note.json
View file

@ -8,7 +8,10 @@
"to": [
"https://www.w3.org/ns/activitystreams#Public"
],
"object": "http://ds9.lemmy.ml/comment/1",
"object": {
"id": "http://ds9.lemmy.ml/comment/1",
"type": "Tombstone"
},
"cc": [
"http://enterprise.lemmy.ml/c/main"
],

6
crates/apub/assets/lemmy/activities/following/accept.json
View file

@ -1,13 +1,7 @@
{
"actor": "http://enterprise.lemmy.ml/c/main",
"to": [
"http://ds9.lemmy.ml/u/lemmy_alpha"
],
"object": {
"actor": "http://ds9.lemmy.ml/u/lemmy_alpha",
"to": [
"http://enterprise.lemmy.ml/c/main"
],
"object": "http://enterprise.lemmy.ml/c/main",
"type": "Follow",
"id": "http://ds9.lemmy.ml/activities/follow/6abcd50b-b8ca-4952-86b0-a6dd8cc12866"

3
crates/apub/assets/lemmy/activities/following/follow.json
View file

@ -1,8 +1,5 @@
{
"actor": "http://ds9.lemmy.ml/u/lemmy_alpha",
"to": [
"http://enterprise.lemmy.ml/c/main"
],
"object": "http://enterprise.lemmy.ml/c/main",
"type": "Follow",
"id": "http://ds9.lemmy.ml/activities/follow/6abcd50b-b8ca-4952-86b0-a6dd8cc12866"

6
crates/apub/assets/lemmy/activities/following/undo_follow.json
View file

@ -1,13 +1,7 @@
{
"actor": "http://ds9.lemmy.ml/u/lemmy_alpha",
"to": [
"http://enterprise.lemmy.ml/c/main"
],
"object": {
"actor": "http://ds9.lemmy.ml/u/lemmy_alpha",
"to": [
"http://enterprise.lemmy.ml/c/main"
],
"object": "http://enterprise.lemmy.ml/c/main",
"type": "Follow",
"id": "http://ds9.lemmy.ml/activities/follow/dc2f1bc5-f3a0-4daa-a46b-428cbfbd023c"

11
crates/apub/assets/lemmy/objects/note.json
View file

@ -3,6 +3,10 @@
"type": "Note",
"attributedTo": "https://enterprise.lemmy.ml/u/picard",
"to": ["https://www.w3.org/ns/activitystreams#Public"],
"cc": [
"https://enterprise.lemmy.ml/c/tenforward",
"https://enterprise.lemmy.ml/u/picard"
],
"inReplyTo": "https://enterprise.lemmy.ml/post/55143",
"content": "<p>first comment!</p>\n",
"mediaType": "text/html",
@ -10,6 +14,13 @@
"content": "first comment!",
"mediaType": "text/markdown"
},
"tag": [
{
"href": "https://enterprise.lemmy.ml/u/picard",
"type": "Mention",
"name": "@picard@enterprise.lemmy.ml"
}
],
"published": "2021-03-01T13:42:43.966208+00:00",
"updated": "2021-03-01T13:43:03.955787+00:00"
}

6
crates/apub/assets/smithereen/activities/create_note.json
View file

@ -16,10 +16,12 @@
"content": "<p>So does this federate now?</p>",
"inReplyTo": "https://ds9.lemmy.ml/post/1723",
"published": "2021-11-09T11:42:35Z",
"tag": {
"tag": [
{
"type": "Mention",
"href": "https://ds9.lemmy.ml/u/nutomic"
},
}
],
"url": "https://friends.grishka.me/posts/66561",
"to": [
"https://www.w3.org/ns/activitystreams#Public"

6
crates/apub/assets/smithereen/objects/note.json
View file

@ -5,10 +5,12 @@
"content": "<p>So does this federate now?</p>",
"inReplyTo": "https://ds9.lemmy.ml/post/1723",
"published": "2021-11-09T11:42:35Z",
"tag": {
"tag": [
{
"type": "Mention",
"href": "https://ds9.lemmy.ml/u/nutomic"
},
}
],
"url": "https://friends.grishka.me/posts/66561",
"to": [
"https://www.w3.org/ns/activitystreams#Public"

30
crates/apub/src/activities/comment/create_or_update.rs
View file

@ -1,8 +1,8 @@
use crate::{
activities::{
check_community_deleted_or_removed,
comment::{collect_non_local_mentions, get_notif_recipients},
community::{announce::GetCommunity, send_to_community},
comment::get_notif_recipients,
community::{announce::GetCommunity, send_activity_in_community},
generate_activity_id,
verify_activity,
verify_is_public,
@ -12,7 +12,7 @@ use crate::{
objects::{comment::ApubComment, community::ApubCommunity, person::ApubPerson},
protocol::activities::{create_or_update::comment::CreateOrUpdateComment, CreateOrUpdateType},
};
use activitystreams::public;
use activitystreams::{link::LinkExt, public};
use lemmy_api_common::{blocking, check_post_deleted_or_removed};
use lemmy_apub_lib::{
data::Data,
@ -33,6 +33,7 @@ impl CreateOrUpdateComment {
actor: &ApubPerson,
kind: CreateOrUpdateType,
context: &LemmyContext,
request_counter: &mut i32,
) -> Result<(), LemmyError> {
// TODO: might be helpful to add a comment method to retrieve community directly
let post_id = comment.post_id;
@ -48,21 +49,34 @@ impl CreateOrUpdateComment {
kind.clone(),
&context.settings().get_protocol_and_hostname(),
)?;
let maa = collect_non_local_mentions(&comment, &community, context).await?;
let note = comment.into_apub(context).await?;
let create_or_update = CreateOrUpdateComment {
actor: ObjectId::new(actor.actor_id()),
to: vec![public()],
object: comment.into_apub(context).await?,
cc: maa.ccs,
tag: maa.tags,
cc: note.cc.clone(),
tag: note.tag.clone(),
object: note,
kind,
id: id.clone(),
unparsed: Default::default(),
};
let tagged_users: Vec<ObjectId<ApubPerson>> = create_or_update
.tag
.iter()
.map(|t| t.href())
.flatten()
.map(|t| ObjectId::new(t.clone()))
.collect();
let mut inboxes = vec![];
for t in tagged_users {
let person = t.dereference(context, request_counter).await?;
inboxes.push(person.shared_inbox_or_inbox_url());
}
let activity = AnnouncableActivities::CreateOrUpdateComment(create_or_update);
send_to_community(activity, &id, actor, &community, maa.inboxes, context).await
send_activity_in_community(activity, &id, actor, &community, inboxes, context).await
}
}

132
crates/apub/src/activities/comment/mod.rs
View file

@ -1,26 +1,13 @@
use crate::objects::{comment::ApubComment, community::ApubCommunity, person::ApubPerson};
use activitystreams::{
base::BaseExt,
link::{LinkExt, Mention},
};
use anyhow::anyhow;
use itertools::Itertools;
use crate::objects::person::ApubPerson;
use lemmy_api_common::blocking;
use lemmy_apub_lib::{object_id::ObjectId, traits::ActorType, webfinger::WebfingerResponse};
use lemmy_apub_lib::object_id::ObjectId;
use lemmy_db_schema::{
newtypes::LocalUserId,
source::{comment::Comment, person::Person, post::Post},
source::{comment::Comment, post::Post},
traits::Crud,
DbPool,
};
use lemmy_utils::{
request::{retry, RecvError},
utils::{scrape_text_for_mentions, MentionData},
LemmyError,
};
use lemmy_utils::{utils::scrape_text_for_mentions, LemmyError};
use lemmy_websocket::{send::send_local_notifs, LemmyContext};
use log::debug;
use url::Url;
pub mod create_or_update;
@ -42,114 +29,3 @@ async fn get_notif_recipients(
let mentions = scrape_text_for_mentions(&comment.content);
send_local_notifs(mentions, comment, &*actor, &post, true, context).await
}
pub struct MentionsAndAddresses {
pub ccs: Vec<Url>,
pub inboxes: Vec<Url>,
pub tags: Vec<Mention>,
}
/// This takes a comment, and builds a list of to_addresses, inboxes,
/// and mention tags, so they know where to be sent to.
/// Addresses are the persons / addresses that go in the cc field.
pub async fn collect_non_local_mentions(
comment: &ApubComment,
community: &ApubCommunity,
context: &LemmyContext,
) -> Result<MentionsAndAddresses, LemmyError> {
let parent_creator = get_comment_parent_creator(context.pool(), comment).await?;
let mut addressed_ccs: Vec<Url> = vec![community.actor_id(), parent_creator.actor_id()];
// Note: dont include community inbox here, as we send to it separately with `send_to_community()`
let mut inboxes = vec![parent_creator.shared_inbox_or_inbox_url()];
// Add the mention tag
let mut tags = Vec::new();
// Get the person IDs for any mentions
let mentions = scrape_text_for_mentions(&comment.content)
.into_iter()
// Filter only the non-local ones
.filter(|m| !m.is_local(&context.settings().hostname))
.collect::<Vec<MentionData>>();
for mention in &mentions {
// TODO should it be fetching it every time?
if let Ok(actor_id) = fetch_webfinger_url(mention, context).await {
let actor_id: ObjectId<ApubPerson> = ObjectId::new(actor_id);
debug!("mention actor_id: {}", actor_id);
addressed_ccs.push(actor_id.to_string().parse()?);
let mention_person = actor_id.dereference(context, &mut 0).await?;
inboxes.push(mention_person.shared_inbox_or_inbox_url());
let mut mention_tag = Mention::new();
mention_tag
.set_href(actor_id.into())
.set_name(mention.full_name());
tags.push(mention_tag);
}
}
let inboxes = inboxes.into_iter().unique().collect();
Ok(MentionsAndAddresses {
ccs: addressed_ccs,
inboxes,
tags,
})
}
/// Returns the apub ID of the person this comment is responding to. Meaning, in case this is a
/// top-level comment, the creator of the post, otherwise the creator of the parent comment.
async fn get_comment_parent_creator(
pool: &DbPool,
comment: &Comment,
) -> Result<ApubPerson, LemmyError> {
let parent_creator_id = if let Some(parent_comment_id) = comment.parent_id {
let parent_comment =
blocking(pool, move |conn| Comment::read(conn, parent_comment_id)).await??;
parent_comment.creator_id
} else {
let parent_post_id = comment.post_id;
let parent_post = blocking(pool, move |conn| Post::read(conn, parent_post_id)).await??;
parent_post.creator_id
};
Ok(
blocking(pool, move |conn| Person::read(conn, parent_creator_id))
.await??
.into(),
)
}
/// Turns a person id like `@name@example.com` into an apub ID, like `https://example.com/user/name`,
/// using webfinger.
async fn fetch_webfinger_url(
mention: &MentionData,
context: &LemmyContext,
) -> Result<Url, LemmyError> {
let fetch_url = format!(
"{}://{}/.well-known/webfinger?resource=acct:{}@{}",
context.settings().get_protocol_string(),
mention.domain,
mention.name,
mention.domain
);
debug!("Fetching webfinger url: {}", &fetch_url);
let response = retry(|| context.client().get(&fetch_url).send()).await?;
let res: WebfingerResponse = response
.json()
.await
.map_err(|e| RecvError(e.to_string()))?;
let link = res
.links
.iter()
.find(|l| l.type_.eq(&Some("application/activity+json".to_string())))
.ok_or_else(|| anyhow!("No application/activity+json link found."))?;
link
.href
.to_owned()
.ok_or_else(|| anyhow!("No href found.").into())
}

8
crates/apub/src/activities/community/add_mod.rs
View file

@ -1,6 +1,10 @@
use crate::{
activities::{
community::{announce::GetCommunity, get_community_from_moderators_url, send_to_community},
community::{
announce::GetCommunity,
get_community_from_moderators_url,
send_activity_in_community,
},
generate_activity_id,
verify_activity,
verify_add_remove_moderator_target,
@ -51,7 +55,7 @@ impl AddMod {
let activity = AnnouncableActivities::AddMod(add);
let inboxes = vec![added_mod.shared_inbox_or_inbox_url()];
send_to_community(activity, &id, actor, community, inboxes, context).await
send_activity_in_community(activity, &id, actor, community, inboxes, context).await
}
}

12
crates/apub/src/activities/community/announce.rs
View file

@ -14,7 +14,6 @@ use lemmy_apub_lib::{
};
use lemmy_utils::LemmyError;
use lemmy_websocket::LemmyContext;
use url::Url;
#[async_trait::async_trait(?Send)]
pub(crate) trait GetCommunity {
@ -48,13 +47,10 @@ impl AnnounceActivity {
pub async fn send(
object: AnnouncableActivities,
community: &ApubCommunity,
additional_inboxes: Vec<Url>,
context: &LemmyContext,
) -> Result<(), LemmyError> {
let announce = AnnounceActivity::new(object.clone(), community, context)?;
let inboxes = community
.get_follower_inboxes(additional_inboxes.clone(), context)
.await?;
let inboxes = community.get_follower_inboxes(context).await?;
send_lemmy_activity(
context,
&announce,
@ -65,9 +61,9 @@ impl AnnounceActivity {
)
.await?;
// Pleroma (and likely Mastodon) can't handle activities like Announce/Create/Page, so for
// compatibility, we also send Announce/Page and Announce/Note (for new and updated
// posts/comments).
// Pleroma (and likely Mastodon) can't handle activities like Announce/Create/Page. So for
// compatibility to allow them to follow Lemmy communities, we also send Announce/Page and
// Announce/Note (for new and updated posts/comments).
use AnnouncableActivities::*;
let object = match object {
CreateOrUpdatePost(c) => Page(c.object),

4
crates/apub/src/activities/community/block_user.rs
View file

@ -1,6 +1,6 @@
use crate::{
activities::{
community::{announce::GetCommunity, send_to_community},
community::{announce::GetCommunity, send_activity_in_community},
generate_activity_id,
verify_activity,
verify_is_public,
@ -63,7 +63,7 @@ impl BlockUserFromCommunity {
let activity = AnnouncableActivities::BlockUserFromCommunity(block);
let inboxes = vec![target.shared_inbox_or_inbox_url()];
send_to_community(activity, &block_id, actor, community, inboxes, context).await
send_activity_in_community(activity, &block_id, actor, community, inboxes, context).await
}
}

15
crates/apub/src/activities/community/mod.rs
View file

@ -1,7 +1,6 @@
use crate::{
activities::send_lemmy_activity,
activity_lists::AnnouncableActivities,
insert_activity,
objects::community::ApubCommunity,
protocol::activities::community::announce::AnnounceActivity,
};
@ -18,23 +17,19 @@ pub mod report;
pub mod undo_block_user;
pub mod update;
pub(crate) async fn send_to_community<T: ActorType>(
pub(crate) async fn send_activity_in_community<T: ActorType>(
activity: AnnouncableActivities,
activity_id: &Url,
actor: &T,
community: &ApubCommunity,
additional_inboxes: Vec<Url>,
mut inboxes: Vec<Url>,
context: &LemmyContext,
) -> Result<(), LemmyError> {
// if this is a local community, we need to do an announce from the community instead
let object_value = serde_json::to_value(&activity)?;
if community.local {
insert_activity(activity_id, object_value, true, false, context.pool()).await?;
AnnounceActivity::send(activity, community, additional_inboxes, context).await?;
} else {
let mut inboxes = additional_inboxes;
inboxes.push(community.shared_inbox_or_inbox_url());
send_lemmy_activity(context, &activity, activity_id, actor, inboxes, false).await?;
if community.local {
AnnounceActivity::send(activity, community, context).await?;
}
Ok(())

8
crates/apub/src/activities/community/remove_mod.rs
View file

@ -1,6 +1,10 @@
use crate::{
activities::{
community::{announce::GetCommunity, get_community_from_moderators_url, send_to_community},
community::{
announce::GetCommunity,
get_community_from_moderators_url,
send_activity_in_community,
},
generate_activity_id,
verify_activity,
verify_add_remove_moderator_target,
@ -51,7 +55,7 @@ impl RemoveMod {
let activity = AnnouncableActivities::RemoveMod(remove);
let inboxes = vec![removed_mod.shared_inbox_or_inbox_url()];
send_to_community(activity, &id, actor, community, inboxes, context).await
send_activity_in_community(activity, &id, actor, community, inboxes, context).await
}
}

4
crates/apub/src/activities/community/undo_block_user.rs
View file

@ -1,6 +1,6 @@
use crate::{
activities::{
community::{announce::GetCommunity, send_to_community},
community::{announce::GetCommunity, send_activity_in_community},
generate_activity_id,
verify_activity,
verify_is_public,
@ -53,7 +53,7 @@ impl UndoBlockUserFromCommunity {
let activity = AnnouncableActivities::UndoBlockUserFromCommunity(undo);
let inboxes = vec![target.shared_inbox_or_inbox_url()];
send_to_community(activity, &id, actor, community, inboxes, context).await
send_activity_in_community(activity, &id, actor, community, inboxes, context).await
}
}

4
crates/apub/src/activities/community/update.rs
View file

@ -1,6 +1,6 @@
use crate::{
activities::{
community::{announce::GetCommunity, send_to_community},
community::{announce::GetCommunity, send_activity_in_community},
generate_activity_id,
verify_activity,
verify_is_public,
@ -46,7 +46,7 @@ impl UpdateCommunity {
};
let activity = AnnouncableActivities::UpdateCommunity(update);
send_to_community(activity, &id, actor, &community, vec![], context).await
send_activity_in_community(activity, &id, actor, &community, vec![], context).await
}
}

31
crates/apub/src/activities/deletion/delete.rs
View file

@ -1,6 +1,6 @@
use crate::{
activities::{
community::{announce::GetCommunity, send_to_community},
community::{announce::GetCommunity, send_activity_in_community},
deletion::{receive_delete_action, verify_delete_activity, DeletableObjects},
generate_activity_id,
verify_activity,
@ -50,11 +50,11 @@ impl ActivityHandler for Delete {
context: &Data<LemmyContext>,
request_counter: &mut i32,
) -> Result<(), LemmyError> {
verify_is_public(&self.to, &self.cc)?;
verify_is_public(&self.to, &[])?;
verify_activity(&self.id, self.actor.inner(), &context.settings())?;
let community = self.get_community(context, request_counter).await?;
verify_delete_activity(
&self.object,
&self.object.id,
&self.actor,
&community,
self.summary.is_some(),
@ -78,9 +78,16 @@ impl ActivityHandler for Delete {
} else {
Some(reason)
};
receive_remove_action(&self.actor, &self.object, reason, context, request_counter).await
receive_remove_action(
&self.actor,
&self.object.id,
reason,
context,
request_counter,
)
.await
} else {
receive_delete_action(&self.object, &self.actor, true, context, request_counter).await
receive_delete_action(&self.object.id, &self.actor, true, context, request_counter).await
}
}
}
@ -88,16 +95,14 @@ impl ActivityHandler for Delete {
impl Delete {
pub(in crate::activities::deletion) fn new(
actor: &ApubPerson,
community: &ApubCommunity,
object_id: Url,
object: DeletableObjects,
summary: Option<String>,
context: &LemmyContext,
) -> Result<Delete, LemmyError> {
Ok(Delete {
actor: ObjectId::new(actor.actor_id()),
to: vec![public()],
object: object_id,
cc: vec![community.actor_id()],
object: object.to_tombstone()?,
kind: DeleteType::Delete,
summary,
id: generate_activity_id(
@ -110,15 +115,15 @@ impl Delete {
pub(in crate::activities::deletion) async fn send(
actor: &ApubPerson,
community: &ApubCommunity,
object_id: Url,
object: DeletableObjects,
summary: Option<String>,
context: &LemmyContext,
) -> Result<(), LemmyError> {
let delete = Delete::new(actor, community, object_id, summary, context)?;
let delete = Delete::new(actor, object, summary, context)?;
let delete_id = delete.id.clone();
let activity = AnnouncableActivities::Delete(delete);
send_to_community(activity, &delete_id, actor, community, vec![], context).await
send_activity_in_community(activity, &delete_id, actor, community, vec![], context).await
}
}
@ -201,7 +206,7 @@ impl GetCommunity for Delete {
context: &LemmyContext,
_request_counter: &mut i32,
) -> Result<ApubCommunity, LemmyError> {
let community_id = match DeletableObjects::read_from_db(&self.object, context).await? {
let community_id = match DeletableObjects::read_from_db(&self.object.id, context).await? {
DeletableObjects::Community(c) => c.id,
DeletableObjects::Comment(c) => {
let post = blocking(context.pool(), move |conn| Post::read(conn, c.post_id)).await??;

33
crates/apub/src/activities/deletion/mod.rs
View file

@ -1,14 +1,13 @@
use crate::{
activities::{verify_mod_action, verify_person_in_community},
objects::{comment::ApubComment, community::ApubCommunity, person::ApubPerson, post::ApubPost},
protocol::activities::deletion::{delete::Delete, undo_delete::UndoDelete},
protocol::{
activities::deletion::{delete::Delete, undo_delete::UndoDelete},
objects::tombstone::Tombstone,
},
};
use lemmy_api_common::blocking;
use lemmy_apub_lib::{
object_id::ObjectId,
traits::{ActorType, ApubObject},
verify::verify_domains_match,
};
use lemmy_apub_lib::{object_id::ObjectId, traits::ApubObject, verify::verify_domains_match};
use lemmy_db_schema::source::{comment::Comment, community::Community, post::Post};
use lemmy_utils::LemmyError;
use lemmy_websocket::{
@ -24,14 +23,14 @@ pub mod undo_delete;
pub async fn send_apub_delete(
actor: &ApubPerson,
community: &ApubCommunity,
object_id: Url,
object: DeletableObjects,
deleted: bool,
context: &LemmyContext,
) -> Result<(), LemmyError> {
if deleted {
Delete::send(actor, community, object_id, None, context).await
Delete::send(actor, community, object, None, context).await
} else {
UndoDelete::send(actor, community, object_id, None, context).await
UndoDelete::send(actor, community, object, None, context).await
}
}
@ -40,15 +39,15 @@ pub async fn send_apub_delete(
pub async fn send_apub_remove(
actor: &ApubPerson,
community: &ApubCommunity,
object_id: Url,
object: DeletableObjects,
reason: String,
removed: bool,
context: &LemmyContext,
) -> Result<(), LemmyError> {
if removed {
Delete::send(actor, community, object_id, Some(reason), context).await
Delete::send(actor, community, object, Some(reason), context).await
} else {
UndoDelete::send(actor, community, object_id, Some(reason), context).await
UndoDelete::send(actor, community, object, Some(reason), context).await
}
}
@ -74,6 +73,14 @@ impl DeletableObjects {
}
Err(diesel::NotFound.into())
}
pub(crate) fn to_tombstone(&self) -> Result<Tombstone, LemmyError> {
match self {
DeletableObjects::Community(c) => c.to_tombstone(),
DeletableObjects::Comment(c) => c.to_tombstone(),
DeletableObjects::Post(p) => p.to_tombstone(),
}
}
}
pub(in crate::activities) async fn verify_delete_activity(
@ -153,7 +160,7 @@ async fn receive_delete_action(
DeletableObjects::Community(community) => {
if community.local {
let mod_ = actor.dereference(context, request_counter).await?;
let object = community.actor_id();
let object = DeletableObjects::Community(community.clone());
send_apub_delete(&mod_, &community.clone(), object, true, context).await?;
}

14
crates/apub/src/activities/deletion/undo_delete.rs
View file

@ -1,6 +1,6 @@
use crate::{
activities::{
community::{announce::GetCommunity, send_to_community},
community::{announce::GetCommunity, send_activity_in_community},
deletion::{receive_delete_action, verify_delete_activity, DeletableObjects},
generate_activity_id,
verify_activity,
@ -40,7 +40,7 @@ impl ActivityHandler for UndoDelete {
self.object.verify(context, request_counter).await?;
let community = self.get_community(context, request_counter).await?;
verify_delete_activity(
&self.object.object,
&self.object.object.id,
&self.actor,
&community,
self.object.summary.is_some(),
@ -57,10 +57,10 @@ impl ActivityHandler for UndoDelete {
request_counter: &mut i32,
) -> Result<(), LemmyError> {
if self.object.summary.is_some() {
UndoDelete::receive_undo_remove_action(&self.object.object, context).await
UndoDelete::receive_undo_remove_action(&self.object.object.id, context).await
} else {
receive_delete_action(
&self.object.object,
&self.object.object.id,
&self.actor,
false,
context,
@ -75,11 +75,11 @@ impl UndoDelete {
pub(in crate::activities::deletion) async fn send(
actor: &ApubPerson,
community: &ApubCommunity,
object_id: Url,
object: DeletableObjects,
summary: Option<String>,
context: &LemmyContext,
) -> Result<(), LemmyError> {
let object = Delete::new(actor, community, object_id, summary, context)?;
let object = Delete::new(actor, object, summary, context)?;
let id = generate_activity_id(
UndoType::Undo,
@ -96,7 +96,7 @@ impl UndoDelete {
};
let activity = AnnouncableActivities::UndoDelete(undo);
send_to_community(activity, &id, actor, community, vec![], context).await
send_activity_in_community(activity, &id, actor, community, vec![], context).await
}
pub(in crate::activities) async fn receive_undo_remove_action(

14
crates/apub/src/activities/following/accept.rs
View file

@ -28,7 +28,6 @@ impl AcceptFollowCommunity {
.await?;
let accept = AcceptFollowCommunity {
actor: ObjectId::new(community.actor_id()),
to: [ObjectId::new(person.actor_id())],
object: follow,
kind: AcceptType::Accept,
id: generate_activity_id(
@ -52,8 +51,7 @@ impl ActivityHandler for AcceptFollowCommunity {
request_counter: &mut i32,
) -> Result<(), LemmyError> {
verify_activity(&self.id, self.actor.inner(), &context.settings())?;
verify_urls_match(self.to[0].inner(), self.object.actor.inner())?;
verify_urls_match(self.actor.inner(), self.object.to[0].inner())?;
verify_urls_match(self.actor.inner(), self.object.object.inner())?;
self.object.verify(context, request_counter).await?;
Ok(())
}
@ -63,11 +61,15 @@ impl ActivityHandler for AcceptFollowCommunity {
context: &Data<LemmyContext>,
request_counter: &mut i32,
) -> Result<(), LemmyError> {
let actor = self.actor.dereference(context, request_counter).await?;
let to = self.to[0].dereference(context, request_counter).await?;
let person = self.actor.dereference(context, request_counter).await?;
let community = self
.object
.actor
.dereference(context, request_counter)
.await?;
// This will throw an error if no follow was requested
blocking(context.pool(), move |conn| {
CommunityFollower::follow_accepted(conn, actor.id, to.id)
CommunityFollower::follow_accepted(conn, person.id, community.id)
})
.await??;

11
crates/apub/src/activities/following/follow.rs
View file

@ -15,7 +15,6 @@ use lemmy_apub_lib::{
data::Data,
object_id::ObjectId,
traits::{ActivityHandler, ActorType},
verify::verify_urls_match,
};
use lemmy_db_schema::{
source::community::{CommunityFollower, CommunityFollowerForm},
@ -32,7 +31,6 @@ impl FollowCommunity {
) -> Result<FollowCommunity, LemmyError> {
Ok(FollowCommunity {
actor: ObjectId::new(actor.actor_id()),
to: [ObjectId::new(community.actor_id())],
object: ObjectId::new(community.actor_id()),
kind: FollowType::Follow,
id: generate_activity_id(
@ -72,9 +70,8 @@ impl ActivityHandler for FollowCommunity {
request_counter: &mut i32,
) -> Result<(), LemmyError> {
verify_activity(&self.id, self.actor.inner(), &context.settings())?;
verify_urls_match(self.to[0].inner(), self.object.inner())?;
verify_person(&self.actor, context, request_counter).await?;
let community = self.to[0].dereference(context, request_counter).await?;
let community = self.object.dereference(context, request_counter).await?;
verify_person_in_community(&self.actor, &community, context, request_counter).await?;
Ok(())
}
@ -84,11 +81,11 @@ impl ActivityHandler for FollowCommunity {
context: &Data<LemmyContext>,
request_counter: &mut i32,
) -> Result<(), LemmyError> {
let actor = self.actor.dereference(context, request_counter).await?;
let community = self.to[0].dereference(context, request_counter).await?;
let person = self.actor.dereference(context, request_counter).await?;
let community = self.object.dereference(context, request_counter).await?;
let community_follower_form = CommunityFollowerForm {
community_id: community.id,
person_id: actor.id,
person_id: person.id,
pending: false,
};

12
crates/apub/src/activities/following/undo_follow.rs
View file

@ -27,7 +27,6 @@ impl UndoFollowCommunity {
let object = FollowCommunity::new(actor, community, context)?;
let undo = UndoFollowCommunity {
actor: ObjectId::new(actor.actor_id()),
to: [ObjectId::new(community.actor_id())],
object,
kind: UndoType::Undo,
id: generate_activity_id(
@ -50,7 +49,6 @@ impl ActivityHandler for UndoFollowCommunity {
request_counter: &mut i32,
) -> Result<(), LemmyError> {
verify_activity(&self.id, self.actor.inner(), &context.settings())?;
verify_urls_match(self.to[0].inner(), self.object.object.inner())?;
verify_urls_match(self.actor.inner(), self.object.actor.inner())?;
verify_person(&self.actor, context, request_counter).await?;
self.object.verify(context, request_counter).await?;
@ -62,12 +60,16 @@ impl ActivityHandler for UndoFollowCommunity {
context: &Data<LemmyContext>,
request_counter: &mut i32,
) -> Result<(), LemmyError> {
let actor = self.actor.dereference(context, request_counter).await?;
let community = self.to[0].dereference(context, request_counter).await?;
let person = self.actor.dereference(context, request_counter).await?;
let community = self
.object
.object
.dereference(context, request_counter)
.await?;
let community_follower_form = CommunityFollowerForm {
community_id: community.id,
person_id: actor.id,
person_id: person.id,
pending: false,
};

5
crates/apub/src/activities/mod.rs
View file

@ -117,7 +117,7 @@ fn verify_add_remove_moderator_target(
}
pub(crate) fn verify_is_public(to: &[Url], cc: &[Url]) -> Result<(), LemmyError> {
if !to.contains(&public()) && !cc.contains(&public()) {
if ![to, cc].iter().any(|set| set.contains(&public())) {
return Err(anyhow!("Object is not public").into());
}
Ok(())
@ -175,9 +175,10 @@ async fn send_lemmy_activity<T: Serialize>(
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(),
)

4
crates/apub/src/activities/post/create_or_update.rs
View file

@ -1,7 +1,7 @@
use crate::{
activities::{
check_community_deleted_or_removed,
community::{announce::GetCommunity, send_to_community},
community::{announce::GetCommunity, send_activity_in_community},
generate_activity_id,
verify_activity,
verify_is_public,
@ -63,7 +63,7 @@ impl CreateOrUpdatePost {
let create_or_update = CreateOrUpdatePost::new(post, actor, &community, kind, context).await?;
let id = create_or_update.id.clone();
let activity = AnnouncableActivities::CreateOrUpdatePost(create_or_update);
send_to_community(activity, &id, actor, &community, vec![], context).await
send_activity_in_community(activity, &id, actor, &community, vec![], context).await
}
}

4
crates/apub/src/activities/voting/undo_vote.rs
View file

@ -1,6 +1,6 @@
use crate::{
activities::{
community::{announce::GetCommunity, send_to_community},
community::{announce::GetCommunity, send_activity_in_community},
generate_activity_id,
verify_activity,
verify_is_public,
@ -56,7 +56,7 @@ impl UndoVote {
unparsed: Default::default(),
};
let activity = AnnouncableActivities::UndoVote(undo_vote);
send_to_community(activity, &id, actor, &community, vec![], context).await
send_activity_in_community(activity, &id, actor, &community, vec![], context).await
}
}

4
crates/apub/src/activities/voting/vote.rs
View file

@ -1,6 +1,6 @@
use crate::{
activities::{
community::{announce::GetCommunity, send_to_community},
community::{announce::GetCommunity, send_activity_in_community},
generate_activity_id,
verify_activity,
verify_is_public,
@ -62,7 +62,7 @@ impl Vote {
let vote_id = vote.id.clone();
let activity = AnnouncableActivities::Vote(vote);
send_to_community(activity, &vote_id, actor, &community, vec![], context).await
send_activity_in_community(activity, &vote_id, actor, &community, vec![], context).await
}
}

1
crates/apub/src/fetcher/mod.rs
View file

@ -1,3 +1,4 @@
pub mod post_or_comment;
pub mod search;
pub mod user_or_community;
pub mod webfinger;

100
crates/apub/src/fetcher/search.rs
View file

@ -1,20 +1,12 @@
use crate::{
fetcher::webfinger::webfinger_resolve,
objects::{comment::ApubComment, community::ApubCommunity, person::ApubPerson, post::ApubPost},
protocol::objects::{group::Group, note::Note, page::Page, person::Person},
EndpointType,
};
use anyhow::anyhow;
use chrono::NaiveDateTime;
use itertools::Itertools;
use lemmy_api_common::blocking;
use lemmy_apub_lib::{
object_id::ObjectId,
traits::ApubObject,
webfinger::{webfinger_resolve_actor, WebfingerType},
};
use lemmy_db_schema::{
source::{community::Community, person::Person as DbPerson},
DbPool,
};
use lemmy_apub_lib::{object_id::ObjectId, traits::ApubObject};
use lemmy_utils::LemmyError;
use lemmy_websocket::LemmyContext;
use serde::Deserialize;
@ -31,58 +23,48 @@ pub async fn search_by_apub_id(
query: &str,
context: &LemmyContext,
) -> Result<SearchableObjects, LemmyError> {
let query_url = match Url::parse(query) {
Ok(u) => u,
Err(_) => {
let (kind, name) = query.split_at(1);
let kind = match kind {
"@" => WebfingerType::Person,
"!" => WebfingerType::Group,
_ => return Err(anyhow!("invalid query").into()),
};
// remote actor, use webfinger to resolve url
if name.contains('@') {
let (name, domain) = name.splitn(2, '@').collect_tuple().expect("invalid query");
webfinger_resolve_actor(
name,
domain,
kind,
context.client(),
context.settings().get_protocol_string(),
)
.await?
}
// local actor, read from database and return
else {
return find_local_actor_by_name(name, kind, context.pool()).await;
}
}
};
let request_counter = &mut 0;
ObjectId::new(query_url)
match Url::parse(query) {
Ok(url) => {
ObjectId::new(url)
.dereference(context, request_counter)
.await
}
async fn find_local_actor_by_name(
name: &str,
kind: WebfingerType,
pool: &DbPool,
) -> Result<SearchableObjects, LemmyError> {
let name: String = name.into();
Ok(match kind {
WebfingerType::Group => SearchableObjects::Community(
blocking(pool, move |conn| Community::read_from_name(conn, &name))
.await??
.into(),
),
WebfingerType::Person => SearchableObjects::Person(
blocking(pool, move |conn| DbPerson::find_by_name(conn, &name))
.await??
.into(),
),
})
Err(_) => {
let (kind, identifier) = query.split_at(1);
match kind {
"@" => {
let id = webfinger_resolve::<ApubPerson>(
identifier,
EndpointType::Person,
context,
request_counter,
)
.await?;
Ok(SearchableObjects::Person(
ObjectId::new(id)
.dereference(context, request_counter)
.await?,
))
}
"!" => {
let id = webfinger_resolve::<ApubCommunity>(
identifier,
EndpointType::Community,
context,
request_counter,
)
.await?;
Ok(SearchableObjects::Community(
ObjectId::new(id)
.dereference(context, request_counter)
.await?,
))
}
_ => Err(anyhow!("invalid query").into()),
}
}
}
}
/// The types of ActivityPub objects that can be fetched directly by searching for their ID.

5
crates/apub/src/fetcher/user_or_community.rs
View file

@ -96,7 +96,10 @@ impl ApubObject for UserOrCommunity {
impl ActorType for UserOrCommunity {
fn actor_id(&self) -> Url {
todo!()
match self {
UserOrCommunity::User(p) => p.actor_id(),
UserOrCommunity::Community(p) => p.actor_id(),
}
}
fn public_key(&self) -> Option<String> {

107
crates/apub/src/fetcher/webfinger.rs Normal file
View file

@ -0,0 +1,107 @@
use crate::{generate_local_apub_endpoint, EndpointType};
use anyhow::anyhow;
use itertools::Itertools;
use lemmy_apub_lib::{
object_id::ObjectId,
traits::{ActorType, ApubObject},
};
use lemmy_db_schema::newtypes::DbUrl;
use lemmy_utils::{
request::{retry, RecvError},
LemmyError,
};
use lemmy_websocket::LemmyContext;
use log::debug;
use serde::{Deserialize, Serialize};
use url::Url;
#[derive(Serialize, Deserialize, Debug)]
pub struct WebfingerLink {
pub rel: Option<String>,
#[serde(rename(serialize = "type", deserialize = "type"))]
pub type_: Option<String>,
pub href: Option<Url>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct WebfingerResponse {
pub subject: String,
pub links: Vec<WebfingerLink>,
}
/// Takes in a shortname of the type dessalines@xyz.tld or dessalines (assumed to be local), and
/// outputs the actor id. Used in the API for communities and users.
///
/// TODO: later provide a method in ApubObject to generate the endpoint, so that we dont have to
/// pass in EndpointType
pub async fn webfinger_resolve<Kind>(
identifier: &str,
endpoint_type: EndpointType,
context: &LemmyContext,
request_counter: &mut i32,
) -> Result<DbUrl, LemmyError>
where
Kind: ApubObject<DataType = LemmyContext> + ActorType + Send + 'static,
for<'de2> <Kind as ApubObject>::ApubType: serde::Deserialize<'de2>,
{
// remote actor
if identifier.contains('@') {
webfinger_resolve_actor::<Kind>(identifier, context, request_counter).await
}
// local actor
else {
let domain = context.settings().get_protocol_and_hostname();
Ok(generate_local_apub_endpoint(
endpoint_type,
identifier,
&domain,
)?)
}
}
/// Turns a person id like `@name@example.com` into an apub ID, like `https://example.com/user/name`,
/// using webfinger.
async fn webfinger_resolve_actor<Kind>(
identifier: &str,
context: &LemmyContext,
request_counter: &mut i32,
) -> Result<DbUrl, LemmyError>
where
Kind: ApubObject<DataType = LemmyContext> + ActorType + Send + 'static,
for<'de2> <Kind as ApubObject>::ApubType: serde::Deserialize<'de2>,
{
let protocol = context.settings().get_protocol_string();
let (_, domain) = identifier
.splitn(2, '@')
.collect_tuple()
.expect("invalid query");
let fetch_url = format!(
"{}://{}/.well-known/webfinger?resource=acct:{}",
protocol, domain, identifier
);
debug!("Fetching webfinger url: {}", &fetch_url);
let response = retry(|| context.client().get(&fetch_url).send()).await?;
let res: WebfingerResponse = response
.json()
.await
.map_err(|e| RecvError(e.to_string()))?;
let links: Vec<Url> = res
.links
.iter()
.filter(|l| l.type_.eq(&Some("application/activity+json".to_string())))
.map(|l| l.href.clone())
.flatten()
.collect();
for l in links {
let object = ObjectId::<Kind>::new(l)
.dereference(context, request_counter)
.await;
if object.is_ok() {
return object.map(|o| o.actor_id().into());
}
}
Err(anyhow!("Failed to resolve actor for {}", identifier).into())
}

2
crates/apub/src/http/community.rs
View file

@ -85,7 +85,7 @@ pub(in crate::http) async fn receive_group_inbox(
let community = announcable.get_community(context, &mut 0).await?;
verify_person_in_community(&actor_id, &community, context, &mut 0).await?;
if community.local {
AnnounceActivity::send(*announcable, &community, vec![], context).await?;
AnnounceActivity::send(*announcable, &community, context).await?;
}
}

48
crates/apub/src/lib.rs
View file

@ -1,9 +1,18 @@
use crate::fetcher::post_or_comment::PostOrComment;
use anyhow::{anyhow, Context};
use lemmy_api_common::blocking;
use lemmy_db_schema::{newtypes::DbUrl, source::activity::Activity, DbPool};
use lemmy_utils::{location_info, settings::structs::Settings, LemmyError};
use std::net::IpAddr;
use url::{ParseError, Url};
pub mod activities;
pub(crate) mod activity_lists;
pub(crate) mod collections;
mod context;
pub mod fetcher;
pub mod http;
pub(crate) mod mentions;
pub mod migrations;
pub mod objects;
pub mod protocol;
@ -11,16 +20,6 @@ pub mod protocol;
#[macro_use]
extern crate lazy_static;
use crate::fetcher::post_or_comment::PostOrComment;
use anyhow::{anyhow, Context};
use lemmy_api_common::blocking;
use lemmy_apub_lib::webfinger::{webfinger_resolve_actor, WebfingerType};
use lemmy_db_schema::{newtypes::DbUrl, source::activity::Activity, DbPool};
use lemmy_utils::{location_info, settings::structs::Settings, LemmyError};
use lemmy_websocket::LemmyContext;
use std::net::IpAddr;
use url::{ParseError, Url};
/// Checks if the ID is allowed for sending or receiving.
///
/// In particular, it checks for:
@ -145,35 +144,6 @@ fn generate_moderators_url(community_id: &DbUrl) -> Result<DbUrl, LemmyError> {
Ok(Url::parse(&format!("{}/moderators", community_id))?.into())
}
/// Takes in a shortname of the type dessalines@xyz.tld or dessalines (assumed to be local), and outputs the actor id.
/// Used in the API for communities and users.
pub async fn get_actor_id_from_name(
webfinger_type: WebfingerType,
short_name: &str,
context: &LemmyContext,
) -> Result<DbUrl, LemmyError> {
let split = short_name.split('@').collect::<Vec<&str>>();
let name = split[0];
// If there's no @, its local
if split.len() == 1 {
let domain = context.settings().get_protocol_and_hostname();
let endpoint_type = match webfinger_type {
WebfingerType::Person => EndpointType::Person,
WebfingerType::Group => EndpointType::Community,
};
Ok(generate_local_apub_endpoint(endpoint_type, name, &domain)?)
} else {
let protocol = context.settings().get_protocol_string();
Ok(
webfinger_resolve_actor(name, split[1], webfinger_type, context.client(), protocol)
.await?
.into(),
)
}
}
/// Store a sent or received activity in the database, for logging purposes. These records are not
/// persistent.
async fn insert_activity(

134
crates/apub/src/mentions.rs Normal file
View file

@ -0,0 +1,134 @@
use crate::{
fetcher::webfinger::WebfingerResponse,
objects::{comment::ApubComment, community::ApubCommunity, person::ApubPerson},
};
use activitystreams::{
base::BaseExt,
link::{LinkExt, Mention},
};
use anyhow::anyhow;
use lemmy_api_common::blocking;
use lemmy_apub_lib::{object_id::ObjectId, traits::ActorType};
use lemmy_db_schema::{
source::{comment::Comment, person::Person, post::Post},
traits::Crud,
DbPool,
};
use lemmy_utils::{
request::{retry, RecvError},
utils::{scrape_text_for_mentions, MentionData},
LemmyError,
};
use lemmy_websocket::LemmyContext;
use log::debug;
use url::Url;
pub struct MentionsAndAddresses {
pub ccs: Vec<Url>,
pub tags: Vec<Mention>,
}
/// This takes a comment, and builds a list of to_addresses, inboxes,
/// and mention tags, so they know where to be sent to.
/// Addresses are the persons / addresses that go in the cc field.
pub async fn collect_non_local_mentions(
comment: &ApubComment,
community_id: ObjectId<ApubCommunity>,
context: &LemmyContext,
) -> Result<MentionsAndAddresses, LemmyError> {
let parent_creator = get_comment_parent_creator(context.pool(), comment).await?;
let mut addressed_ccs: Vec<Url> = vec![community_id.into(), parent_creator.actor_id()];
// Add the mention tag
let mut parent_creator_tag = Mention::new();
parent_creator_tag
.set_href(parent_creator.actor_id.clone().into())
.set_name(format!(
"@{}@{}",
&parent_creator.name,
&parent_creator.actor_id().domain().expect("has domain")
));
let mut tags = vec![parent_creator_tag];
// Get the person IDs for any mentions
let mentions = scrape_text_for_mentions(&comment.content)
.into_iter()
// Filter only the non-local ones
.filter(|m| !m.is_local(&context.settings().hostname))
.collect::<Vec<MentionData>>();
for mention in &mentions {
// TODO should it be fetching it every time?
if let Ok(actor_id) = fetch_webfinger_url(mention, context).await {
let actor_id: ObjectId<ApubPerson> = ObjectId::new(actor_id);
debug!("mention actor_id: {}", actor_id);
addressed_ccs.push(actor_id.to_string().parse()?);
let mut mention_tag = Mention::new();
mention_tag
.set_href(actor_id.into())
.set_name(mention.full_name());
tags.push(mention_tag);
}
}
Ok(MentionsAndAddresses {
ccs: addressed_ccs,
tags,
})
}
/// Returns the apub ID of the person this comment is responding to. Meaning, in case this is a
/// top-level comment, the creator of the post, otherwise the creator of the parent comment.
async fn get_comment_parent_creator(
pool: &DbPool,
comment: &Comment,
) -> Result<ApubPerson, LemmyError> {
let parent_creator_id = if let Some(parent_comment_id) = comment.parent_id {
let parent_comment =
blocking(pool, move |conn| Comment::read(conn, parent_comment_id)).await??;
parent_comment.creator_id
} else {
let parent_post_id = comment.post_id;
let parent_post = blocking(pool, move |conn| Post::read(conn, parent_post_id)).await??;
parent_post.creator_id
};
Ok(
blocking(pool, move |conn| Person::read(conn, parent_creator_id))
.await??
.into(),
)
}
/// Turns a person id like `@name@example.com` into an apub ID, like `https://example.com/user/name`,
/// using webfinger.
async fn fetch_webfinger_url(
mention: &MentionData,
context: &LemmyContext,
) -> Result<Url, LemmyError> {
let fetch_url = format!(
"{}://{}/.well-known/webfinger?resource=acct:{}@{}",
context.settings().get_protocol_string(),
mention.domain,
mention.name,
mention.domain
);
debug!("Fetching webfinger url: {}", &fetch_url);
let response = retry(|| context.client().get(&fetch_url).send()).await?;
let res: WebfingerResponse = response
.json()
.await
.map_err(|e| RecvError(e.to_string()))?;
let link = res
.links
.iter()
.find(|l| l.type_.eq(&Some("application/activity+json".to_string())))
.ok_or_else(|| anyhow!("No application/activity+json link found."))?;
link
.href
.to_owned()
.ok_or_else(|| anyhow!("No href found.").into())
}

15
crates/apub/src/objects/comment.rs
View file

@ -1,6 +1,7 @@
use crate::{
activities::{verify_is_public, verify_person_in_community},
check_is_apub_id_valid,
mentions::collect_non_local_mentions,
protocol::{
objects::{
note::{Note, SourceCompat},
@ -93,6 +94,11 @@ impl ApubObject for ApubComment {
let post_id = self.post_id;
let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
let community_id = post.community_id;
let community = blocking(context.pool(), move |conn| {
Community::read(conn, community_id)
})
.await??;
let in_reply_to = if let Some(comment_id) = self.parent_id {
let parent_comment =
@ -101,13 +107,14 @@ impl ApubObject for ApubComment {
} else {
ObjectId::<PostOrComment>::new(post.ap_id)
};
let maa = collect_non_local_mentions(&self, ObjectId::new(community.actor_id), context).await?;
let note = Note {
r#type: NoteType::Note,
id: ObjectId::new(self.ap_id.clone()),
attributed_to: ObjectId::new(creator.actor_id),
to: vec![public()],
cc: vec![],
cc: maa.ccs,
content: markdown_to_html(&self.content),
media_type: Some(MediaTypeHtml::Html),
source: SourceCompat::Lemmy(Source {
@ -117,6 +124,7 @@ impl ApubObject for ApubComment {
in_reply_to,
published: Some(convert_datetime(self.published)),
updated: self.updated.map(convert_datetime),
tag: maa.tags,
unparsed: Default::default(),
};
@ -124,10 +132,7 @@ impl ApubObject for ApubComment {
}
fn to_tombstone(&self) -> Result<Tombstone, LemmyError> {
Ok(Tombstone::new(
NoteType::Note,
self.updated.unwrap_or(self.published),
))
Ok(Tombstone::new(self.ap_id.clone().into()))
}
async fn verify(

14
crates/apub/src/objects/community.rs
View file

@ -118,10 +118,7 @@ impl ApubObject for ApubCommunity {
}
fn to_tombstone(&self) -> Result<Tombstone, LemmyError> {
Ok(Tombstone::new(
GroupType::Group,
self.updated.unwrap_or(self.published),
))
Ok(Tombstone::new(self.actor_id()))
}
async fn verify(
@ -192,7 +189,6 @@ impl ApubCommunity {
/// For a given community, returns the inboxes of all followers.
pub(crate) async fn get_follower_inboxes(
&self,
additional_inboxes: Vec<Url>,
context: &LemmyContext,
) -> Result<Vec<Url>, LemmyError> {
let id = self.id;
@ -201,7 +197,7 @@ impl ApubCommunity {
CommunityFollowerView::for_community(conn, id)
})
.await??;
let follower_inboxes: Vec<Url> = follows
let inboxes: Vec<Url> = follows
.into_iter()
.filter(|f| !f.follower.local)
.map(|f| {
@ -210,12 +206,8 @@ impl ApubCommunity {
.unwrap_or(f.follower.inbox_url)
.into()
})
.collect();
let inboxes = vec![follower_inboxes, additional_inboxes]
.into_iter()
.flatten()
.unique()
.filter(|inbox| inbox.host_str() != Some(&context.settings().hostname))
.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())
.collect();

5
crates/apub/src/objects/post.rs
View file

@ -128,10 +128,7 @@ impl ApubObject for ApubPost {
}
fn to_tombstone(&self) -> Result<Tombstone, LemmyError> {
Ok(Tombstone::new(
PageType::Page,
self.updated.unwrap_or(self.published),
))
Ok(Tombstone::new(self.ap_id.clone().into()))
}
async fn verify(

2
crates/apub/src/protocol/activities/create_or_update/mod.rs
View file

@ -14,7 +14,7 @@ mod tests {
#[actix_rt::test]
#[serial]
async fn test_parsey_create_or_update() {
async fn test_parse_create_or_update() {
test_parse_lemmy_item::<CreateOrUpdatePost>(
"assets/lemmy/activities/create_or_update/create_page.json",
);

5
crates/apub/src/protocol/activities/deletion/delete.rs
View file

@ -1,4 +1,4 @@
use crate::objects::person::ApubPerson;
use crate::{objects::person::ApubPerson, protocol::objects::tombstone::Tombstone};
use activitystreams::{activity::kind::DeleteType, unparsed::Unparsed};
use lemmy_apub_lib::object_id::ObjectId;
use serde::{Deserialize, Serialize};
@ -11,8 +11,7 @@ use url::Url;
pub struct Delete {
pub(crate) actor: ObjectId<ApubPerson>,
pub(crate) to: Vec<Url>,
pub(crate) object: Url,
pub(crate) cc: Vec<Url>,
pub(crate) object: Tombstone,
#[serde(rename = "type")]
pub(crate) kind: DeleteType,
/// If summary is present, this is a mod action (Remove in Lemmy terms). Otherwise, its a user

2
crates/apub/src/protocol/activities/deletion/mod.rs
View file

@ -11,7 +11,7 @@ mod tests {
#[actix_rt::test]
#[serial]
async fn test_parse_lemmy_voting() {
async fn test_parse_lemmy_deletion() {
test_parse_lemmy_item::<Delete>("assets/lemmy/activities/deletion/remove_note.json");
test_parse_lemmy_item::<Delete>("assets/lemmy/activities/deletion/delete_page.json");

3
crates/apub/src/protocol/activities/following/accept.rs
View file

@ -1,5 +1,5 @@
use crate::{
objects::{community::ApubCommunity, person::ApubPerson},
objects::community::ApubCommunity,
protocol::activities::following::follow::FollowCommunity,
};
use activitystreams::{activity::kind::AcceptType, unparsed::Unparsed};
@ -11,7 +11,6 @@ use url::Url;
#[serde(rename_all = "camelCase")]
pub struct AcceptFollowCommunity {
pub(crate) actor: ObjectId<ApubCommunity>,
pub(crate) to: [ObjectId<ApubPerson>; 1],
pub(crate) object: FollowCommunity,
#[serde(rename = "type")]
pub(crate) kind: AcceptType,

1
crates/apub/src/protocol/activities/following/follow.rs
View file

@ -8,7 +8,6 @@ use url::Url;
#[serde(rename_all = "camelCase")]
pub struct FollowCommunity {
pub(crate) actor: ObjectId<ApubPerson>,
pub(crate) to: [ObjectId<ApubCommunity>; 1],
pub(crate) object: ObjectId<ApubCommunity>,
#[serde(rename = "type")]
pub(crate) kind: FollowType,

3
crates/apub/src/protocol/activities/following/undo_follow.rs
View file

@ -1,5 +1,5 @@
use crate::{
objects::{community::ApubCommunity, person::ApubPerson},
objects::person::ApubPerson,
protocol::activities::following::follow::FollowCommunity,
};
use activitystreams::{activity::kind::UndoType, unparsed::Unparsed};
@ -11,7 +11,6 @@ use url::Url;
#[serde(rename_all = "camelCase")]
pub struct UndoFollowCommunity {
pub(crate) actor: ObjectId<ApubPerson>,
pub(crate) to: [ObjectId<ApubCommunity>; 1],
pub(crate) object: FollowCommunity,
#[serde(rename = "type")]
pub(crate) kind: UndoType,

4
crates/apub/src/protocol/mod.rs
View file

@ -30,7 +30,9 @@ pub(crate) mod tests {
use serde::{de::DeserializeOwned, Serialize};
use std::collections::HashMap;
pub(crate) fn test_parse_lemmy_item<T: Serialize + DeserializeOwned>(path: &str) -> T {
pub(crate) fn test_parse_lemmy_item<T: Serialize + DeserializeOwned + std::fmt::Debug>(
path: &str,
) -> T {
let parsed = file_to_json_object::<T>(path);
// ensure that no field is ignored when parsing

4
crates/apub/src/protocol/objects/note.rs
View file

@ -3,7 +3,7 @@ use crate::{
objects::{comment::ApubComment, person::ApubPerson, post::ApubPost},
protocol::Source,
};
use activitystreams::{object::kind::NoteType, unparsed::Unparsed};
use activitystreams::{link::Mention, object::kind::NoteType, unparsed::Unparsed};
use anyhow::anyhow;
use chrono::{DateTime, FixedOffset};
use lemmy_api_common::blocking;
@ -38,6 +38,8 @@ pub struct Note {
pub(crate) in_reply_to: ObjectId<PostOrComment>,
pub(crate) published: Option<DateTime<FixedOffset>>,
pub(crate) updated: Option<DateTime<FixedOffset>>,
#[serde(default)]
pub(crate) tag: Vec<Mention>,
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}

11
crates/apub/src/protocol/objects/tombstone.rs
View file

@ -1,25 +1,22 @@
use activitystreams::object::kind::TombstoneType;
use chrono::{DateTime, FixedOffset, NaiveDateTime};
use lemmy_utils::utils::convert_datetime;
use serde::{Deserialize, Serialize};
use serde_with::skip_serializing_none;
use url::Url;
#[skip_serializing_none]
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Tombstone {
pub(crate) id: Url,
#[serde(rename = "type")]
kind: TombstoneType,
former_type: String,
deleted: DateTime<FixedOffset>,
}
impl Tombstone {
pub fn new<T: ToString>(former_type: T, updated_time: NaiveDateTime) -> Tombstone {
pub fn new(id: Url) -> Tombstone {
Tombstone {
id,
kind: TombstoneType::Tombstone,
former_type: former_type.to_string(),
deleted: convert_datetime(updated_time),
}
}
}

35
crates/apub_lib/src/activity_queue.rs
View file

@ -10,24 +10,26 @@ use background_jobs::{
WorkerConfig,
};
use lemmy_utils::{location_info, LemmyError};
use log::warn;
use log::{info, warn};
use reqwest::Client;
use serde::{Deserialize, Serialize};
use std::{env, fmt::Debug, future::Future, pin::Pin};
use url::Url;
pub async fn send_activity(
activity: String,
activity_id: &Url,
actor: &dyn ActorType,
inboxes: Vec<&Url>,
activity: String,
client: &Client,
activity_queue: &QueueHandle,
) -> Result<(), LemmyError> {
for i in inboxes {
let message = SendActivityTask {
activity: activity.clone(),
activity_id: activity_id.clone(),
inbox: i.to_owned(),
actor_id: actor.actor_id(),
activity: activity.clone(),
private_key: actor.private_key().context(location_info!())?,
};
if env::var("APUB_TESTING_SEND_SYNC").is_ok() {
@ -42,9 +44,10 @@ pub async fn send_activity(
#[derive(Clone, Debug, Deserialize, Serialize)]
struct SendActivityTask {
activity: String,
activity_id: Url,
inbox: Url,
actor_id: Url,
activity: String,
private_key: String,
}
@ -64,6 +67,7 @@ impl ActixJob for SendActivityTask {
}
async fn do_send(task: SendActivityTask, client: &Client) -> Result<(), Error> {
info!("Sending {} to {}", task.activity_id, task.inbox);
let result = sign_and_send(
client,
&task.inbox,
@ -73,14 +77,27 @@ async fn do_send(task: SendActivityTask, client: &Client) -> Result<(), Error> {
)
.await;
if let Err(e) = result {
warn!("{}", e);
match result {
Ok(o) => {
if !o.status().is_success() {
warn!(
"Send {} to {} failed with status {}: {}",
task.activity_id,
task.inbox,
o.status(),
o.text().await?
);
}
}
Err(e) => {
return Err(anyhow!(
"Failed to send activity {} to {}",
&task.activity,
task.inbox
"Failed to send activity {} to {}: {}",
&task.activity_id,
task.inbox,
e
));
}
}
Ok(())
}

1
crates/apub_lib/src/lib.rs
View file

@ -8,6 +8,5 @@ pub mod signatures;
pub mod traits;
pub mod values;
pub mod verify;
pub mod webfinger;
pub static APUB_JSON_CONTENT_TYPE: &str = "application/activity+json";

7
crates/apub_lib/src/signatures.rs
View file

@ -44,10 +44,9 @@ pub async fn sign_and_send(
HeaderValue::from_str(APUB_JSON_CONTENT_TYPE)?,
);
headers.insert(HeaderName::from_str("Host")?, HeaderValue::from_str(&host)?);
headers.insert(
HeaderName::from_str("Date")?,
HeaderValue::from_str(&Utc::now().to_rfc2822())?,
);
// Need to use legacy timezone because mastodon and doesnt understand any new standards
let date = Utc::now().to_rfc2822().replace("+0000", "GMT");
headers.insert(HeaderName::from_str("Date")?, HeaderValue::from_str(&date)?);
let response = client
.post(&inbox_url.to_string())

68
crates/apub_lib/src/webfinger.rs
View file

@ -1,68 +0,0 @@
use anyhow::anyhow;
use lemmy_utils::{
request::{retry, RecvError},
LemmyError,
};
use log::debug;
use reqwest::Client;
use serde::{Deserialize, Serialize};
use url::Url;
#[derive(Serialize, Deserialize, Debug)]
pub struct WebfingerLink {
pub rel: Option<String>,
#[serde(rename(serialize = "type", deserialize = "type"))]
pub type_: Option<String>,
pub href: Option<Url>,
#[serde(skip_serializing_if = "Option::is_none")]
pub template: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct WebfingerResponse {
pub subject: String,
pub aliases: Vec<Url>,
pub links: Vec<WebfingerLink>,
}
pub enum WebfingerType {
Person,
Group,
}
/// Turns a person id like `@name@example.com` into an apub ID, like `https://example.com/user/name`,
/// using webfinger.
pub async fn webfinger_resolve_actor(
name: &str,
domain: &str,
webfinger_type: WebfingerType,
client: &Client,
protocol_string: &str,
) -> Result<Url, LemmyError> {
let webfinger_type = match webfinger_type {
WebfingerType::Person => "acct",
WebfingerType::Group => "group",
};
let fetch_url = format!(
"{}://{}/.well-known/webfinger?resource={}:{}@{}",
protocol_string, domain, webfinger_type, name, domain
);
debug!("Fetching webfinger url: {}", &fetch_url);
let response = retry(|| client.get(&fetch_url).send()).await?;
let res: WebfingerResponse = response
.json()
.await
.map_err(|e| RecvError(e.to_string()))?;
let link = res
.links
.iter()
.find(|l| l.type_.eq(&Some("application/activity+json".to_string())))
.ok_or_else(|| anyhow!("No application/activity+json link found."))?;
link
.href
.to_owned()
.ok_or_else(|| anyhow!("No href found.").into())
}

2
crates/routes/Cargo.toml
View file

@ -17,7 +17,7 @@ lemmy_db_views = { version = "=0.14.0-rc.1", path = "../db_views" }
lemmy_db_views_actor = { version = "=0.14.0-rc.1", path = "../db_views_actor" }
lemmy_db_schema = { version = "=0.14.0-rc.1", path = "../db_schema" }
lemmy_api_common = { version = "=0.14.0-rc.1", path = "../api_common" }
lemmy_apub_lib = { version = "=0.14.0-rc.1", path = "../apub_lib" }
lemmy_apub = { version = "=0.14.0-rc.1", path = "../apub" }
diesel = "1.4.8"
actix = "0.12.0"
actix-web = { version = "4.0.0-beta.9", default-features = false, features = ["rustls"] }

95
crates/routes/src/webfinger.rs
View file

@ -1,11 +1,12 @@
use actix_web::{web, web::Query, HttpResponse};
use anyhow::anyhow;
use anyhow::Context;
use lemmy_api_common::blocking;
use lemmy_apub_lib::webfinger::{WebfingerLink, WebfingerResponse};
use lemmy_apub::fetcher::webfinger::{WebfingerLink, WebfingerResponse};
use lemmy_db_schema::source::{community::Community, person::Person};
use lemmy_utils::{settings::structs::Settings, ApiError, LemmyError};
use lemmy_utils::{location_info, settings::structs::Settings, LemmyError};
use lemmy_websocket::LemmyContext;
use serde::Deserialize;
use url::Url;
#[derive(Deserialize)]
struct Params {
@ -31,64 +32,60 @@ async fn get_webfinger_response(
info: Query<Params>,
context: web::Data<LemmyContext>,
) -> Result<HttpResponse, LemmyError> {
let community_regex_parsed = context
let name = context
.settings()
.webfinger_community_regex()
.webfinger_regex()
.captures(&info.resource)
.map(|c| c.get(1))
.flatten();
.flatten()
.context(location_info!())?
.as_str()
.to_string();
let username_regex_parsed = context
.settings()
.webfinger_username_regex()
.captures(&info.resource)
.map(|c| c.get(1))
.flatten();
let url = if let Some(community_name) = community_regex_parsed {
let community_name = community_name.as_str().to_owned();
// Make sure the requested community exists.
blocking(context.pool(), move |conn| {
Community::read_from_name(conn, &community_name)
let name_ = name.clone();
let community_id: Option<Url> = blocking(context.pool(), move |conn| {
Community::read_from_name(conn, &name_)
})
.await?
.map_err(|e| ApiError::err("not_found", e))?
.actor_id
} else if let Some(person_name) = username_regex_parsed {
let person_name = person_name.as_str().to_owned();
// Make sure the requested person exists.
blocking(context.pool(), move |conn| {
Person::find_by_name(conn, &person_name)
.ok()
.map(|c| c.actor_id.into());
let user_id: Option<Url> = blocking(context.pool(), move |conn| {
Person::find_by_name(conn, &name)
})
.await?
.map_err(|e| ApiError::err("not_found", e))?
.actor_id
} else {
return Err(LemmyError::from(anyhow!("not_found")));
};
.ok()
.map(|c| c.actor_id.into());
let links = vec![
webfinger_link_for_actor(community_id),
webfinger_link_for_actor(user_id),
]
.into_iter()
.flatten()
.collect();
let json = WebfingerResponse {
subject: info.resource.to_owned(),
aliases: vec![url.to_owned().into()],
links: vec![
WebfingerLink {
rel: Some("http://webfinger.net/rel/profile-page".to_string()),
type_: Some("text/html".to_string()),
href: Some(url.to_owned().into()),
template: None,
},
WebfingerLink {
rel: Some("self".to_string()),
type_: Some("application/activity+json".to_string()),
href: Some(url.into()),
template: None,
}, // TODO: this also needs to return the subscribe link once that's implemented
//{
// "rel": "http://ostatus.org/schema/1.0/subscribe",
// "template": "https://my_instance.com/authorize_interaction?uri={uri}"
//}
],
links,
};
Ok(HttpResponse::Ok().json(json))
}
fn webfinger_link_for_actor(url: Option<Url>) -> Vec<WebfingerLink> {
if let Some(url) = url {
vec![
WebfingerLink {
rel: Some("http://webfinger.net/rel/profile-page".to_string()),
type_: Some("text/html".to_string()),
href: Some(url.to_owned()),
},
WebfingerLink {
rel: Some("self".to_string()),
type_: Some("application/activity+json".to_string()),
href: Some(url),
},
]
} else {
vec![]
}
}

15
crates/utils/src/settings/mod.rs
View file

@ -11,12 +11,7 @@ static DEFAULT_CONFIG_FILE: &str = "config/config.hjson";
lazy_static! {
static ref SETTINGS: RwLock<Settings> =
RwLock::new(Settings::init().expect("Failed to load settings file"));
static ref WEBFINGER_COMMUNITY_REGEX: Regex = Regex::new(&format!(
"^group:([a-z0-9_]{{3,}})@{}$",
Settings::get().hostname
))
.expect("compile webfinger regex");
static ref WEBFINGER_USER_REGEX: Regex = Regex::new(&format!(
static ref WEBFINGER_REGEX: Regex = Regex::new(&format!(
"^acct:([a-z0-9_]{{3,}})@{}$",
Settings::get().hostname
))
@ -105,12 +100,8 @@ impl Settings {
Ok(Self::read_config_file()?)
}
pub fn webfinger_community_regex(&self) -> Regex {
WEBFINGER_COMMUNITY_REGEX.to_owned()
}
pub fn webfinger_username_regex(&self) -> Regex {
WEBFINGER_USER_REGEX.to_owned()
pub fn webfinger_regex(&self) -> Regex {
WEBFINGER_REGEX.to_owned()
}
pub fn slur_regex(&self) -> Option<Regex> {