git.squeep.com Git - akkoma/blob - lib/pleroma/object/fetcher.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Object.Fetcher do
   6   alias Pleroma.HTTP
   7   alias Pleroma.Object
   8   alias Pleroma.Object.Containment
   9   alias Pleroma.Signature
  10   alias Pleroma.Repo
  11   alias Pleroma.Web.ActivityPub.InternalFetchActor
  12   alias Pleroma.Web.ActivityPub.Transmogrifier
  13   alias Pleroma.Web.OStatus
  14
  15   require Logger
  16
  17   defp reinject_object(struct, data) do
  18     Logger.debug("Reinjecting object #{data["id"]}")
  19
  20     with data <- Transmogrifier.fix_object(data),
  21          changeset <- Object.change(struct, %{data: data}),
  22          {:ok, object} <- Repo.insert_or_update(changeset) do
  23       {:ok, object}
  24     else
  25       e ->
  26         Logger.error("Error while processing object: #{inspect(e)}")
  27         {:error, e}
  28     end
  29   end
  30
  31   def refetch_object(%Object{data: %{"id" => id}} = object) do
  32     with {:ok, data} <- fetch_and_contain_remote_object_from_id(id),
  33          {:ok, object} <- reinject_object(object, data) do
  34       {:ok, object}
  35     else
  36       e -> {:error, e}
  37     end
  38   end
  39
  40   # TODO:
  41   # This will create a Create activity, which we need internally at the moment.
  42   def fetch_object_from_id(id, options \\ []) do
  43     if object = Object.get_cached_by_ap_id(id) do
  44       {:ok, object}
  45     else
  46       Logger.info("Fetching #{id} via AP")
  47
  48       with {:fetch, {:ok, data}} <- {:fetch, fetch_and_contain_remote_object_from_id(id)},
  49            {:normalize, nil} <- {:normalize, Object.normalize(data, false)},
  50            params <- %{
  51              "type" => "Create",
  52              "to" => data["to"],
  53              "cc" => data["cc"],
  54              # Should we seriously keep this attributedTo thing?
  55              "actor" => data["actor"] || data["attributedTo"],
  56              "object" => data
  57            },
  58            {:containment, :ok} <- {:containment, Containment.contain_origin(id, params)},
  59            {:ok, activity} <- Transmogrifier.handle_incoming(params, options),
  60            {:object, _data, %Object{} = object} <-
  61              {:object, data, Object.normalize(activity, false)} do
  62         {:ok, object}
  63       else
  64         {:containment, _} ->
  65           {:error, "Object containment failed."}
  66
  67         {:error, {:reject, nil}} ->
  68           {:reject, nil}
  69
  70         {:object, data, nil} ->
  71           reinject_object(%Object{}, data)
  72
  73         {:normalize, object = %Object{}} ->
  74           {:ok, object}
  75
  76         _e ->
  77           # Only fallback when receiving a fetch/normalization error with ActivityPub
  78           Logger.info("Couldn't get object via AP, trying out OStatus fetching...")
  79
  80           # FIXME: OStatus Object Containment?
  81           case OStatus.fetch_activity_from_url(id) do
  82             {:ok, [activity | _]} -> {:ok, Object.normalize(activity, false)}
  83             e -> e
  84           end
  85       end
  86     end
  87   end
  88
  89   def fetch_object_from_id!(id, options \\ []) do
  90     with {:ok, object} <- fetch_object_from_id(id, options) do
  91       object
  92     else
  93       _e ->
  94         nil
  95     end
  96   end
  97
  98   defp make_signature(id, date) do
  99     uri = URI.parse(id)
 100
 101     signature =
 102       InternalFetchActor.get_actor()
 103       |> Signature.sign(%{
 104         "(request-target)": "get #{uri.path}",
 105         host: uri.host,
 106         date: date
 107       })
 108
 109     [{:Signature, signature}]
 110   end
 111
 112   defp sign_fetch(headers, id, date) do
 113     if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
 114       headers ++ make_signature(id, date)
 115     else
 116       headers
 117     end
 118   end
 119
 120   defp maybe_date_fetch(headers, date) do
 121     if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
 122       headers ++ [{:Date, date}]
 123     else
 124       headers
 125     end
 126   end
 127
 128   def fetch_and_contain_remote_object_from_id(id) when is_binary(id) do
 129     Logger.info("Fetching object #{id} via AP")
 130
 131     date = Pleroma.Signature.signed_date()
 132
 133     headers =
 134       [{:Accept, "application/activity+json"}]
 135       |> maybe_date_fetch(date)
 136       |> sign_fetch(id, date)
 137
 138     Logger.debug("Fetch headers: #{inspect(headers)}")
 139
 140     with true <- String.starts_with?(id, "http"),
 141          {:ok, %{body: body, status: code}} when code in 200..299 <- HTTP.get(id, headers),
 142          {:ok, data} <- Jason.decode(body),
 143          :ok <- Containment.contain_origin_from_id(id, data) do
 144       {:ok, data}
 145     else
 146       {:ok, %{status: code}} when code in [404, 410] ->
 147         {:error, "Object has been deleted"}
 148
 149       e ->
 150         {:error, e}
 151     end
 152   end
 153
 154   def fetch_and_contain_remote_object_from_id(%{"id" => id}),
 155     do: fetch_and_contain_remote_object_from_id(id)
 156
 157   def fetch_and_contain_remote_object_from_id(_id), do: {:error, "id must be a string"}
 158 end