pleroma

publisher.ex (11244B)

# Pleroma: A lightweight social networking server
# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.ActivityPub.Publisher do
  alias Pleroma.Activity
  alias Pleroma.Config
  alias Pleroma.Delivery
  alias Pleroma.HTTP
  alias Pleroma.Instances
  alias Pleroma.Object
  alias Pleroma.Repo
  alias Pleroma.User
  alias Pleroma.Web.ActivityPub.Publisher.Prepared
  alias Pleroma.Web.ActivityPub.Relay
  alias Pleroma.Web.ActivityPub.Transmogrifier
  alias Pleroma.Workers.PublisherWorker
  require Pleroma.Constants
  import Pleroma.Web.ActivityPub.Visibility
  require Logger
  @moduledoc """
  ActivityPub outgoing federation module.
  """
  @doc """
  Enqueue publishing a single activity.
  """
  @spec enqueue_one(map(), Keyword.t()) :: {:ok, %Oban.Job{}}
  def enqueue_one(%{} = params, worker_args \\ []) do
    PublisherWorker.new(
      %{"op" => "publish_one", "params" => params},
      worker_args
    )
    |> Oban.insert()
  end
  @doc """
  Gathers a set of remote users given an IR envelope.
  """
  def remote_users(%User{id: user_id}, %{data: %{"to" => to} = data}) do
    cc = Map.get(data, "cc", [])
    bcc =
      data
      |> Map.get("bcc", [])
      |> Enum.reduce([], fn ap_id, bcc ->
        case Pleroma.List.get_by_ap_id(ap_id) do
          %Pleroma.List{user_id: ^user_id} = list ->
            {:ok, following} = Pleroma.List.get_following(list)
            bcc ++ Enum.map(following, & &1.ap_id)
          _ ->
            bcc
        end
      end)
    [to, cc, bcc]
    |> Enum.concat()
    |> Enum.map(&User.get_cached_by_ap_id/1)
    |> Enum.filter(fn user -> user && !user.local end)
  end
  @doc """
  Determine if an activity can be represented by running it through Transmogrifier.
  """
  def representable?(%Activity{} = activity) do
    with {:ok, _data} <- Transmogrifier.prepare_outgoing(activity.data) do
      true
    else
      _e ->
        false
    end
  end
  @doc """
  Prepare an activity for publishing from an Oban job
  * `inbox`: the inbox to publish to
  * `activity_id`: the internal activity id
  * `cc`: the cc recipients relevant to this inbox (optional)
  """
  @spec prepare_one(map()) :: Prepared.t()
  def prepare_one(%{inbox: inbox, activity_id: activity_id} = params) do
    activity = Activity.get_by_id_with_user_actor(activity_id)
    actor = activity.user_actor
    ap_id = activity.data["id"]
    Logger.debug("Federating #{ap_id} to #{inbox}")
    uri = %{path: path} = URI.parse(inbox)
    {:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
    cc = Map.get(params, :cc, [])
    json =
      data
      |> Map.put("cc", cc)
      |> Jason.encode!()
    digest = "SHA-256=" <> (:crypto.hash(:sha256, json) |> Base.encode64())
    date = Pleroma.Signature.signed_date()
    signature =
      Pleroma.Signature.sign(actor, %{
        "(request-target)": "post #{path}",
        host: signature_host(uri),
        "content-length": byte_size(json),
        digest: digest,
        date: date
      })
    %Prepared{
      activity_id: activity_id,
      json: json,
      date: date,
      signature: signature,
      digest: digest,
      inbox: inbox,
      unreachable_since: params[:unreachable_since]
    }
  end
  @doc """
  Publish a single message to a peer.  Takes a struct with the following
  parameters set:
  * `activity_id`: the activity id
  * `json`: the json payload
  * `date`: the signed date from Pleroma.Signature.signed_date()
  * `signature`: the signature from Pleroma.Signature.sign/2
  * `digest`: base64 encoded the hash of the json payload prefixed with "SHA-256="
  * `inbox`: the inbox URI of this delivery
  * `unreachable_since`: timestamp the instance was marked unreachable
  """
  def publish_one(%Prepared{} = p) do
    with {:ok, %{status: code}} = result when code in 200..299 <-
           HTTP.post(
             p.inbox,
             p.json,
             [
               {"Content-Type", "application/activity+json"},
               {"Date", p.date},
               {"signature", p.signature},
               {"digest", p.digest}
             ]
           ) do
      if not is_nil(p.unreachable_since) do
        Instances.set_reachable(p.inbox)
      end
      result
    else
      {_post_result, %{status: code} = response} = e ->
        if is_nil(p.unreachable_since) do
          Instances.set_unreachable(p.inbox)
        end
        Logger.metadata(activity: p.activity_id, inbox: p.inbox, status: code)
        Logger.error("Publisher failed to inbox #{p.inbox} with status #{code}")
        case response do
          %{status: 400} -> {:cancel, :bad_request}
          %{status: 403} -> {:cancel, :forbidden}
          %{status: 404} -> {:cancel, :not_found}
          %{status: 410} -> {:cancel, :not_found}
          _ -> {:error, e}
        end
      {:error, {:already_started, _}} ->
        Logger.debug("Publisher snoozing worker job due worker :already_started race condition")
        connection_pool_snooze()
      {:error, :pool_full} ->
        Logger.debug("Publisher snoozing worker job due to full connection pool")
        connection_pool_snooze()
      e ->
        if is_nil(p.unreachable_since) do
          Instances.set_unreachable(p.inbox)
        end
        Logger.metadata(activity: p.activity_id, inbox: p.inbox)
        Logger.error("Publisher failed to inbox #{p.inbox} #{inspect(e)}")
        {:error, e}
    end
  end
  defp connection_pool_snooze, do: {:snooze, 3}
  defp signature_host(%URI{port: port, scheme: scheme, host: host}) do
    if port == URI.default_port(scheme) do
      host
    else
      "#{host}:#{port}"
    end
  end
  def should_federate?(nil, _), do: false
  def should_federate?(_, true), do: true
  def should_federate?(inbox, _) do
    %{host: host} = URI.parse(inbox)
    quarantined_instances =
      Config.get([:instance, :quarantined_instances], [])
      |> Pleroma.Web.ActivityPub.MRF.instance_list_from_tuples()
      |> Pleroma.Web.ActivityPub.MRF.subdomains_regex()
    !Pleroma.Web.ActivityPub.MRF.subdomain_match?(quarantined_instances, host)
  end
  @spec recipients(User.t(), Activity.t()) :: [[User.t()]]
  defp recipients(actor, activity) do
    followers =
      if actor.follower_address in activity.recipients do
        User.get_external_followers(actor)
      else
        []
      end
    fetchers =
      with %Activity{data: %{"type" => "Delete"}} <- activity,
           %Object{id: object_id} <- Object.normalize(activity, fetch: false),
           fetchers <- User.get_delivered_users_by_object_id(object_id),
           _ <- Delivery.delete_all_by_object_id(object_id) do
        fetchers
      else
        _ ->
          []
      end
    mentioned = remote_users(actor, activity)
    non_mentioned = (followers ++ fetchers) -- mentioned
    [mentioned, non_mentioned]
  end
  defp get_cc_ap_ids(ap_id, recipients) do
    host = Map.get(URI.parse(ap_id), :host)
    recipients
    |> Enum.filter(fn %User{ap_id: ap_id} -> Map.get(URI.parse(ap_id), :host) == host end)
    |> Enum.map(& &1.ap_id)
  end
  defp maybe_use_sharedinbox(%User{shared_inbox: nil, inbox: inbox}), do: inbox
  defp maybe_use_sharedinbox(%User{shared_inbox: shared_inbox}), do: shared_inbox
  @doc """
  Determine a user inbox to use based on heuristics.  These heuristics
  are based on an approximation of the ``sharedInbox`` rules in the
  [ActivityPub specification][ap-sharedinbox].
  Please do not edit this function (or its children) without reading
  the spec, as editing the code is likely to introduce some breakage
  without some familiarity.
     [ap-sharedinbox]: https://www.w3.org/TR/activitypub/#shared-inbox-delivery
  """
  def determine_inbox(
        %Activity{data: activity_data},
        %User{inbox: inbox} = user
      ) do
    to = activity_data["to"] || []
    cc = activity_data["cc"] || []
    type = activity_data["type"]
    cond do
      type == "Delete" ->
        maybe_use_sharedinbox(user)
      Pleroma.Constants.as_public() in to || Pleroma.Constants.as_public() in cc ->
        maybe_use_sharedinbox(user)
      length(to) + length(cc) > 1 ->
        maybe_use_sharedinbox(user)
      true ->
        inbox
    end
  end
  @doc """
  Publishes an activity with BCC to all relevant peers.
  """
  def publish(%User{} = actor, %{data: %{"bcc" => bcc}} = activity)
      when is_list(bcc) and bcc != [] do
    public = public?(activity)
    [priority_recipients, recipients] = recipients(actor, activity)
    inboxes =
      [priority_recipients, recipients]
      |> Enum.map(fn recipients ->
        recipients
        |> Enum.map(fn %User{} = user ->
          determine_inbox(activity, user)
        end)
        |> Enum.uniq()
        |> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
        |> Instances.filter_reachable()
      end)
    Repo.checkout(fn ->
      Enum.each(inboxes, fn inboxes ->
        Enum.each(inboxes, fn {inbox, unreachable_since} ->
          %User{ap_id: ap_id} = Enum.find(recipients, fn actor -> actor.inbox == inbox end)
          # Get all the recipients on the same host and add them to cc. Otherwise, a remote
          # instance would only accept a first message for the first recipient and ignore the rest.
          cc = get_cc_ap_ids(ap_id, recipients)
          __MODULE__.enqueue_one(%{
            inbox: inbox,
            cc: cc,
            activity_id: activity.id,
            unreachable_since: unreachable_since
          })
        end)
      end)
    end)
  end
  # Publishes an activity to all relevant peers.
  def publish(%User{} = actor, %Activity{} = activity) do
    public = public?(activity)
    if public && Config.get([:instance, :allow_relay]) do
      Logger.debug(fn -> "Relaying #{activity.data["id"]} out" end)
      Relay.publish(activity)
    end
    [priority_inboxes, inboxes] =
      recipients(actor, activity)
      |> Enum.map(fn recipients ->
        recipients
        |> Enum.map(fn %User{} = user ->
          determine_inbox(activity, user)
        end)
        |> Enum.uniq()
        |> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
      end)
    inboxes = inboxes -- priority_inboxes
    [{priority_inboxes, 0}, {inboxes, 1}]
    |> Enum.each(fn {inboxes, priority} ->
      inboxes
      |> Instances.filter_reachable()
      |> Enum.each(fn {inbox, unreachable_since} ->
        __MODULE__.enqueue_one(
          %{
            inbox: inbox,
            activity_id: activity.id,
            unreachable_since: unreachable_since
          },
          priority: priority
        )
      end)
    end)
    :ok
  end
  def gather_webfinger_links(%User{} = user) do
    [
      %{"rel" => "self", "type" => "application/activity+json", "href" => user.ap_id},
      %{
        "rel" => "self",
        "type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
        "href" => user.ap_id
      },
      %{
        "rel" => "http://ostatus.org/schema/1.0/subscribe",
        "template" => "#{Pleroma.Web.Endpoint.url()}/ostatus_subscribe?acct={uri}"
      }
    ]
  end
  def gather_nodeinfo_protocol_names, do: ["activitypub"]
end