Introduce relay

Signed-off-by: Thomas Citharel <tcit@tcit.fr>

lib/mobilizon_web/api/events.ex

@@ -9,6 +9,8 @@ defmodule MobilizonWeb.API.Events do
   alias Mobilizon.Service.ActivityPub.Utils, as: ActivityPubUtils
   alias MobilizonWeb.API.Utils
 
+  @visibility %{"PUBLIC" => :public, "PRIVATE" => :private}
+
   @doc """
   Create an event
   """

lib/mobilizon_web/api/follows.ex

@@ -0,0 +1,51 @@
+defmodule MobilizonWeb.API.Follows do
+  @moduledoc """
+  Common API for following, unfollowing, accepting and rejecting stuff.
+  """
+
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.{Actor, Follower}
+  alias Mobilizon.Service.ActivityPub
+  require Logger
+
+  def follow(%Actor{} = follower, %Actor{} = followed) do
+    case ActivityPub.follow(follower, followed) do
+      {:ok, activity, _} ->
+        {:ok, activity}
+
+      e ->
+        Logger.warn("Error while following actor: #{inspect(e)}")
+        {:error, e}
+    end
+  end
+
+  def unfollow(%Actor{} = follower, %Actor{} = followed) do
+    case ActivityPub.unfollow(follower, followed) do
+      {:ok, activity, _} ->
+        {:ok, activity}
+
+      e ->
+        Logger.warn("Error while unfollowing actor: #{inspect(e)}")
+        {:error, e}
+    end
+  end
+
+  def accept(%Actor{} = follower, %Actor{} = followed) do
+    with %Follower{approved: false, id: follow_id, url: follow_url} = follow <-
+           Actor.following?(follower, followed),
+         activity_follow_url <- "#{MobilizonWeb.Endpoint.url()}/accept/follow/#{follow_id}",
+         data <-
+           ActivityPub.Utils.make_follow_data(followed, follower, follow_url),
+         {:ok, activity, _} <-
+           ActivityPub.accept(
+             %{to: [follower.url], actor: followed.url, object: data},
+             activity_follow_url
+           ),
+         {:ok, %Follower{approved: true}} <- Actors.update_follower(follow, %{"approved" => true}) do
+      {:ok, activity}
+    else
+      %Follower{approved: true} ->
+        {:error, "Follow already accepted"}
+    end
+  end
+end

lib/mobilizon_web/api/utils.ex

@@ -9,7 +9,7 @@ defmodule MobilizonWeb.API.Utils do
   Determines the full audience based on mentions for a public audience
 
   Audience is:
-    * `to` : the mentionned actors, the eventual actor we're replying to and the public
+    * `to` : the mentioned actors, the eventual actor we're replying to and the public
     * `cc` : the actor's followers
   """
   @spec get_to_and_cc(Actor.t(), list(), map(), String.t()) :: {list(), list()}
@@ -72,7 +72,9 @@ defmodule MobilizonWeb.API.Utils do
     end
   end
 
-  def get_to_and_cc(_user, mentions, _inReplyTo, {:list, _}), do: {mentions, []}
+  def get_to_and_cc(_actor, mentions, _inReplyTo, {:list, _}) do
+    {mentions, []}
+  end
 
   #  def get_addressed_users(_, to) when is_list(to) do
   #    Actors.get(to)
@@ -138,7 +140,7 @@ defmodule MobilizonWeb.API.Utils do
            make_content_html(
              content,
              tags,
-             "text/plain"
+             "text/html"
            ),
          mentioned_users <- for({_, mentioned_user} <- mentions, do: mentioned_user.url),
          addressed_users <- get_addressed_users(mentioned_users, nil),

lib/mobilizon_web/controllers/activity_pub_controller.ex

@@ -14,6 +14,19 @@ defmodule MobilizonWeb.ActivityPubController do
 
   action_fallback(:errors)
 
+  plug(:relay_active? when action in [:relay])
+
+  def relay_active?(conn, _) do
+    if Mobilizon.CommonConfig.get([:instance, :allow_relay]) do
+      conn
+    else
+      conn
+      |> put_status(404)
+      |> json("Not found")
+      |> halt()
+    end
+  end
+
   def following(conn, %{"name" => name, "page" => page}) do
     with {page, ""} <- Integer.parse(page),
          %Actor{} = actor <- Actors.get_local_actor_by_name_with_everything(name) do
@@ -67,6 +80,7 @@ defmodule MobilizonWeb.ActivityPubController do
 
   # TODO: Ensure that this inbox is a recipient of the message
   def inbox(%{assigns: %{valid_signature: true}} = conn, params) do
+    Logger.debug("Got something with valid signature inside inbox")
     Federator.enqueue(:incoming_ap_doc, params)
     json(conn, "ok")
   end
@@ -90,19 +104,35 @@ defmodule MobilizonWeb.ActivityPubController do
         "Signature validation error for: #{params["actor"]}, make sure you are forwarding the HTTP Host header!"
       )
 
-      Logger.error(inspect(conn.req_headers))
+      Logger.debug(inspect(conn.req_headers))
     end
 
     json(conn, "error")
   end
 
+  def relay(conn, _params) do
+    with {status, actor} <-
+           Cachex.fetch(
+             :activity_pub,
+             "relay_actor",
+             &Mobilizon.Service.ActivityPub.Relay.get_actor/0
+           ),
+         true <- status in [:ok, :commit] do
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ActorView.render("actor.json", %{actor: actor}))
+    end
+  end
+
   def errors(conn, {:error, :not_found}) do
     conn
     |> put_status(404)
     |> json("Not found")
   end
 
-  def errors(conn, _e) do
+  def errors(conn, e) do
+    Logger.debug(inspect(e))
+
     conn
     |> put_status(500)
     |> json("Unknown Error")

lib/mobilizon_web/http_signature.ex

@@ -10,7 +10,6 @@ defmodule MobilizonWeb.HTTPSignaturePlug do
   Plug to check HTTP Signatures on every incoming request
   """
 
