Merge remote-tracking branch 'origin' into follower-hiding

lib/mix/tasks/make_moderator.ex

@@ -8,7 +8,7 @@ defmodule Mix.Tasks.SetModerator do
   """
 
   use Mix.Task
-  import Mix.Ecto
+  import Ecto.Changeset
   alias Pleroma.{Repo, User}
 
   def run([nickname | rest]) do
@@ -21,14 +21,15 @@ defmodule Mix.Tasks.SetModerator do
       end
 
     with %User{local: true} = user <- User.get_by_nickname(nickname) do
-      info =
-        user.info
-        |> Map.put("is_moderator", !!moderator)
+      info_cng = User.Info.admin_api_update(user.info, %{is_moderator: !!moderator})
 
-      cng = User.info_changeset(user, %{info: info})
-      {:ok, user} = User.update_and_set_cache(cng)
+      user_cng =
+        Ecto.Changeset.change(user)
+        |> put_embed(:info, info_cng)
 
-      IO.puts("Moderator status of #{nickname}: #{user.info["is_moderator"]}")
+      {:ok, user} = User.update_and_set_cache(user_cng)
+
+      IO.puts("Moderator status of #{nickname}: #{user.info.is_moderator}")
     else
       _ ->
         IO.puts("No local user #{nickname}")

lib/mix/tasks/sample_psql.eex

@@ -4,3 +4,4 @@ CREATE DATABASE pleroma_dev OWNER pleroma;
 --Extensions made by ecto.migrate that need superuser access
 CREATE EXTENSION IF NOT EXISTS citext;
 CREATE EXTENSION IF NOT EXISTS pg_trgm;
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";

lib/mix/tasks/set_admin.ex

@@ -1,5 +1,6 @@
 defmodule Mix.Tasks.SetAdmin do
   use Mix.Task
+  import Ecto.Changeset
   alias Pleroma.User
 
   @doc """
@@ -9,21 +10,22 @@ defmodule Mix.Tasks.SetAdmin do
   def run([nickname | rest]) do
     Application.ensure_all_started(:pleroma)
 
-    status =
+    admin =
       case rest do
-        [status] -> status == "true"
+        [admin] -> admin == "true"
         _ -> true
       end
 
     with %User{local: true} = user <- User.get_by_nickname(nickname) do
-      info =
-        user.info
-        |> Map.put("is_admin", !!status)
+      info_cng = User.Info.admin_api_update(user.info, %{is_admin: !!admin})
 
-      cng = User.info_changeset(user, %{info: info})
-      {:ok, user} = User.update_and_set_cache(cng)
+      user_cng =
+        Ecto.Changeset.change(user)
+        |> put_embed(:info, info_cng)
 
-      IO.puts("Admin status of #{nickname}: #{user.info["is_admin"]}")
+      {:ok, user} = User.update_and_set_cache(user_cng)
+
+      IO.puts("Admin status of #{nickname}: #{user.info.is_admin}")
     else
       _ ->
         IO.puts("No local user #{nickname}")

lib/mix/tasks/set_locked.ex

