mobilizon/lib/federation/activity_pub/actor.ex

120 lines
4.2 KiB
Elixir
Raw Normal View History

defmodule Mobilizon.Federation.ActivityPub.Actor do
@moduledoc """
Module to handle ActivityPub Actor interactions
"""
alias Mobilizon.Actors
alias Mobilizon.Actors.Actor
alias Mobilizon.Federation.ActivityPub.{Fetcher, Relay}
alias Mobilizon.Federation.WebFinger
alias Mobilizon.Web.Endpoint
require Logger
import Mobilizon.Federation.ActivityPub.Utils, only: [are_same_origin?: 2]
@doc """
Getting an actor from url, eventually creating it if we don't have it locally or if it needs an update
"""
@spec get_or_fetch_actor_by_url(url :: String.t(), options :: Keyword.t()) ::
{:ok, Actor.t()}
| {:error, make_actor_errors}
| {:error, :no_internal_relay_actor}
| {:error, :url_nil}
def get_or_fetch_actor_by_url(url, options \\ [])
def get_or_fetch_actor_by_url("https://www.w3.org/ns/activitystreams#Public", _preload) do
%Actor{url: url} = Relay.get_actor()
get_or_fetch_actor_by_url(url)
end
def get_or_fetch_actor_by_url(url, options) when is_binary(url) and is_list(options) do
Logger.debug("Getting or fetching actor by URL #{url}")
preload = Keyword.get(options, :preload, false)
case Actors.get_actor_by_url(url, preload) do
{:ok, %Actor{} = cached_actor} ->
if Actors.needs_update?(cached_actor) do
__MODULE__.make_actor_from_url(url, options)
else
{:ok, cached_actor}
end
{:error, :actor_not_found} ->
# For tests, see https://github.com/jjh42/mock#not-supported---mocking-internal-function-calls and Mobilizon.Federation.ActivityPubTest
__MODULE__.make_actor_from_url(url, options)
end
end
def get_or_fetch_actor_by_url(nil, _preload), do: {:error, :url_nil}
@type make_actor_errors :: Fetcher.fetch_actor_errors() | :actor_is_local
@doc """
Create an actor locally by its URL (AP ID)
"""
@spec make_actor_from_url(url :: String.t(), options :: Keyword.t()) ::
{:ok, Actor.t()} | {:error, make_actor_errors | Ecto.Changeset.t()}
def make_actor_from_url(url, options \\ []) do
Logger.debug("Making actor from url #{url}")
if are_same_origin?(url, Endpoint.url()) do
{:error, :actor_is_local}
else
case Fetcher.fetch_and_prepare_actor_from_url(url, options) do
{:ok, data} when is_map(data) ->
Actors.upsert_actor(data, Keyword.get(options, :preload, false))
# Request returned 410
{:error, :actor_deleted} ->
Logger.info("Actor #{url} was deleted")
{:error, :actor_deleted}
{:error, err} ->
{:error, err}
end
end
end
@doc """
Find an actor in our local database or call WebFinger to find what's its AP ID is and then fetch it
"""
@spec find_or_make_actor_from_nickname(nickname :: String.t(), type :: atom() | nil) ::
{:ok, Actor.t()} | {:error, make_actor_errors | WebFinger.finger_errors()}
def find_or_make_actor_from_nickname(nickname, type \\ nil) do
Logger.debug("Finding or making actor from nickname #{nickname}")
case Actors.get_actor_by_name_with_preload(nickname, type) do
%Actor{url: actor_url} = actor ->
if Actors.needs_update?(actor) do
make_actor_from_url(actor_url, preload: true)
else
{:ok, actor}
end
nil ->
make_actor_from_nickname(nickname, preload: true)
end
end
@spec find_or_make_group_from_nickname(nick :: String.t()) ::
{:error, make_actor_errors | WebFinger.finger_errors()}
def find_or_make_group_from_nickname(nick), do: find_or_make_actor_from_nickname(nick, :Group)
@doc """
Create an actor inside our database from username, using WebFinger to find out its AP ID and then fetch it
"""
@spec make_actor_from_nickname(nickname :: String.t(), preload :: boolean) ::
{:ok, Actor.t()} | {:error, make_actor_errors | WebFinger.finger_errors()}
def make_actor_from_nickname(nickname, preload \\ false) do
Logger.debug("Fingering actor from nickname #{nickname}")
case WebFinger.finger(nickname) do
{:ok, url} when is_binary(url) ->
Logger.debug("Matched #{nickname} to URL #{url}, now making actor")
make_actor_from_url(url, preload: preload)
{:error, e} ->
{:error, e}
end
end
end