Rename MobilizonWeb to Mobilizon.Web

lib/web/upload/uploader/local.ex

@@ -0,0 +1,67 @@
+# Portions of this file are derived from Pleroma:
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+# Upstream: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/uploaders/local.ex
+
+defmodule Mobilizon.Web.Upload.Uploader.Local do
+  @moduledoc """
+  Local uploader for files
+  """
+
+  @behaviour Mobilizon.Web.Upload.Uploader
+
+  alias Mobilizon.Config
+
+  def get_file(_) do
+    {:ok, {:static_dir, upload_path()}}
+  end
+
+  def put_file(upload) do
+    {path, file} = local_path(upload.path)
+    result_file = Path.join(path, file)
+
+    unless File.exists?(result_file) do
+      File.cp!(upload.tempfile, result_file)
+    end
+
+    :ok
+  end
+
+  def remove_file(path) do
+    with {path, file} <- local_path(path),
+         full_path <- Path.join(path, file),
+         true <- File.exists?(full_path),
+         :ok <- File.rm(full_path),
+         :ok <- remove_folder(path) do
+      {:ok, path}
+    else
+      false -> {:error, "File #{path} doesn't exist"}
+    end
+  end
+
+  defp remove_folder(path) do
+    with {:subfolder, true} <- {:subfolder, path != upload_path()},
+         {:empty_folder, {:ok, [] = _files}} <- {:empty_folder, File.ls(path)} do
+      File.rmdir(path)
+    else
+      {:subfolder, _} -> :ok
+      {:empty_folder, _} -> {:error, "Error: Folder is not empty"}
+    end
+  end
+
+  defp local_path(path) do
+    case Enum.reverse(String.split(path, "/", trim: true)) do
+      [file] ->
+        {upload_path(), file}
+
+      [file | folders] ->
+        path = Path.join([upload_path()] ++ Enum.reverse(folders))
+        File.mkdir_p!(path)
+        {path, file}
+    end
+  end
+
+  def upload_path do
+    Config.get!([__MODULE__, :uploads])
+  end
+end

lib/web/upload/uploader/uploader.ex

@@ -0,0 +1,78 @@
+# Portions of this file are derived from Pleroma:
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social>
+# SPDX-License-Identifier: AGPL-3.0-only
+# Upstream: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/uploaders/uploader.ex
+
+defmodule Mobilizon.Web.Upload.Uploader do
+  @moduledoc """
+  Defines the contract to put and get an uploaded file to any backend.
+  """
+
+  @doc """
+  Instructs how to get the file from the backend.
+
+  Used by `Mobilizon.Web.Plugs.UploadedMedia`.
+  """
+  @type get_method :: {:static_dir, directory :: String.t()} | {:url, url :: String.t()}
+  @callback get_file(file :: String.t()) :: {:ok, get_method()}
+
+  @doc """
+  Put a file to the backend.
+
+  Returns:
+
+  * `:ok` which assumes `{:ok, upload.path}`
+  * `{:ok, spec}` where spec is:
+    * `{:file, filename :: String.t}` to handle reads with `get_file/1` (recommended)
+
+    This allows to correctly proxy or redirect requests to the backend, while allowing to migrate backends without breaking any URL.
+  * `{url, url :: String.t}` to bypass `get_file/2` and use the `url` directly in the activity.
+  * `{:error, String.t}` error information if the file failed to be saved to the backend.
+  * `:wait_callback` will wait for an http post request at `/api/pleroma/upload_callback/:upload_path` and call the uploader's `http_callback/3` method.
+
+  """
+  @type file_spec :: {:file | :url, String.t()}
+  @callback put_file(Mobilizon.Web.Upload.t()) ::
+              :ok | {:ok, file_spec()} | {:error, String.t()} | :wait_callback
+
+  @callback remove_file(file_spec()) :: :ok | {:ok, file_spec()} | {:error, String.t()}
+
+  @callback http_callback(Plug.Conn.t(), Map.t()) ::
+              {:ok, Plug.Conn.t()}
+              | {:ok, Plug.Conn.t(), file_spec()}
+              | {:error, Plug.Conn.t(), String.t()}
+  @optional_callbacks http_callback: 2
+
+  @spec put_file(module(), Mobilizon.Web.Upload.t()) :: {:ok, file_spec()} | {:error, String.t()}
+  def put_file(uploader, upload) do
+    case uploader.put_file(upload) do
+      :ok -> {:ok, {:file, upload.path}}
+      :wait_callback -> handle_callback(uploader, upload)
+      {:ok, _} = ok -> ok
+      {:error, _} = error -> error
+    end
+  end
+
+  def remove_file(uploader, path) do
+    uploader.remove_file(path)
+  end
+
+  defp handle_callback(uploader, upload) do
+    :global.register_name({__MODULE__, upload.path}, self())
+
+    receive do
+      {__MODULE__, pid, conn, params} ->
+        case uploader.http_callback(conn, params) do
+          {:ok, conn, ok} ->
+            send(pid, {__MODULE__, conn})
+            {:ok, ok}
+
+          {:error, conn, error} ->
+            send(pid, {__MODULE__, conn})
+            {:error, error}
+        end
+    after
+      30_000 -> {:error, "Uploader callback timeout"}
+    end
+  end
+end