@@ -10,11 +10,11 @@ defmodule Mix.Tasks.SetLocked do
   """
 
   use Mix.Task
-  import Mix.Ecto
+  import Ecto.Changeset
   alias Pleroma.{Repo, User}
 
   def run([nickname | rest]) do
-    ensure_started(Repo, [])
+    Application.ensure_all_started(:pleroma)
 
     locked =
       case rest do
@@ -23,14 +23,15 @@ defmodule Mix.Tasks.SetLocked do
       end
 
     with %User{local: true} = user <- User.get_by_nickname(nickname) do
-      info =
-        user.info
-        |> Map.put("locked", !!locked)
+      info_cng = User.Info.profile_update(user.info, %{locked: !!locked})
 
-      cng = User.info_changeset(user, %{info: info})
-      user = Repo.update!(cng)
+      user_cng =
+        Ecto.Changeset.change(user)
+        |> put_embed(:info, info_cng)
 
-      IO.puts("locked status of #{nickname}: #{user.info["locked"]}")
+      {:ok, user} = User.update_and_set_cache(user_cng)
+
+      IO.puts("Locked status of #{nickname}: #{user.info.locked}")
     else
       _ ->
         IO.puts("No local user #{nickname}")

lib/pleroma/http/connection.ex

@@ -0,0 +1,27 @@
+defmodule Pleroma.HTTP.Connection do
+  @moduledoc """
+  Connection for http-requests.
+  """
+
+  @hackney_options [pool: :default]
+  @adapter Application.get_env(:tesla, :adapter)
+
+  @doc """
+  Configure a client connection
+
+  # Returns
+
+  Tesla.Env.client
+  """
+  @spec new(Keyword.t()) :: Tesla.Env.client()
+  def new(opts \\ []) do
+    Tesla.client([], {@adapter, hackney_options(opts)})
+  end
+
+  # fetch Hackney options
+  #
+  defp hackney_options(opts \\ []) do
+    options = Keyword.get(opts, :adapter, [])
+    @hackney_options ++ options
+  end
+end

lib/pleroma/http/http.ex

@@ -1,14 +1,42 @@
 defmodule Pleroma.HTTP do
-  require HTTPoison
+  @moduledoc """
 
+  """
+
+  alias Pleroma.HTTP.Connection
+  alias Pleroma.HTTP.RequestBuilder, as: Builder
+
+  @doc """
+  Builds and perform http request.
+
+  # Arguments:
+  `method` - :get, :post, :put, :delete
+  `url`
+  `body`
+  `headers` - a keyworld list of headers, e.g. `[{"content-type", "text/plain"}]`
+  `options` - custom, per-request middleware or adapter options
+
+  # Returns:
+  `{:ok, %Tesla.Env{}}` or `{:error, error}`
+
+  """
   def request(method, url, body \\ "", headers \\ [], options \\ []) do
     options =
       process_request_options(options)
       |> process_sni_options(url)
 
-    HTTPoison.request(method, url, body, headers, options)
+    %{}
+    |> Builder.method(method)
+    |> Builder.headers(headers)
+    |> Builder.opts(options)
+    |> Builder.url(url)
+    |> Builder.add_param(:body, :body, body)
+    |> Enum.into([])
+    |> (&Tesla.request(Connection.new(), &1)).()
   end
 
+  defp process_sni_options(options, nil), do: options
+
   defp process_sni_options(options, url) do
     uri = URI.parse(url)
     host = uri.host |> to_charlist()
@@ -22,7 +50,7 @@ defmodule Pleroma.HTTP do
   def process_request_options(options) do
     config = Application.get_env(:pleroma, :http, [])
     proxy = Keyword.get(config, :proxy_url, nil)
-    options = options ++ [hackney: [pool: :default]]
+    options = options ++ [adapter: [pool: :default]]
 
     case proxy do
       nil -> options
@@ -30,8 +58,19 @@ defmodule Pleroma.HTTP do
     end
   end
 
-  def get(url, headers \\ [], options \\ []), do: request(:get, url, "", headers, options)
+  @doc """
+  Performs GET request.
 
