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.Repo
  10   alias Pleroma.Signature
  11   alias Pleroma.Web.ActivityPub.InternalFetchActor
  12   alias Pleroma.Web.ActivityPub.Transmogrifier
  13
  14   require Logger
  15   require Pleroma.Constants
  16
  17   defp touch_changeset(changeset) do
  18     updated_at =
  19       NaiveDateTime.utc_now()
  20       |> NaiveDateTime.truncate(:second)
  21
  22     Ecto.Changeset.put_change(changeset, :updated_at, updated_at)
  23   end
  24
  25   defp maybe_reinject_internal_fields(data, %{data: %{} = old_data}) do
  26     internal_fields = Map.take(old_data, Pleroma.Constants.object_internal_fields())
  27
  28     Map.merge(data, internal_fields)
  29   end
  30
  31   defp maybe_reinject_internal_fields(data, _), do: data
  32
  33   @spec reinject_object(struct(), map()) :: {:ok, Object.t()} | {:error, any()}
  34   defp reinject_object(struct, data) do
  35     Logger.debug("Reinjecting object #{data["id"]}")
  36
  37     with data <- Transmogrifier.fix_object(data),
  38          data <- maybe_reinject_internal_fields(data, struct),
  39          changeset <- Object.change(struct, %{data: data}),
  40          changeset <- touch_changeset(changeset),
  41          {:ok, object} <- Repo.insert_or_update(changeset) do
  42       {:ok, object}
  43     else
  44       e ->
  45         Logger.error("Error while processing object: #{inspect(e)}")
  46         {:error, e}
  47     end
  48   end
  49
  50   def refetch_object(%Object{data: %{"id" => id}} = object) do
  51     with {:local, false} <- {:local, String.starts_with?(id, Pleroma.Web.base_url() <> "/")},
  52          {:ok, data} <- fetch_and_contain_remote_object_from_id(id),
  53          {:ok, object} <- reinject_object(object, data) do
  54       {:ok, object}
  55     else
  56       {:local, true} -> object
  57       e -> {:error, e}
  58     end
  59   end
  60
  61   # TODO:
  62   # This will create a Create activity, which we need internally at the moment.
  63   def fetch_object_from_id(id, options \\ []) do
  64     with {:fetch_object, nil} <- {:fetch_object, Object.get_cached_by_ap_id(id)},
  65          {:fetch, {:ok, data}} <- {:fetch, fetch_and_contain_remote_object_from_id(id)},
  66          {:normalize, nil} <- {:normalize, Object.normalize(data, false)},
  67          params <- prepare_activity_params(data),
  68          {:containment, :ok} <- {:containment, Containment.contain_origin(id, params)},
  69          {:transmogrifier, {:ok, activity}} <-
  70            {:transmogrifier, Transmogrifier.handle_incoming(params, options)},
  71          {:object, _data, %Object{} = object} <-
  72            {:object, data, Object.normalize(activity, false)} do
  73       {:ok, object}
  74     else
  75       {:containment, _} ->
  76         {:error, "Object containment failed."}
  77
  78       {:transmogrifier, {:error, {:reject, nil}}} ->
  79         {:reject, nil}
  80
  81       {:transmogrifier, _} ->
  82         {:error, "Transmogrifier failure."}
  83
  84       {:object, data, nil} ->
  85         reinject_object(%Object{}, data)
  86
  87       {:normalize, object = %Object{}} ->
  88         {:ok, object}
  89
  90       {:fetch_object, %Object{} = object} ->
  91         {:ok, object}
  92
  93       {:fetch, {:error, error}} ->
  94         {:error, error}
  95
  96       e ->
  97         e
  98     end
  99   end
 100
 101   defp prepare_activity_params(data) do
 102     %{
 103       "type" => "Create",
 104       "to" => data["to"],
 105       "cc" => data["cc"],
 106       # Should we seriously keep this attributedTo thing?
 107       "actor" => data["actor"] || data["attributedTo"],
 108       "object" => data
 109     }
 110   end
 111
 112   def fetch_object_from_id!(id, options \\ []) do
 113     with {:ok, object} <- fetch_object_from_id(id, options) do
 114       object
 115     else
 116       {:error, %Tesla.Mock.Error{}} ->
 117         nil
 118
 119       e ->
 120         Logger.error("Error while fetching #{id}: #{inspect(e)}")
 121         nil
 122     end
 123   end
 124
 125   defp make_signature(id, date) do
 126     uri = URI.parse(id)
 127
 128     signature =
 129       InternalFetchActor.get_actor()
 130       |> Signature.sign(%{
 131         "(request-target)": "get #{uri.path}",
 132         host: uri.host,
 133         date: date
 134       })
 135
 136     [{:Signature, signature}]
 137   end
 138
 139   defp sign_fetch(headers, id, date) do
 140     if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
 141       headers ++ make_signature(id, date)
 142     else
 143       headers
 144     end
 145   end
 146
 147   defp maybe_date_fetch(headers, date) do
 148     if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
 149       headers ++ [{:Date, date}]
 150     else
 151       headers
 152     end
 153   end
 154
 155   def fetch_and_contain_remote_object_from_id(id) when is_binary(id) do
 156     Logger.info("Fetching object #{id} via AP")
 157
 158     date = Pleroma.Signature.signed_date()
 159
 160     headers =
 161       [{:Accept, "application/activity+json"}]
 162       |> maybe_date_fetch(date)
 163       |> sign_fetch(id, date)
 164
 165     Logger.debug("Fetch headers: #{inspect(headers)}")
 166
 167     with {:scheme, true} <- {:scheme, String.starts_with?(id, "http")},
 168          {:ok, %{body: body, status: code}} when code in 200..299 <- HTTP.get(id, headers),
 169          {:ok, data} <- Jason.decode(body),
 170          :ok <- Containment.contain_origin_from_id(id, data) do
 171       {:ok, data}
 172     else
 173       {:ok, %{status: code}} when code in [404, 410] ->
 174         {:error, "Object has been deleted"}
 175
 176       {:scheme, _} ->
 177         {:error, "Unsupported URI scheme"}
 178
 179       {:error, e} ->
 180         {:error, e}
 181
 182       e ->
 183         {:error, e}
 184     end
 185   end
 186
 187   def fetch_and_contain_remote_object_from_id(%{"id" => id}),
 188     do: fetch_and_contain_remote_object_from_id(id)
 189
 190   def fetch_and_contain_remote_object_from_id(_id), do: {:error, "id must be a string"}
 191 end