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