git.squeep.com Git - akkoma/blob - lib/pleroma/workers/attachments_cleanup_worker.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.Workers.AttachmentsCleanupWorker do
   6   import Ecto.Query
   7
   8   alias Pleroma.Object
   9   alias Pleroma.Repo
  10
  11   use Pleroma.Workers.WorkerHelper, queue: "attachments_cleanup"
  12
  13   @impl Oban.Worker
  14   def perform(
  15         %{
  16           "op" => "cleanup_attachments",
  17           "object" => %{"data" => %{"attachment" => [_ | _] = attachments, "actor" => actor}}
  18         },
  19         _job
  20       ) do
  21     hrefs =
  22       Enum.flat_map(attachments, fn attachment ->
  23         Enum.map(attachment["url"], & &1["href"])
  24       end)
  25
  26     names = Enum.map(attachments, & &1["name"])
  27
  28     uploader = Pleroma.Config.get([Pleroma.Upload, :uploader])
  29
  30     prefix =
  31       case Pleroma.Config.get([Pleroma.Upload, :base_url]) do
  32         nil -> "media"
  33         _ -> ""
  34       end
  35
  36     base_url =
  37       String.trim_trailing(
  38         Pleroma.Config.get([Pleroma.Upload, :base_url], Pleroma.Web.base_url()),
  39         "/"
  40       )
  41
  42     # find all objects for copies of the attachments, name and actor doesn't matter here
  43     object_ids_and_hrefs =
  44       from(o in Object,
  45         where:
  46           fragment(
  47             "to_jsonb(array(select jsonb_array_elements((?)#>'{url}') ->> 'href' where jsonb_typeof((?)#>'{url}') = 'array'))::jsonb \\?| (?)",
  48             o.data,
  49             o.data,
  50             ^hrefs
  51           )
  52       )
  53       # The query above can be time consumptive on large instances until we
  54       # refactor how uploads are stored
  55       |> Repo.all(timeout: :infinity)
  56       # we should delete 1 object for any given attachment, but don't delete
  57       # files if there are more than 1 object for it
  58       |> Enum.reduce(%{}, fn %{
  59                                id: id,
  60                                data: %{
  61                                  "url" => [%{"href" => href}],
  62                                  "actor" => obj_actor,
  63                                  "name" => name
  64                                }
  65                              },
  66                              acc ->
  67         Map.update(acc, href, %{id: id, count: 1}, fn val ->
  68           case obj_actor == actor and name in names do
  69             true ->
  70               # set id of the actor's object that will be deleted
  71               %{val | id: id, count: val.count + 1}
  72
  73             false ->
  74               # another actor's object, just increase count to not delete file
  75               %{val | count: val.count + 1}
  76           end
  77         end)
  78       end)
  79       |> Enum.map(fn {href, %{id: id, count: count}} ->
  80         # only delete files that have single instance
  81         with 1 <- count do
  82           href
  83           |> String.trim_leading("#{base_url}/#{prefix}")
  84           |> uploader.delete_file()
  85
  86           {id, href}
  87         else
  88           _ -> {id, nil}
  89         end
  90       end)
  91
  92     object_ids = Enum.map(object_ids_and_hrefs, fn {id, _} -> id end)
  93
  94     from(o in Object, where: o.id in ^object_ids)
  95     |> Repo.delete_all()
  96
  97     object_ids_and_hrefs
  98     |> Enum.filter(fn {_, href} -> not is_nil(href) end)
  99     |> Enum.map(&elem(&1, 1))
 100     |> Pleroma.Web.MediaProxy.Invalidation.purge()
 101
 102     {:ok, :success}
 103   end
 104
 105   def perform(%{"op" => "cleanup_attachments", "object" => _object}, _job), do: {:ok, :skip}
 106 end