git.squeep.com Git - akkoma/blob - lib/pleroma/web/streamer.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.Streamer do
   6   require Logger
   7
   8   alias Pleroma.Activity
   9   alias Pleroma.Chat.MessageReference
  10   alias Pleroma.Config
  11   alias Pleroma.Conversation.Participation
  12   alias Pleroma.Notification
  13   alias Pleroma.Object
  14   alias Pleroma.User
  15   alias Pleroma.Web.ActivityPub.ActivityPub
  16   alias Pleroma.Web.ActivityPub.Visibility
  17   alias Pleroma.Web.CommonAPI
  18   alias Pleroma.Web.OAuth.Token
  19   alias Pleroma.Web.Plugs.OAuthScopesPlug
  20   alias Pleroma.Web.StreamerView
  21
  22   @mix_env Mix.env()
  23   @registry Pleroma.Web.StreamerRegistry
  24
  25   def registry, do: @registry
  26
  27   @public_streams ["public", "public:local", "public:media", "public:local:media"]
  28   @user_streams ["user", "user:notification", "direct", "user:pleroma_chat"]
  29
  30   @doc "Expands and authorizes a stream, and registers the process for streaming."
  31   @spec get_topic_and_add_socket(
  32           stream :: String.t(),
  33           User.t() | nil,
  34           Token.t() | nil,
  35           Map.t() | nil
  36         ) ::
  37           {:ok, topic :: String.t()} | {:error, :bad_topic} | {:error, :unauthorized}
  38   def get_topic_and_add_socket(stream, user, oauth_token, params \\ %{}) do
  39     with {:ok, topic} <- get_topic(stream, user, oauth_token, params) do
  40       add_socket(topic, user)
  41     end
  42   end
  43
  44   @doc "Expand and authorizes a stream"
  45   @spec get_topic(stream :: String.t(), User.t() | nil, Token.t() | nil, Map.t()) ::
  46           {:ok, topic :: String.t()} | {:error, :bad_topic}
  47   def get_topic(stream, user, oauth_token, params \\ %{})
  48
  49   # Allow all public steams.
  50   def get_topic(stream, _user, _oauth_token, _params) when stream in @public_streams do
  51     {:ok, stream}
  52   end
  53
  54   # Allow all hashtags streams.
  55   def get_topic("hashtag", _user, _oauth_token, %{"tag" => tag} = _params) do
  56     {:ok, "hashtag:" <> tag}
  57   end
  58
  59   # Allow remote instance streams.
  60   def get_topic("public:remote", _user, _oauth_token, %{"instance" => instance} = _params) do
  61     {:ok, "public:remote:" <> instance}
  62   end
  63
  64   def get_topic("public:remote:media", _user, _oauth_token, %{"instance" => instance} = _params) do
  65     {:ok, "public:remote:media:" <> instance}
  66   end
  67
  68   # Expand user streams.
  69   def get_topic(
  70         stream,
  71         %User{id: user_id} = user,
  72         %Token{user_id: user_id} = oauth_token,
  73         _params
  74       )
  75       when stream in @user_streams do
  76     # Note: "read" works for all user streams (not mentioning it since it's an ancestor scope)
  77     required_scopes =
  78       if stream == "user:notification" do
  79         ["read:notifications"]
  80       else
  81         ["read:statuses"]
  82       end
  83
  84     if OAuthScopesPlug.filter_descendants(required_scopes, oauth_token.scopes) == [] do
  85       {:error, :unauthorized}
  86     else
  87       {:ok, stream <> ":" <> to_string(user.id)}
  88     end
  89   end
  90
  91   def get_topic(stream, _user, _oauth_token, _params) when stream in @user_streams do
  92     {:error, :unauthorized}
  93   end
  94
  95   # List streams.
  96   def get_topic(
  97         "list",
  98         %User{id: user_id} = user,
  99         %Token{user_id: user_id} = oauth_token,
 100         %{"list" => id}
 101       ) do
 102     cond do
 103       OAuthScopesPlug.filter_descendants(["read", "read:lists"], oauth_token.scopes) == [] ->
 104         {:error, :unauthorized}
 105
 106       Pleroma.List.get(id, user) ->
 107         {:ok, "list:" <> to_string(id)}
 108
 109       true ->
 110         {:error, :bad_topic}
 111     end
 112   end
 113
 114   def get_topic("list", _user, _oauth_token, _params) do
 115     {:error, :unauthorized}
 116   end
 117
 118   def get_topic(_stream, _user, _oauth_token, _params) do
 119     {:error, :bad_topic}
 120   end
 121
 122   @doc "Registers the process for streaming. Use `get_topic/3` to get the full authorized topic."
 123   def add_socket(topic, user) do
 124     if should_env_send?() do
 125       auth? = if user, do: true
 126       Registry.register(@registry, topic, auth?)
 127     end
 128
 129     {:ok, topic}
 130   end
 131
 132   def remove_socket(topic) do
 133     if should_env_send?(), do: Registry.unregister(@registry, topic)
 134   end
 135
 136   def stream(topics, items) do
 137     if should_env_send?() do
 138       for topic <- List.wrap(topics), item <- List.wrap(items) do
 139         spawn(fn -> do_stream(topic, item) end)
 140       end
 141     end
 142   end
 143
 144   def filtered_by_user?(user, item, streamed_type \\ :activity)
 145
 146   def filtered_by_user?(%User{} = user, %Activity{} = item, streamed_type) do
 147     %{block: blocked_ap_ids, mute: muted_ap_ids, reblog_mute: reblog_muted_ap_ids} =
 148       User.outgoing_relationships_ap_ids(user, [:block, :mute, :reblog_mute])
 149
 150     recipient_blocks = MapSet.new(blocked_ap_ids ++ muted_ap_ids)
 151     recipients = MapSet.new(item.recipients)
 152     domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
 153
 154     with parent <- Object.normalize(item, fetch: false) || item,
 155          true <- Enum.all?([blocked_ap_ids, muted_ap_ids], &(item.actor not in &1)),
 156          true <- item.data["type"] != "Announce" || item.actor not in reblog_muted_ap_ids,
 157          true <-
 158            !(streamed_type == :activity && item.data["type"] == "Announce" &&
 159                parent.data["actor"] == user.ap_id),
 160          true <- Enum.all?([blocked_ap_ids, muted_ap_ids], &(parent.data["actor"] not in &1)),
 161          true <- MapSet.disjoint?(recipients, recipient_blocks),
 162          %{host: item_host} <- URI.parse(item.actor),
 163          %{host: parent_host} <- URI.parse(parent.data["actor"]),
 164          false <- Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, item_host),
 165          false <- Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, parent_host),
 166          true <- thread_containment(item, user),
 167          false <- CommonAPI.thread_muted?(user, parent) do
 168       false
 169     else
 170       _ -> true
 171     end
 172   end
 173
 174   def filtered_by_user?(%User{} = user, %Notification{activity: activity}, _) do
 175     filtered_by_user?(user, activity, :notification)
 176   end
 177
 178   defp do_stream("direct", item) do
 179     recipient_topics =
 180       User.get_recipients_from_activity(item)
 181       |> Enum.map(fn %{id: id} -> "direct:#{id}" end)
 182
 183     Enum.each(recipient_topics, fn user_topic ->
 184       Logger.debug("Trying to push direct message to #{user_topic}\n\n")
 185       push_to_socket(user_topic, item)
 186     end)
 187   end
 188
 189   defp do_stream("follow_relationship", item) do
 190     text = StreamerView.render("follow_relationships_update.json", item)
 191     user_topic = "user:#{item.follower.id}"
 192
 193     Logger.debug("Trying to push follow relationship update to #{user_topic}\n\n")
 194
 195     Registry.dispatch(@registry, user_topic, fn list ->
 196       Enum.each(list, fn {pid, _auth} ->
 197         send(pid, {:text, text})
 198       end)
 199     end)
 200   end
 201
 202   defp do_stream("participation", participation) do
 203     user_topic = "direct:#{participation.user_id}"
 204     Logger.debug("Trying to push a conversation participation to #{user_topic}\n\n")
 205
 206     push_to_socket(user_topic, participation)
 207   end
 208
 209   defp do_stream("list", item) do
 210     # filter the recipient list if the activity is not public, see #270.
 211     recipient_lists =
 212       case Visibility.is_public?(item) do
 213         true ->
 214           Pleroma.List.get_lists_from_activity(item)
 215
 216         _ ->
 217           Pleroma.List.get_lists_from_activity(item)
 218           |> Enum.filter(fn list ->
 219             owner = User.get_cached_by_id(list.user_id)
 220
 221             Visibility.visible_for_user?(item, owner)
 222           end)
 223       end
 224
 225     recipient_topics =
 226       recipient_lists
 227       |> Enum.map(fn %{id: id} -> "list:#{id}" end)
 228
 229     Enum.each(recipient_topics, fn list_topic ->
 230       Logger.debug("Trying to push message to #{list_topic}\n\n")
 231       push_to_socket(list_topic, item)
 232     end)
 233   end
 234
 235   defp do_stream(topic, %Notification{} = item)
 236        when topic in ["user", "user:notification"] do
 237     Registry.dispatch(@registry, "#{topic}:#{item.user_id}", fn list ->
 238       Enum.each(list, fn {pid, _auth} ->
 239         send(pid, {:render_with_user, StreamerView, "notification.json", item})
 240       end)
 241     end)
 242   end
 243
 244   defp do_stream(topic, {user, %MessageReference{} = cm_ref})
 245        when topic in ["user", "user:pleroma_chat"] do
 246     topic = "#{topic}:#{user.id}"
 247
 248     text = StreamerView.render("chat_update.json", %{chat_message_reference: cm_ref})
 249
 250     Registry.dispatch(@registry, topic, fn list ->
 251       Enum.each(list, fn {pid, _auth} ->
 252         send(pid, {:text, text})
 253       end)
 254     end)
 255   end
 256
 257   defp do_stream("user", item) do
 258     Logger.debug("Trying to push to users")
 259
 260     recipient_topics =
 261       User.get_recipients_from_activity(item)
 262       |> Enum.map(fn %{id: id} -> "user:#{id}" end)
 263
 264     Enum.each(recipient_topics, fn topic ->
 265       push_to_socket(topic, item)
 266     end)
 267   end
 268
 269   defp do_stream(topic, item) do
 270     Logger.debug("Trying to push to #{topic}")
 271     Logger.debug("Pushing item to #{topic}")
 272     push_to_socket(topic, item)
 273   end
 274
 275   defp push_to_socket(topic, %Participation{} = participation) do
 276     rendered = StreamerView.render("conversation.json", participation)
 277
 278     Registry.dispatch(@registry, topic, fn list ->
 279       Enum.each(list, fn {pid, _} ->
 280         send(pid, {:text, rendered})
 281       end)
 282     end)
 283   end
 284
 285   defp push_to_socket(topic, %Activity{
 286          data: %{"type" => "Delete", "deleted_activity_id" => deleted_activity_id}
 287        }) do
 288     rendered = Jason.encode!(%{event: "delete", payload: to_string(deleted_activity_id)})
 289
 290     Registry.dispatch(@registry, topic, fn list ->
 291       Enum.each(list, fn {pid, _} ->
 292         send(pid, {:text, rendered})
 293       end)
 294     end)
 295   end
 296
 297   defp push_to_socket(_topic, %Activity{data: %{"type" => "Delete"}}), do: :noop
 298
 299   defp push_to_socket(topic, item) do
 300     anon_render = StreamerView.render("update.json", item)
 301
 302     Registry.dispatch(@registry, topic, fn list ->
 303       Enum.each(list, fn {pid, auth?} ->
 304         if auth? do
 305           send(pid, {:render_with_user, StreamerView, "update.json", item})
 306         else
 307           send(pid, {:text, anon_render})
 308         end
 309       end)
 310     end)
 311   end
 312
 313   defp thread_containment(_activity, %User{skip_thread_containment: true}), do: true
 314
 315   defp thread_containment(activity, user) do
 316     if Config.get([:instance, :skip_thread_containment]) do
 317       true
 318     else
 319       ActivityPub.contain_activity(activity, user)
 320     end
 321   end
 322
 323   # In test environement, only return true if the registry is started.
 324   # In benchmark environment, returns false.
 325   # In any other environment, always returns true.
 326   cond do
 327     @mix_env == :test ->
 328       def should_env_send? do
 329         case Process.whereis(@registry) do
 330           nil ->
 331             false
 332
 333           pid ->
 334             Process.alive?(pid)
 335         end
 336       end
 337
 338     @mix_env == :benchmark ->
 339       def should_env_send?, do: false
 340
 341     true ->
 342       def should_env_send?, do: true
 343   end
 344 end