Fix ObjectAgePolicyTest
[akkoma] / lib / pleroma / web / activity_pub / publisher.ex
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
4
5 defmodule Pleroma.Web.ActivityPub.Publisher do
6 alias Pleroma.Activity
7 alias Pleroma.Config
8 alias Pleroma.Delivery
9 alias Pleroma.HTTP
10 alias Pleroma.Instances
11 alias Pleroma.Object
12 alias Pleroma.Repo
13 alias Pleroma.User
14 alias Pleroma.Web.ActivityPub.Relay
15 alias Pleroma.Web.ActivityPub.Transmogrifier
16
17 require Pleroma.Constants
18
19 import Pleroma.Web.ActivityPub.Visibility
20
21 @behaviour Pleroma.Web.Federator.Publisher
22
23 require Logger
24
25 @moduledoc """
26 ActivityPub outgoing federation module.
27 """
28
29 @doc """
30 Determine if an activity can be represented by running it through Transmogrifier.
31 """
32 def is_representable?(%Activity{} = activity) do
33 with {:ok, _data} <- Transmogrifier.prepare_outgoing(activity.data) do
34 true
35 else
36 _e ->
37 false
38 end
39 end
40
41 @doc """
42 Publish a single message to a peer. Takes a struct with the following
43 parameters set:
44
45 * `inbox`: the inbox to publish to
46 * `json`: the JSON message body representing the ActivityPub message
47 * `actor`: the actor which is signing the message
48 * `id`: the ActivityStreams URI of the message
49 """
50 def publish_one(%{inbox: inbox, json: json, actor: %User{} = actor, id: id} = params) do
51 Logger.debug("Federating #{id} to #{inbox}")
52 %{host: host, path: path} = URI.parse(inbox)
53
54 digest = "SHA-256=" <> (:crypto.hash(:sha256, json) |> Base.encode64())
55
56 date = Pleroma.Signature.signed_date()
57
58 signature =
59 Pleroma.Signature.sign(actor, %{
60 "(request-target)": "post #{path}",
61 host: host,
62 "content-length": byte_size(json),
63 digest: digest,
64 date: date
65 })
66
67 with {:ok, %{status: code}} when code in 200..299 <-
68 result =
69 HTTP.post(
70 inbox,
71 json,
72 [
73 {"Content-Type", "application/activity+json"},
74 {"Date", date},
75 {"signature", signature},
76 {"digest", digest}
77 ]
78 ) do
79 if !Map.has_key?(params, :unreachable_since) || params[:unreachable_since],
80 do: Instances.set_reachable(inbox)
81
82 result
83 else
84 {_post_result, response} ->
85 unless params[:unreachable_since], do: Instances.set_unreachable(inbox)
86 {:error, response}
87 end
88 end
89
90 def publish_one(%{actor_id: actor_id} = params) do
91 actor = User.get_cached_by_id(actor_id)
92
93 params
94 |> Map.delete(:actor_id)
95 |> Map.put(:actor, actor)
96 |> publish_one()
97 end
98
99 defp should_federate?(inbox, public) do
100 if public do
101 true
102 else
103 %{host: host} = URI.parse(inbox)
104
105 quarantined_instances =
106 Config.get([:instance, :quarantined_instances], [])
107 |> Pleroma.Web.ActivityPub.MRF.subdomains_regex()
108
109 !Pleroma.Web.ActivityPub.MRF.subdomain_match?(quarantined_instances, host)
110 end
111 end
112
113 @spec recipients(User.t(), Activity.t()) :: list(User.t()) | []
114 defp recipients(actor, activity) do
115 followers =
116 if actor.follower_address in activity.recipients do
117 User.get_external_followers(actor)
118 else
119 []
120 end
121
122 fetchers =
123 with %Activity{data: %{"type" => "Delete"}} <- activity,
124 %Object{id: object_id} <- Object.normalize(activity),
125 fetchers <- User.get_delivered_users_by_object_id(object_id),
126 _ <- Delivery.delete_all_by_object_id(object_id) do
127 fetchers
128 else
129 _ ->
130 []
131 end
132
133 Pleroma.Web.Federator.Publisher.remote_users(actor, activity) ++ followers ++ fetchers
134 end
135
136 defp get_cc_ap_ids(ap_id, recipients) do
137 host = Map.get(URI.parse(ap_id), :host)
138
139 recipients
140 |> Enum.filter(fn %User{ap_id: ap_id} -> Map.get(URI.parse(ap_id), :host) == host end)
141 |> Enum.map(& &1.ap_id)
142 end
143
144 defp maybe_use_sharedinbox(%User{shared_inbox: nil, inbox: inbox}), do: inbox
145 defp maybe_use_sharedinbox(%User{shared_inbox: shared_inbox}), do: shared_inbox
146
147 @doc """
148 Determine a user inbox to use based on heuristics. These heuristics
149 are based on an approximation of the ``sharedInbox`` rules in the
150 [ActivityPub specification][ap-sharedinbox].
151
152 Please do not edit this function (or its children) without reading
153 the spec, as editing the code is likely to introduce some breakage
154 without some familiarity.
155
156 [ap-sharedinbox]: https://www.w3.org/TR/activitypub/#shared-inbox-delivery
157 """
158 def determine_inbox(
159 %Activity{data: activity_data},
160 %User{inbox: inbox} = user
161 ) do
162 to = activity_data["to"] || []
163 cc = activity_data["cc"] || []
164 type = activity_data["type"]
165
166 cond do
167 type == "Delete" ->
168 maybe_use_sharedinbox(user)
169
170 Pleroma.Constants.as_public() in to || Pleroma.Constants.as_public() in cc ->
171 maybe_use_sharedinbox(user)
172
173 length(to) + length(cc) > 1 ->
174 maybe_use_sharedinbox(user)
175
176 true ->
177 inbox
178 end
179 end
180
181 @doc """
182 Publishes an activity with BCC to all relevant peers.
183 """
184
185 def publish(%User{} = actor, %{data: %{"bcc" => bcc}} = activity)
186 when is_list(bcc) and bcc != [] do
187 public = is_public?(activity)
188 {:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
189
190 recipients = recipients(actor, activity)
191
192 inboxes =
193 recipients
194 |> Enum.filter(&User.ap_enabled?/1)
195 |> Enum.map(fn actor -> actor.inbox end)
196 |> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
197 |> Instances.filter_reachable()
198
199 Repo.checkout(fn ->
200 Enum.each(inboxes, fn {inbox, unreachable_since} ->
201 %User{ap_id: ap_id} = Enum.find(recipients, fn actor -> actor.inbox == inbox end)
202
203 # Get all the recipients on the same host and add them to cc. Otherwise, a remote
204 # instance would only accept a first message for the first recipient and ignore the rest.
205 cc = get_cc_ap_ids(ap_id, recipients)
206
207 json =
208 data
209 |> Map.put("cc", cc)
210 |> Jason.encode!()
211
212 Pleroma.Web.Federator.Publisher.enqueue_one(__MODULE__, %{
213 inbox: inbox,
214 json: json,
215 actor_id: actor.id,
216 id: activity.data["id"],
217 unreachable_since: unreachable_since
218 })
219 end)
220 end)
221 end
222
223 @doc """
224 Publishes an activity to all relevant peers.
225 """
226 def publish(%User{} = actor, %Activity{} = activity) do
227 public = is_public?(activity)
228
229 if public && Config.get([:instance, :allow_relay]) do
230 Logger.debug(fn -> "Relaying #{activity.data["id"]} out" end)
231 Relay.publish(activity)
232 end
233
234 {:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
235 json = Jason.encode!(data)
236
237 recipients(actor, activity)
238 |> Enum.filter(fn user -> User.ap_enabled?(user) end)
239 |> Enum.map(fn %User{} = user ->
240 determine_inbox(activity, user)
241 end)
242 |> Enum.uniq()
243 |> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
244 |> Instances.filter_reachable()
245 |> Enum.each(fn {inbox, unreachable_since} ->
246 Pleroma.Web.Federator.Publisher.enqueue_one(
247 __MODULE__,
248 %{
249 inbox: inbox,
250 json: json,
251 actor_id: actor.id,
252 id: activity.data["id"],
253 unreachable_since: unreachable_since
254 }
255 )
256 end)
257 end
258
259 def gather_webfinger_links(%User{} = user) do
260 [
261 %{"rel" => "self", "type" => "application/activity+json", "href" => user.ap_id},
262 %{
263 "rel" => "self",
264 "type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
265 "href" => user.ap_id
266 },
267 %{
268 "rel" => "http://ostatus.org/schema/1.0/subscribe",
269 "template" => "#{Pleroma.Web.base_url()}/ostatus_subscribe?acct={uri}"
270 }
271 ]
272 end
273
274 def gather_nodeinfo_protocol_names, do: ["activitypub"]
275 end