git.squeep.com Git - akkoma/blob - lib/pleroma/web/emoji_api/emoji_api_controller.ex

   1 defmodule Pleroma.Web.EmojiAPI.EmojiAPIController do
   2   use Pleroma.Web, :controller
   3
   4   require Logger
   5
   6   def reload(conn, _params) do
   7     Pleroma.Emoji.reload()
   8
   9     conn |> text("ok")
  10   end
  11
  12   @emoji_dir_path Path.join(
  13                     Pleroma.Config.get!([:instance, :static_dir]),
  14                     "emoji"
  15                   )
  16
  17   @cache_seconds_per_file Pleroma.Config.get!([:emoji, :shared_pack_cache_seconds_per_file])
  18
  19   def list_packs(conn, _params) do
  20     pack_infos =
  21       case File.ls(@emoji_dir_path) do
  22         {:error, _} ->
  23           %{}
  24
  25         {:ok, results} ->
  26           results
  27           |> Enum.filter(fn file ->
  28             dir_path = Path.join(@emoji_dir_path, file)
  29             # Filter to only use the pack.yml packs
  30             File.dir?(dir_path) and File.exists?(Path.join(dir_path, "pack.yml"))
  31           end)
  32           |> Enum.map(fn pack_name ->
  33             pack_path = Path.join(@emoji_dir_path, pack_name)
  34             pack_file = Path.join(pack_path, "pack.yml")
  35
  36             {pack_name, RelaxYaml.Decoder.read_from_file(pack_file)}
  37           end)
  38           # Transform into a map of pack-name => pack-data
  39           # Check if all the files are in place and can be sent
  40           |> Enum.map(fn {name, pack} ->
  41             pack_path = Path.join(@emoji_dir_path, name)
  42
  43             if can_download?(pack, pack_path) do
  44               archive_for_sha = make_archive(name, pack, pack_path)
  45               archive_sha = :crypto.hash(:sha256, archive_for_sha) |> Base.encode16()
  46
  47               {name,
  48                pack
  49                |> put_in(["pack", "can-download"], true)
  50                |> put_in(["pack", "download-sha256"], archive_sha)}
  51             else
  52               {name,
  53                pack
  54                |> put_in(["pack", "can-download"], false)}
  55             end
  56           end)
  57           |> Enum.into(%{})
  58       end
  59
  60     conn |> json(pack_infos)
  61   end
  62
  63   defp can_download?(pack, pack_path) do
  64     # If the pack is set as shared, check if it can be downloaded
  65     # That means that when asked, the pack can be packed and sent to the remote
  66     # Otherwise, they'd have to download it from external-src
  67     pack["pack"]["share-files"] and
  68       Enum.all?(pack["files"], fn {_, path} ->
  69         File.exists?(Path.join(pack_path, path))
  70       end)
  71   end
  72
  73   defp create_archive_and_cache(name, pack, pack_dir, md5) do
  74     files =
  75       ['pack.yml'] ++
  76         (pack["files"] |> Enum.map(fn {_, path} -> to_charlist(path) end))
  77
  78     {:ok, {_, zip_result}} = :zip.zip('#{name}.zip', files, [:memory, cwd: to_charlist(pack_dir)])
  79
  80     cache_ms = :timer.seconds(@cache_seconds_per_file * Enum.count(files))
  81
  82     Cachex.put!(
  83       :emoji_packs_cache,
  84       name,
  85       # if pack.yml MD5 changes, the cache is not valid anymore
  86       %{pack_yml_md5: md5, pack_data: zip_result},
  87       # Add a minute to cache time for every file in the pack
  88       ttl: cache_ms
  89     )
  90
  91     Logger.debug("Create an archive for the '#{name}' emoji pack, \
  92 keeping it in cache for #{div(cache_ms, 1000)}s")
  93
  94     zip_result
  95   end
  96
  97   defp make_archive(name, pack, pack_dir) do
  98     # Having a different pack.yml md5 invalidates cache
  99     pack_yml_md5 = :crypto.hash(:md5, File.read!(Path.join(pack_dir, "pack.yml")))
 100
 101     maybe_cached_pack = Cachex.get!(:emoji_packs_cache, name)
 102
 103     zip_result =
 104       if is_nil(maybe_cached_pack) do
 105         create_archive_and_cache(name, pack, pack_dir, pack_yml_md5)
 106       else
 107         if maybe_cached_pack[:pack_yml_md5] == pack_yml_md5 do
 108           Logger.debug("Using cache for the '#{name}' shared emoji pack")
 109
 110           maybe_cached_pack[:pack_data]
 111         else
 112           create_archive_and_cache(name, pack, pack_dir, pack_yml_md5)
 113         end
 114       end
 115
 116     zip_result
 117   end
 118
 119   def download_shared(conn, %{"name" => name}) do
 120     pack_dir = Path.join(@emoji_dir_path, name)
 121     pack_yaml = Path.join(pack_dir, "pack.yml")
 122
 123     if File.exists?(pack_yaml) do
 124       pack = RelaxYaml.Decoder.read_from_file(pack_yaml)
 125
 126       if can_download?(pack, pack_dir) do
 127         zip_result = make_archive(name, pack, pack_dir)
 128
 129         conn
 130         |> send_download({:binary, zip_result}, filename: "#{name}.zip")
 131       else
 132         {:error,
 133          conn
 134          |> put_status(:forbidden)
 135          |> text("Pack #{name} cannot be downloaded from this instance, either pack sharing\
 136            was disabled for this pack or some files are missing")}
 137       end
 138     else
 139       {:error,
 140        conn
 141        |> put_status(:not_found)
 142        |> text("Pack #{name} does not exist")}
 143     end
 144   end
 145
 146   def download_from(conn, %{"instance_address" => address, "pack_name" => name} = data) do
 147     list_uri = "#{address}/api/pleroma/emoji/packs/list"
 148
 149     list = Tesla.get!(list_uri).body |> Jason.decode!()
 150     full_pack = list[name]
 151     pfiles = full_pack["files"]
 152     pack = full_pack["pack"]
 153
 154     pack_info_res =
 155       cond do
 156         pack["share-files"] && pack["can-download"] ->
 157           {:ok,
 158            %{
 159              sha: pack["download-sha256"],
 160              uri: "#{address}/api/pleroma/emoji/packs/download_shared/#{name}"
 161            }}
 162
 163         pack["fallback-src"] ->
 164           {:ok,
 165            %{
 166              sha: pack["fallback-src-sha256"],
 167              uri: pack["fallback-src"],
 168              fallback: true
 169            }}
 170
 171         true ->
 172           {:error, "The pack was not set as shared and there is no fallback src to download from"}
 173       end
 174
 175     case pack_info_res do
 176       {:ok, %{sha: sha, uri: uri} = pinfo} ->
 177         sha = Base.decode16!(sha)
 178         emoji_archive = Tesla.get!(uri).body
 179
 180         got_sha = :crypto.hash(:sha256, emoji_archive)
 181
 182         if got_sha == sha do
 183           local_name = data["as"] || name
 184           pack_dir = Path.join(@emoji_dir_path, local_name)
 185           File.mkdir_p!(pack_dir)
 186
 187           files =
 188             ['pack.yml'] ++
 189               (pfiles |> Enum.map(fn {_, path} -> to_charlist(path) end))
 190
 191           {:ok, _} = :zip.unzip(emoji_archive, cwd: to_charlist(pack_dir), file_list: files)
 192
 193           # Fallback URL might not contain a pack.yml file. Put on we have if there's none
 194           if pinfo[:fallback] do
 195             yaml_path = Path.join(pack_dir, "pack.yml")
 196
 197             unless File.exists?(yaml_path) do
 198               File.write!(yaml_path, RelaxYaml.Encoder.encode(full_pack, []))
 199             end
 200           end
 201
 202           conn |> text("ok")
 203         else
 204           conn
 205           |> put_status(:internal_server_error)
 206           |> text("SHA256 for the pack doesn't match the one sent by the server")
 207         end
 208
 209       {:error, e} ->
 210         conn |> put_status(:internal_server_error) |> text(e)
 211     end
 212   end
 213
 214   def delete(conn, %{"name" => name}) do
 215     pack_dir = Path.join(@emoji_dir_path, name)
 216
 217     case File.rm_rf(pack_dir) do
 218       {:ok, _} ->
 219         conn |> text("ok")
 220
 221       {:error, _} ->
 222         conn |> put_status(:internal_server_error) |> text("Couldn't delete the pack #{name}")
 223     end
 224   end
 225 end