Make webfinger standard compliant

Cargo.lock

@@ -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",

crates/api/src/site.rs

@@ -11,10 +11,13 @@ use lemmy_api_common::{
   site::*,
 };
 use lemmy_apub::{
-  fetcher::search::{search_by_apub_id, SearchableObjects},
+  fetcher::{
-  get_actor_id_from_name,
+    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 {

crates/api_crud/src/comment/read.rs

@@ -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::{
-use lemmy_apub_lib::webfinger::WebfingerType;
+  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 {

crates/api_crud/src/community/read.rs

@@ -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::{
-use lemmy_apub_lib::{object_id::ObjectId, webfinger::WebfingerType};
+  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)

crates/api_crud/src/post/read.rs

@@ -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::{
-use lemmy_apub_lib::webfinger::WebfingerType;
+  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 {

crates/api_crud/src/user/read.rs

@@ -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::{
-use lemmy_apub_lib::{object_id::ObjectId, webfinger::WebfingerType};
+  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)

crates/apub/src/activities/comment/mod.rs

@@ -1,12 +1,14 @@
-use crate::objects::{comment::ApubComment, community::ApubCommunity, person::ApubPerson};
 use activitystreams::{
   base::BaseExt,
   link::{LinkExt, Mention},
 };
 use anyhow::anyhow;
 use itertools::Itertools;
+use log::debug;
+use url::Url;
+
 use lemmy_api_common::blocking;
-use lemmy_apub_lib::{object_id::ObjectId, traits::ActorType, webfinger::WebfingerResponse};
+use lemmy_apub_lib::{object_id::ObjectId, traits::ActorType};
 use lemmy_db_schema::{
   newtypes::LocalUserId,
   source::{comment::Comment, person::Person, post::Post},
@@ -19,8 +21,11 @@ use lemmy_utils::{
   LemmyError,
 };
 use lemmy_websocket::{send::send_local_notifs, LemmyContext};
-use log::debug;
+
-use url::Url;
+use crate::{
+  fetcher::webfinger::WebfingerResponse,
+  objects::{comment::ApubComment, community::ApubCommunity, person::ApubPerson},
+};
 
 pub mod create_or_update;
 

crates/apub/src/activities/mod.rs

@@ -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(),
   )

crates/apub/src/fetcher/mod.rs

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

crates/apub/src/fetcher/search.rs

@@ -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_apub_lib::{object_id::ObjectId, traits::ApubObject};
-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_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) {
+  let request_counter = &mut 0;
-    Ok(u) => u,
+  match Url::parse(query) {
+    Ok(url) => {
+      ObjectId::new(url)
+        .dereference(context, request_counter)
+        .await
+    }
     Err(_) => {
-      let (kind, name) = query.split_at(1);
+      let (kind, identifier) = query.split_at(1);
-      let kind = match kind {
+      match kind {
-        "@" => WebfingerType::Person,
+        "@" => {
-        "!" => WebfingerType::Group,
+          let id = webfinger_resolve::<ApubPerson>(
-        _ => return Err(anyhow!("invalid query").into()),
+            identifier,
-      };
+            EndpointType::Person,
-      // remote actor, use webfinger to resolve url
+            context,
-      if name.contains('@') {
+            request_counter,
-        let (name, domain) = name.splitn(2, '@').collect_tuple().expect("invalid query");
+          )
-        webfinger_resolve_actor(
+          .await?;
-          name,
+          Ok(SearchableObjects::Person(
-          domain,
+            ObjectId::new(id)
-          kind,
+              .dereference(context, request_counter)
-          context.client(),
+              .await?,
-          context.settings().get_protocol_string(),
+          ))
-        )
+        }
-        .await?
+        "!" => {
-      }
+          let id = webfinger_resolve::<ApubCommunity>(
-      // local actor, read from database and return
+            identifier,
-      else {
+            EndpointType::Community,
-        return find_local_actor_by_name(name, kind, context.pool()).await;
+            context,
+            request_counter,
+          )
+          .await?;
+          Ok(SearchableObjects::Community(
+            ObjectId::new(id)
+              .dereference(context, request_counter)
+              .await?,
+          ))
+        }
+        _ => Err(anyhow!("invalid query").into()),
       }
     }
-  };
+  }
-
-  let request_counter = &mut 0;
-  ObjectId::new(query_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(),
-    ),
-  })
 }
 
 /// The types of ActivityPub objects that can be fetched directly by searching for their ID.

crates/apub/src/fetcher/user_or_community.rs

@@ -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> {

crates/apub/src/fetcher/webfinger.rs

@@ -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())
+}

crates/apub/src/lib.rs

@@ -1,3 +1,11 @@
+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;
@@ -11,16 +19,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 +143,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(

crates/apub_lib/src/activity_queue.rs

@@ -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,13 +77,26 @@ async fn do_send(task: SendActivityTask, client: &Client) -> Result<(), Error> {
   )
   .await;
 
-  if let Err(e) = result {
+  match result {
-    warn!("{}", e);
+    Ok(o) => {
-    return Err(anyhow!(
+      if !o.status().is_success() {
-      "Failed to send activity {} to {}",
+        warn!(
-      &task.activity,
+          "Send {} to {} failed with status {}: {}",
-      task.inbox
+          task.activity_id,
-    ));
+          task.inbox,
+          o.status(),
+          o.text().await?
+        );
+      }
+    }
+    Err(e) => {
+      return Err(anyhow!(
+        "Failed to send activity {} to {}: {}",
+        &task.activity_id,
+        task.inbox,
+        e
+      ));
+    }
   }
   Ok(())
 }

crates/apub_lib/src/lib.rs

@@ -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";

crates/apub_lib/src/webfinger.rs

@@ -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())
-}

crates/routes/Cargo.toml

@@ -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"] }

crates/routes/src/webfinger.rs

@@ -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
+  let name_ = name.clone();
-    .settings()
+  let community_id: Option<Url> = blocking(context.pool(), move |conn| {
-    .webfinger_username_regex()
+    Community::read_from_name(conn, &name_)
-    .captures(&info.resource)
+  })
-    .map(|c| c.get(1))
+  .await?
-    .flatten();
+  .ok()
-
+  .map(|c| c.actor_id.into());
-  let url = if let Some(community_name) = community_regex_parsed {
+  let user_id: Option<Url> = blocking(context.pool(), move |conn| {
-    let community_name = community_name.as_str().to_owned();
+    Person::find_by_name(conn, &name)
-    // Make sure the requested community exists.
+  })
-    blocking(context.pool(), move |conn| {
+  .await?
-      Community::read_from_name(conn, &community_name)
+  .ok()
-    })
+  .map(|c| c.actor_id.into());
-    .await?
+  let links = vec![
-    .map_err(|e| ApiError::err("not_found", e))?
+    webfinger_link_for_actor(community_id),
-    .actor_id
+    webfinger_link_for_actor(user_id),
-  } else if let Some(person_name) = username_regex_parsed {
+  ]
-    let person_name = person_name.as_str().to_owned();
+  .into_iter()
-    // Make sure the requested person exists.
+  .flatten()
-    blocking(context.pool(), move |conn| {
+  .collect();
-      Person::find_by_name(conn, &person_name)
-    })
-    .await?
-    .map_err(|e| ApiError::err("not_found", e))?
-    .actor_id
-  } else {
-    return Err(LemmyError::from(anyhow!("not_found")));
-  };
 
   let json = WebfingerResponse {
     subject: info.resource.to_owned(),
-    aliases: vec![url.to_owned().into()],
+    links,
-    links: vec![
+  };
+
+  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().into()),
+        href: Some(url.to_owned()),
-        template: None,
       },
       WebfingerLink {
         rel: Some("self".to_string()),
         type_: Some("application/activity+json".to_string()),
-        href: Some(url.into()),
+        href: Some(url),
-        template: None,
+      },
-      }, // TODO: this also needs to return the subscribe link once that's implemented
+    ]
-         //{
+  } else {
-         //  "rel": "http://ostatus.org/schema/1.0/subscribe",
+    vec![]
-         //  "template": "https://my_instance.com/authorize_interaction?uri={uri}"
+  }
-         //}
-    ],
-  };
-
-  Ok(HttpResponse::Ok().json(json))
 }

crates/utils/src/settings/mod.rs

@@ -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!(
+  static ref WEBFINGER_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!(
     "^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 {
+  pub fn webfinger_regex(&self) -> Regex {
-    WEBFINGER_COMMUNITY_REGEX.to_owned()
+    WEBFINGER_REGEX.to_owned()
-  }
-
-  pub fn webfinger_username_regex(&self) -> Regex {
-    WEBFINGER_USER_REGEX.to_owned()
   }
 
   pub fn slur_regex(&self) -> Option<Regex> {