-  alias Mobilizon.Service.HTTPSignatures
   import Plug.Conn
   require Logger
 
@@ -23,32 +22,30 @@ defmodule MobilizonWeb.HTTPSignaturePlug do
   end
 
   def call(conn, _opts) do
-    actor = conn.params["actor"]
-
-    Logger.debug(fn ->
-      "Checking sig for #{actor}"
-    end)
-
     [signature | _] = get_req_header(conn, "signature")
 
-    cond do
-      String.contains?(signature, actor) ->
-        conn =
-          conn
-          |> put_req_header(
-            "(request-target)",
-            String.downcase("#{conn.method}") <> " #{conn.request_path}"
-          )
-
-        assign(conn, :valid_signature, HTTPSignatures.validate_conn(conn))
-
-      signature ->
-        Logger.debug("Signature not from actor")
-        assign(conn, :valid_signature, false)
-
-      true ->
-        Logger.debug("No signature header!")
+    if signature do
+      # set (request-target) header to the appropriate value
+      # we also replace the digest header with the one we computed
+      conn =
         conn
+        |> put_req_header(
+          "(request-target)",
+          String.downcase("#{conn.method}") <> " #{conn.request_path}"
+        )
+
+      conn =
+        if conn.assigns[:digest] do
+          conn
+          |> put_req_header("digest", conn.assigns[:digest])
+        else
+          conn
+        end
+
+      assign(conn, :valid_signature, HTTPSignatures.validate_conn(conn))
+    else
+      Logger.debug("No signature header!")
+      conn
     end
   end
 end

lib/mobilizon_web/router.ex

@@ -18,6 +18,10 @@ defmodule MobilizonWeb.Router do
     plug(MobilizonWeb.HTTPSignaturePlug)
   end
 
+  pipeline :relay do
+    plug(:accepts, ["activity-json", "json"])
+  end
+
   pipeline :activity_pub do
     plug(:accepts, ["activity-json"])
   end
@@ -97,6 +101,13 @@ defmodule MobilizonWeb.Router do
     post("/inbox", ActivityPubController, :inbox)
   end
 
+  scope "/relay", MobilizonWeb do
+    pipe_through(:relay)
+
+    get("/", ActivityPubController, :relay)
+    post("/inbox", ActivityPubController, :inbox)
+  end
+
   scope "/proxy/", MobilizonWeb do
     pipe_through(:remote_media)
 

lib/mobilizon_web/views/activity_pub/actor_view.ex

@@ -12,12 +12,12 @@ defmodule MobilizonWeb.ActivityPub.ActorView do
     public_key = Mobilizon.Service.ActivityPub.Utils.pem_to_public_key_pem(actor.keys)
 
     %{
-      "id" => Actor.build_url(actor.preferred_username, :page),
-      "type" => "Person",
-      "following" => Actor.build_url(actor.preferred_username, :following),
-      "followers" => Actor.build_url(actor.preferred_username, :followers),
-      "inbox" => Actor.build_url(actor.preferred_username, :inbox),
-      "outbox" => Actor.build_url(actor.preferred_username, :outbox),
+      "id" => actor.url,
+      "type" => to_string(actor.type),
+      "following" => actor.following_url,
+      "followers" => actor.followers_url,
+      "inbox" => actor.inbox_url,
+      "outbox" => actor.outbox_url,
       "preferredUsername" => actor.preferred_username,
       "name" => actor.name,
       "summary" => actor.summary,

lib/mobilizon_web/views/error_view.ex

@@ -31,8 +31,8 @@ defmodule MobilizonWeb.ErrorView do
   # template is found, let's render it as 500
   def template_not_found(template, assigns) do
     require Logger
-    Logger.error("Template not found")
-    Logger.error(inspect(template))
+    Logger.warn("Template not found")
+    Logger.debug(inspect(template))
     render("500.html", assigns)
   end
 end

lib/mobilizon_web/views/page_view.ex

@@ -46,24 +46,8 @@ defmodule MobilizonWeb.PageView do
   end
 
   def render("event.activity-json", %{conn: %{assigns: %{object: event}}}) do
-    event = Mobilizon.Service.ActivityPub.Converters.Event.model_to_as(event)
-    {:ok, html, []} = Earmark.as_html(event["summary"])
-
-    %{
-      "type" => "Event",
-      "attributedTo" => event["actor"],
-      "id" => event["id"],
-      "name" => event["title"],
-      "category" => event["category"],
-      "content" => html,
-      "source" => %{
-        "content" => event["summary"],
-        "mediaType" => "text/markdown"
-      },
-      "mediaType" => "text/html",
-      "published" => event["publish_at"],
-      "updated" => event["updated_at"]
-    }
+    event
+    |> Mobilizon.Service.ActivityPub.Converters.Event.model_to_as()
     |> Map.merge(Utils.make_json_ld_header())
   end