+  See `Pleroma.HTTP.request/5`
+  """
+  def get(url, headers \\ [], options \\ []),
+    do: request(:get, url, "", headers, options)
+
+  @doc """
+  Performs POST request.
+
+  See `Pleroma.HTTP.request/5`
+  """
   def post(url, body, headers \\ [], options \\ []),
     do: request(:post, url, body, headers, options)
 end

lib/pleroma/http/request_builder.ex

@@ -0,0 +1,126 @@
+defmodule Pleroma.HTTP.RequestBuilder do
+  @moduledoc """
+  Helper functions for building Tesla requests
+  """
+
+  @doc """
+  Specify the request method when building a request
+
+  ## Parameters
+
+  - request (Map) - Collected request options
+  - m (atom) - Request method
+
+  ## Returns
+
+  Map
+  """
+  @spec method(map(), atom) :: map()
+  def method(request, m) do
+    Map.put_new(request, :method, m)
+  end
+
+  @doc """
+  Specify the request method when building a request
+
+  ## Parameters
+
+  - request (Map) - Collected request options
+  - u (String) - Request URL
+
+  ## Returns
+
+  Map
+  """
+  @spec url(map(), String.t()) :: map()
+  def url(request, u) do
+    Map.put_new(request, :url, u)
+  end
+
+  @doc """
+  Add headers to the request
+  """
+  @spec headers(map(), list(tuple)) :: map()
+  def headers(request, h) do
+    Map.put_new(request, :headers, h)
+  end
+
+  @doc """
+  Add custom, per-request middleware or adapter options to the request
+  """
+  @spec opts(map(), Keyword.t()) :: map()
+  def opts(request, options) do
+    Map.put_new(request, :opts, options)
+  end
+
+  @doc """
+  Add optional parameters to the request
+
+  ## Parameters
+
+  - request (Map) - Collected request options
+  - definitions (Map) - Map of parameter name to parameter location.
+  - options (KeywordList) - The provided optional parameters
+
+  ## Returns
+
+  Map
+  """
+  @spec add_optional_params(map(), %{optional(atom) => atom}, keyword()) :: map()
+  def add_optional_params(request, _, []), do: request
+
+  def add_optional_params(request, definitions, [{key, value} | tail]) do
+    case definitions do
+      %{^key => location} ->
+        request
+        |> add_param(location, key, value)
+        |> add_optional_params(definitions, tail)
+
+      _ ->
+        add_optional_params(request, definitions, tail)
+    end
+  end
+
+  @doc """
+  Add optional parameters to the request
+
+  ## Parameters
+
+  - request (Map) - Collected request options
+  - location (atom) - Where to put the parameter
+  - key (atom) - The name of the parameter
+  - value (any) - The value of the parameter
+
+  ## Returns
+
+  Map
+  """
+  @spec add_param(map(), atom, atom, any()) :: map()
+  def add_param(request, :body, :body, value), do: Map.put(request, :body, value)
+
+  def add_param(request, :body, key, value) do
+    request
+    |> Map.put_new_lazy(:body, &Tesla.Multipart.new/0)
+    |> Map.update!(
+      :body,
+      &Tesla.Multipart.add_field(&1, key, Poison.encode!(value),
+        headers: [{:"Content-Type", "application/json"}]
+      )
+    )
+  end
+
+  def add_param(request, :file, name, path) do
+    request
+    |> Map.put_new_lazy(:body, &Tesla.Multipart.new/0)
+    |> Map.update!(:body, &Tesla.Multipart.add_file(&1, path, name: name))
+  end
+
+  def add_param(request, :form, name, value) do
+    request
+    |> Map.update(:body, %{name => value}, &Map.put(&1, name, value))
+  end
+
+  def add_param(request, location, key, value) do
+    Map.update(request, location, [{key, value}], &(&1 ++ [{key, value}]))
+  end
+end

lib/pleroma/plugs/oauth_plug.ex

@@ -1,30 +1,68 @@
 defmodule Pleroma.Plugs.OAuthPlug do
   import Plug.Conn
-  alias Pleroma.User
-  alias Pleroma.Repo
-  alias Pleroma.Web.OAuth.Token
+  import Ecto.Query
 
-  def init(options) do
-    options
-  end
+  alias Pleroma.{
+    User,
+    Repo,
+    Web.OAuth.Token
+  }
+
+  @realm_reg Regex.compile!("Bearer\:?\s+(.*)$", "i")
+
+  def init(options), do: options
 
   def call(%{assigns: %{user: %User{}}} = conn, _), do: conn
 
   def call(conn, _) do
-    token =
-      case get_req_header(conn, "authorization") do
-        ["Bearer " <> header] -> header
-        _ -> get_session(conn, :oauth_token)
-      end
-
-    with token when not is_nil(token) <- token,
-         %Token{user_id: user_id} <- Repo.get_by(Token, token: token),
-         %User{} = user <- Repo.get(User, user_id),
-         false <- !!user.info.deactivated do
-      conn
-      |> assign(:user, user)
+    with {:ok, token} <- fetch_token(conn),
+         {:ok, user} <- fetch_user(token) do
+      assign(conn, :user, user)
     else
       _ -> conn
     end
   end
+
+  # Gets user by token
+  #
+  @spec fetch_user(String.t()) :: {:ok, User.t()} | nil
+  defp fetch_user(token) do
+    query = from(q in Token, where: q.token == ^token, preload: [:user])
+
+    with %Token{user: %{info: %{deactivated: false} = _} = user} <- Repo.one(query) do
+      {:ok, user}
+    end
+  end
+
+  # Gets token from session by :oauth_token key
+  #
+  @spec fetch_token_from_session(Plug.Conn.t()) :: :no_token_found | {:ok, String.t()}
+  defp fetch_token_from_session(conn) do
+    case get_session(conn, :oauth_token) do
+      nil -> :no_token_found
+      token -> {:ok, token}
+    end
+  end
+
+  # Gets token from headers
+  #
+  @spec fetch_token(Plug.Conn.t()) :: :no_token_found | {:ok, String.t()}
+  defp fetch_token(%Plug.Conn{} = conn) do
+    headers = get_req_header(conn, "authorization")
+
+    with :no_token_found <- fetch_token(headers),
+         do: fetch_token_from_session(conn)
+  end
+
+  @spec fetch_token(Keyword.t()) :: :no_token_found | {:ok, String.t()}
+  defp fetch_token([]), do: :no_token_found
+
+  defp fetch_token([token | tail]) do
+    trimmed_token = String.trim(token)
+
+    case Regex.run(@realm_reg, trimmed_token) do
+      [_, match] -> {:ok, String.trim(match)}
+      _ -> fetch_token(tail)
+    end
+  end
 end

lib/pleroma/uploaders/mdii.ex

@@ -20,7 +20,7 @@ defmodule Pleroma.Uploaders.MDII do
     extension = String.split(upload.name, ".") |> List.last()
     query = "#{cgi}?#{extension}"
 
-    with {:ok, %{status_code: 200, body: body}} <- @httpoison.post(query, file_data) do
+    with {:ok, %{status: 200, body: body}} <- @httpoison.post(query, file_data) do
       remote_file_name = String.split(body) |> List.first()
       public_url = "#{files}/#{remote_file_name}.#{extension}"
       {:ok, {:url, public_url}}

lib/pleroma/uploaders/swift/keystone.ex

@@ -25,10 +25,10 @@ defmodule Pleroma.Uploaders.Swift.Keystone do
            ["Content-Type": "application/json"],
            hackney: [:insecure]
          ) do
-      {:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
+      {:ok, %Tesla.Env{status: 200, body: body}} ->
         body["access"]["token"]["id"]
 
-      {:ok, %HTTPoison.Response{status_code: _}} ->
+      {:ok, %Tesla.Env{status: _}} ->
         ""
     end
   end

lib/pleroma/uploaders/swift/swift.ex

@@ -13,10 +13,10 @@ defmodule Pleroma.Uploaders.Swift.Client do
     token = Pleroma.Uploaders.Swift.Keystone.get_token()
 
     case put("#{filename}", body, "X-Auth-Token": token, "Content-Type": content_type) do
-      {:ok, %HTTPoison.Response{status_code: 201}} ->
+      {:ok, %Tesla.Env{status: 201}} ->
         {:ok, {:file, filename}}
 
-      {:ok, %HTTPoison.Response{status_code: 401}} ->
+      {:ok, %Tesla.Env{status: 401}} ->
         {:error, "Unauthorized, Bad Token"}
 
       {:error, _} ->

lib/pleroma/user.ex

@@ -4,6 +4,8 @@ defmodule Pleroma.User do
   import Ecto.{Changeset, Query}
   alias Pleroma.{Repo, User, Object, Web, Activity, Notification}
   alias Comeonin.Pbkdf2
+  alias Pleroma.Formatter
+  alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
   alias Pleroma.Web.{OStatus, Websub, OAuth}
   alias Pleroma.Web.ActivityPub.{Utils, ActivityPub}
 
@@ -175,6 +177,7 @@ defmodule Pleroma.User do
       |> validate_format(:email, @email_regex)
       |> validate_length(:bio, max: 1000)
       |> validate_length(:name, min: 1, max: 100)
+      |> put_change(:info, %Pleroma.User.Info{})
 
     if changeset.valid? do
       hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])
@@ -802,4 +805,18 @@ defmodule Pleroma.User do
         :error
     end
   end
+
+  def parse_bio(bio, user \\ %User{info: %{source_data: %{}}}) do
+    mentions = Formatter.parse_mentions(bio)
+    tags = Formatter.parse_tags(bio)
+
+    emoji =
+      (user.info.source_data["tag"] || [])
+      |> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
+      |> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
+        {String.trim(name, ":"), url}
+      end)
+
+    CommonUtils.format_input(bio, mentions, tags, "text/plain") |> Formatter.emojify(emoji)
+  end
 end

lib/pleroma/user/info.ex

@@ -4,7 +4,7 @@ defmodule Pleroma.User.Info do
 
   embedded_schema do
     field(:banner, :map, default: %{})
-    field(:background, :string, default: nil)
+    field(:background, :map, default: %{})
     field(:source_data, :map, default: %{})
     field(:note_count, :integer, default: 0)
     field(:follower_count, :integer, default: 0)
@@ -137,6 +137,7 @@ defmodule Pleroma.User.Info do
       :default_scope,
       :banner,
       :hide_network
+      :background
     ])
   end
 

lib/pleroma/web/activity_pub/activity_pub.ex

@@ -762,7 +762,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
     Logger.info("Fetching #{id} via AP")
 
     with true <- String.starts_with?(id, "http"),
-         {:ok, %{body: body, status_code: code}} when code in 200..299 <-
+         {:ok, %{body: body, status: code}} when code in 200..299 <-
            @httpoison.get(
              id,
              [Accept: "application/activity+json"],

lib/pleroma/web/activity_pub/mrf/simple_policy.ex

@@ -23,7 +23,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicy do
 
   defp check_media_removal(
          %{host: actor_host} = _actor_info,
-         %{"type" => "Create", "object" => %{"attachement" => child_attachment}} = object
+         %{"type" => "Create", "object" => %{"attachment" => child_attachment}} = object
        )
        when length(child_attachment) > 0 do
     object =

lib/pleroma/web/federator/retry_queue.ex

@@ -17,7 +17,15 @@ defmodule Pleroma.Web.Federator.RetryQueue do
   end
 
   def start_link() do
-    GenServer.start_link(__MODULE__, %{delivered: 0, dropped: 0}, name: __MODULE__)
+    enabled = Pleroma.Config.get([:retry_queue, :enabled], false)
+
+    if enabled do
+      Logger.info("Starting retry queue")
+      GenServer.start_link(__MODULE__, %{delivered: 0, dropped: 0}, name: __MODULE__)
+    else
+      Logger.info("Retry queue disabled")
+      :ignore
+    end
   end
 
   def enqueue(data, transport, retries \\ 0) do

lib/pleroma/web/mastodon_api/mastodon_api_controller.ex

@@ -55,7 +55,7 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
     user_params =
       %{}
       |> add_if_present(params, "display_name", :name)
-      |> add_if_present(params, "note", :bio)
+      |> add_if_present(params, "note", :bio, fn value -> {:ok, User.parse_bio(value)} end)
       |> add_if_present(params, "avatar", :avatar, fn value ->
         with %Plug.Upload{} <- value,
              {:ok, object} <- ActivityPub.upload(value, type: :avatar) do
@@ -1181,7 +1181,7 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
       user = user.nickname
       url = String.replace(api, "{{host}}", host) |> String.replace("{{user}}", user)
 
-      with {:ok, %{status_code: 200, body: body}} <-
+      with {:ok, %{status: 200, body: body}} <-
              @httpoison.get(url, [], timeout: timeout, recv_timeout: timeout),
            {:ok, data} <- Jason.decode(body) do
         data2 =

lib/pleroma/web/media_proxy/controller.ex

@@ -5,12 +5,12 @@ defmodule Pleroma.Web.MediaProxy.MediaProxyController do
   @default_proxy_opts [max_body_length: 25 * 1_048_576]
 
   def remote(conn, params = %{"sig" => sig64, "url" => url64}) do
-    with config <- Pleroma.Config.get([:media_proxy]),
+    with config <- Pleroma.Config.get([:media_proxy], []),
          true <- Keyword.get(config, :enabled, false),
          {:ok, url} <- MediaProxy.decode_url(sig64, url64),
          filename <- Path.basename(URI.parse(url).path),
          :ok <- filename_matches(Map.has_key?(params, "filename"), conn.request_path, url) do
-      ReverseProxy.call(conn, url, Keyword.get(config, :proxy_opts, @default_proxy_length))
+      ReverseProxy.call(conn, url, Keyword.get(config, :proxy_opts, @default_proxy_opts))
     else
       false ->
         send_resp(conn, 404, Plug.Conn.Status.reason_phrase(404))

lib/pleroma/web/ostatus/ostatus.ex

@@ -346,13 +346,15 @@ defmodule Pleroma.Web.OStatus do
 
   def fetch_activity_from_atom_url(url) do
     with true <- String.starts_with?(url, "http"),
-         {:ok, %{body: body, status_code: code}} when code in 200..299 <-
+         {:ok, %{body: body, status: code}} when code in 200..299 <-
            @httpoison.get(
              url,
              [Accept: "application/atom+xml"],
              follow_redirect: true,
-             timeout: 10000,
-             recv_timeout: 20000
+             adapter: [
+               timeout: 10000,
+               recv_timeout: 20000
+             ]
            ) do
       Logger.debug("Got document from #{url}, handling...")
       handle_incoming(body)

lib/pleroma/web/salmon/salmon.ex

@@ -158,14 +158,16 @@ defmodule Pleroma.Web.Salmon do
   end
 
   defp send_to_user(%{info: %{salmon: salmon}}, feed, poster) do
-    with {:ok, %{status_code: code}} <-
+    with {:ok, %{status: code}} <-
            poster.(
              salmon,
              feed,
              [{"Content-Type", "application/magic-envelope+xml"}],
-             timeout: 10000,
-             recv_timeout: 20000,
-             hackney: [pool: :default]
+             adapter: [
+               timeout: 10000,
+               recv_timeout: 20000,
+               pool: :default
+             ]
            ) do
       Logger.debug(fn -> "Pushed to #{salmon}, code #{code}" end)
     else

lib/pleroma/web/twitter_api/twitter_api.ex

@@ -132,7 +132,7 @@ defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
     params = %{
       nickname: params["nickname"],
       name: params["fullname"],
-      bio: params["bio"],
+      bio: User.parse_bio(params["bio"]),
       email: params["email"],
       password: params["password"],
       password_confirmation: params["confirm"]

lib/pleroma/web/twitter_api/twitter_api_controller.ex

@@ -462,27 +462,16 @@ defmodule Pleroma.Web.TwitterAPI.Controller do
     User.Info.profile_update(user.info, info_params)
   end
 
-  defp add_profile_emoji(user, params) do
+  defp parse_profile_bio(user, params) do
     if bio = params["description"] do
-      mentions = Formatter.parse_mentions(bio)
-      tags = Formatter.parse_tags(bio)
-
-      emoji =
-        (user.info.source_data["tag"] || [])
-        |> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
-        |> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
-          {String.trim(name, ":"), url}
-        end)
-
-      bio_html = CommonUtils.format_input(bio, mentions, tags, "text/plain")
-      Map.put(params, "bio", bio_html |> Formatter.emojify(emoji))
+      Map.put(params, "bio", User.parse_bio(bio, user))
     else
       params
     end
   end
 
   def update_profile(%{assigns: %{user: user}} = conn, params) do
-    params = add_profile_emoji(user, params)
+    params = parse_profile_bio(user, params)
     info_cng = build_info_cng(user, params)
 
     with changeset <- User.update_changeset(user, params),

lib/pleroma/web/web_finger/web_finger.ex

@@ -220,7 +220,7 @@ defmodule Pleroma.Web.WebFinger do
   end
 
   def find_lrdd_template(domain) do
-    with {:ok, %{status_code: status_code, body: body}} when status_code in 200..299 <-
+    with {:ok, %{status: status, body: body}} when status in 200..299 <-
            @httpoison.get("http://#{domain}/.well-known/host-meta", [], follow_redirect: true) do
       get_template_from_xml(body)
     else
@@ -259,7 +259,7 @@ defmodule Pleroma.Web.WebFinger do
              [Accept: "application/xrd+xml,application/jrd+json"],
              follow_redirect: true
            ),
-         {:ok, %{status_code: status_code, body: body}} when status_code in 200..299 <- response do
+         {:ok, %{status: status, body: body}} when status in 200..299 <- response do
       doc = XML.parse_document(body)
 
       if doc != :error do

lib/pleroma/web/websub/websub.ex

@@ -173,7 +173,7 @@ defmodule Pleroma.Web.Websub do
 
   def gather_feed_data(topic, getter \\ &@httpoison.get/1) do
     with {:ok, response} <- getter.(topic),
-         status_code when status_code in 200..299 <- response.status_code,
+         status when status in 200..299 <- response.status,
          body <- response.body,
          doc <- XML.parse_document(body),
          uri when not is_nil(uri) <- XML.string_from_xpath("/feed/author[1]/uri", doc),
@@ -221,7 +221,7 @@ defmodule Pleroma.Web.Websub do
 
     task = Task.async(websub_checker)
 
-    with {:ok, %{status_code: 202}} <-
+    with {:ok, %{status: 202}} <-
            poster.(websub.hub, {:form, data}, "Content-type": "application/x-www-form-urlencoded"),
          {:ok, websub} <- Task.yield(task, timeout) do
       {:ok, websub}
@@ -257,7 +257,7 @@ defmodule Pleroma.Web.Websub do
     signature = sign(secret || "", xml)
     Logger.info(fn -> "Pushing #{topic} to #{callback}" end)
 
-    with {:ok, %{status_code: code}} <-
+    with {:ok, %{status: code}} <-
            @httpoison.post(
              callback,
              xml,
@@ -265,9 +265,11 @@ defmodule Pleroma.Web.Websub do
                {"Content-Type", "application/atom+xml"},
                {"X-Hub-Signature", "sha1=#{signature}"}
              ],
-             timeout: 10000,
-             recv_timeout: 20000,
-             hackney: [pool: :default]
+             adapter: [
+               timeout: 10000,
+               recv_timeout: 20000,
+               pool: :default
+             ]
            ) do
       Logger.info(fn -> "Pushed to #{callback}, code #{code}" end)
       {:ok, code}