No OneTemporary
Actions

Size

52 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/healthcheck.ex b/lib/healthcheck.ex
	index 32aafc210..f97d14432 100644
	--- a/lib/healthcheck.ex
	+++ b/lib/healthcheck.ex
	@@ -1,60 +1,64 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Healthcheck do
	@moduledoc """
	Module collects metrics about app and assign healthy status.
	"""
	alias Pleroma.Healthcheck
	alias Pleroma.Repo

	defstruct pool_size: 0,
	active: 0,
	idle: 0,
	memory_used: 0,
	healthy: true

	@type t :: %__MODULE__{
	pool_size: non_neg_integer(),
	active: non_neg_integer(),
	idle: non_neg_integer(),
	memory_used: number(),
	healthy: boolean()
	}

	@spec system_info() :: t()
	def system_info do
	%Healthcheck{
	memory_used: Float.round(:erlang.memory(:total) / 1024 / 1024, 2)
	}
	\|> assign_db_info()
	\|> check_health()
	end

	defp assign_db_info(healthcheck) do
	database = Pleroma.Config.get([Repo, :database])

	query =
	"select state, count(pid) from pg_stat_activity where datname = '#{database}' group by state;"

	result = Repo.query!(query)
	pool_size = Pleroma.Config.get([Repo, :pool_size])

	db_info =
	Enum.reduce(result.rows, %{active: 0, idle: 0}, fn [state, cnt], states ->
	if state == "active" do
	Map.put(states, :active, states.active + cnt)
	else
	Map.put(states, :idle, states.idle + cnt)
	end
	end)
	\|> Map.put(:pool_size, pool_size)

	Map.merge(healthcheck, db_info)
	end

	@spec check_health(Healthcheck.t()) :: Healthcheck.t()
	def check_health(%{pool_size: pool_size, active: active} = check)
	when active >= pool_size do
	%{check \| healthy: false}
	end

	def check_health(check), do: check
	end
	diff --git a/lib/jason_types.ex b/lib/jason_types.ex
	index d1a7bc7ac..c558aef57 100644
	--- a/lib/jason_types.ex
	+++ b/lib/jason_types.ex
	@@ -1,5 +1,9 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	Postgrex.Types.define(
	Pleroma.PostgresTypes,
	[] ++ Ecto.Adapters.Postgres.extensions(),
	json: Jason
	)
	diff --git a/lib/mix/tasks/pleroma/benchmark.ex b/lib/mix/tasks/pleroma/benchmark.ex
	index d43db7b35..5222cce80 100644
	--- a/lib/mix/tasks/pleroma/benchmark.ex
	+++ b/lib/mix/tasks/pleroma/benchmark.ex
	@@ -1,25 +1,29 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Mix.Tasks.Pleroma.Benchmark do
	import Mix.Pleroma
	use Mix.Task

	def run(["search"]) do
	start_pleroma()

	Benchee.run(%{
	"search" => fn ->
	Pleroma.Activity.search(nil, "cofe")
	end
	})
	end

	def run(["tag"]) do
	start_pleroma()

	Benchee.run(%{
	"tag" => fn ->
	%{"type" => "Create", "tag" => "cofe"}
	\|> Pleroma.Web.ActivityPub.ActivityPub.fetch_public_activities()
	end
	})
	end
	end
	diff --git a/lib/mix/tasks/pleroma/config.ex b/lib/mix/tasks/pleroma/config.ex
	index faa605d9b..a71bcd447 100644
	--- a/lib/mix/tasks/pleroma/config.ex
	+++ b/lib/mix/tasks/pleroma/config.ex
	@@ -1,79 +1,83 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Mix.Tasks.Pleroma.Config do
	use Mix.Task
	import Mix.Pleroma
	alias Pleroma.Repo
	alias Pleroma.Web.AdminAPI.Config
	@shortdoc "Manages the location of the config"
	@moduledoc """
	Manages the location of the config.

	## Transfers config from file to DB.

	mix pleroma.config migrate_to_db

	## Transfers config from DB to file.

	mix pleroma.config migrate_from_db ENV
	"""

	def run(["migrate_to_db"]) do
	start_pleroma()

	if Pleroma.Config.get([:instance, :dynamic_configuration]) do
	Application.get_all_env(:pleroma)
	\|> Enum.reject(fn {k, _v} -> k in [Pleroma.Repo, :env] end)
	\|> Enum.each(fn {k, v} ->
	key = to_string(k) \|> String.replace("Elixir.", "")
	{:ok, _} = Config.update_or_create(%{group: "pleroma", key: key, value: v})
	Mix.shell().info("#{key} is migrated.")
	end)

	Mix.shell().info("Settings migrated.")
	else
	Mix.shell().info(
	"Migration is not allowed by config. You can change this behavior in instance settings."
	)
	end
	end

	def run(["migrate_from_db", env, delete?]) do
	start_pleroma()

	delete? = if delete? == "true", do: true, else: false

	if Pleroma.Config.get([:instance, :dynamic_configuration]) do
	config_path = "config/#{env}.exported_from_db.secret.exs"

	{:ok, file} = File.open(config_path, [:write])
	IO.write(file, "use Mix.Config\r\n")

	Repo.all(Config)
	\|> Enum.each(fn config ->
	mark =
	if String.starts_with?(config.key, "Pleroma.") or
	String.starts_with?(config.key, "Ueberauth"),
	do: ",",
	else: ":"

	IO.write(
	file,
	"config :#{config.group}, #{config.key}#{mark} #{
	inspect(Config.from_binary(config.value))
	}\r\n"
	)

	if delete? do
	{:ok, _} = Repo.delete(config)
	Mix.shell().info("#{config.key} deleted from DB.")
	end
	end)

	File.close(file)
	System.cmd("mix", ["format", config_path])
	else
	Mix.shell().info(
	"Migration is not allowed by config. You can change this behavior in instance settings."
	)
	end
	end
	end
	diff --git a/lib/pleroma/bbs/authenticator.ex b/lib/pleroma/bbs/authenticator.ex
	index a2c153720..79f133ea6 100644
	--- a/lib/pleroma/bbs/authenticator.ex
	+++ b/lib/pleroma/bbs/authenticator.ex
	@@ -1,16 +1,20 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.BBS.Authenticator do
	use Sshd.PasswordAuthenticator
	alias Comeonin.Pbkdf2
	alias Pleroma.User

	def authenticate(username, password) do
	username = to_string(username)
	password = to_string(password)

	with %User{} = user <- User.get_by_nickname(username) do
	Pbkdf2.checkpw(password, user.password_hash)
	else
	_e -> false
	end
	end
	end
	diff --git a/lib/pleroma/bbs/handler.ex b/lib/pleroma/bbs/handler.ex
	index f34be961f..0a381f592 100644
	--- a/lib/pleroma/bbs/handler.ex
	+++ b/lib/pleroma/bbs/handler.ex
	@@ -1,146 +1,150 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.BBS.Handler do
	use Sshd.ShellHandler
	alias Pleroma.Activity
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI

	def on_shell(username, _pubkey, _ip, _port) do
	:ok = IO.puts("Welcome to #{Pleroma.Config.get([:instance, :name])}!")
	user = Pleroma.User.get_cached_by_nickname(to_string(username))
	Logger.debug("#{inspect(user)}")
	loop(run_state(user: user))
	end

	def on_connect(username, ip, port, method) do
	Logger.debug(fn ->
	"""
	Incoming SSH shell #{inspect(self())} requested for #{username} from #{inspect(ip)}:#{
	inspect(port)
	} using #{inspect(method)}
	"""
	end)
	end

	def on_disconnect(username, ip, port) do
	Logger.debug(fn ->
	"Disconnecting SSH shell for #{username} from #{inspect(ip)}:#{inspect(port)}"
	end)
	end

	defp loop(state) do
	self_pid = self()
	counter = state.counter
	prefix = state.prefix
	user = state.user

	input = spawn(fn -> io_get(self_pid, prefix, counter, user.nickname) end)
	wait_input(state, input)
	end

	def puts_activity(activity) do
	status = Pleroma.Web.MastodonAPI.StatusView.render("status.json", %{activity: activity})
	IO.puts("-- #{status.id} by #{status.account.display_name} (#{status.account.acct})")
	IO.puts(HtmlSanitizeEx.strip_tags(status.content))
	IO.puts("")
	end

	def handle_command(state, "help") do
	IO.puts("Available commands:")
	IO.puts("help - This help")
	IO.puts("home - Show the home timeline")
	IO.puts("p <text> - Post the given text")
	IO.puts("r <id> <text> - Reply to the post with the given id")
	IO.puts("quit - Quit")

	state
	end

	def handle_command(%{user: user} = state, "r " <> text) do
	text = String.trim(text)
	[activity_id, rest] = String.split(text, " ", parts: 2)

	with %Activity{} <- Activity.get_by_id(activity_id),
	{:ok, _activity} <-
	CommonAPI.post(user, %{"status" => rest, "in_reply_to_status_id" => activity_id}) do
	IO.puts("Replied!")
	else
	_e -> IO.puts("Could not reply...")
	end

	state
	end

	def handle_command(%{user: user} = state, "p " <> text) do
	text = String.trim(text)

	with {:ok, _activity} <- CommonAPI.post(user, %{"status" => text}) do
	IO.puts("Posted!")
	else
	_e -> IO.puts("Could not post...")
	end

	state
	end

	def handle_command(state, "home") do
	user = state.user

	params =
	%{}
	\|> Map.put("type", ["Create"])
	\|> Map.put("blocking_user", user)
	\|> Map.put("muting_user", user)
	\|> Map.put("user", user)

	activities =
	[user.ap_id \| user.following]
	\|> ActivityPub.fetch_activities(params)

	Enum.each(activities, fn activity ->
	puts_activity(activity)
	end)

	state
	end

	def handle_command(state, command) do
	IO.puts("Unknown command '#{command}'")
	state
	end

	defp wait_input(state, input) do
	receive do
	{:input, ^input, "quit\n"} ->
	IO.puts("Exiting...")

	{:input, ^input, code} when is_binary(code) ->
	code = String.trim(code)

	state = handle_command(state, code)

	loop(%{state \| counter: state.counter + 1})

	{:error, :interrupted} ->
	IO.puts("Caught Ctrl+C...")
	loop(%{state \| counter: state.counter + 1})

	{:input, ^input, msg} ->
	:ok = Logger.warn("received unknown message: #{inspect(msg)}")
	loop(%{state \| counter: state.counter + 1})
	end
	end

	defp run_state(opts) do
	%{prefix: "pleroma", counter: 1, user: opts[:user]}
	end

	defp io_get(pid, prefix, counter, username) do
	prompt = prompt(prefix, counter, username)
	send(pid, {:input, self(), IO.gets(:stdio, prompt)})
	end

	defp prompt(prefix, counter, username) do
	prompt = "#{username}@#{prefix}:#{counter}>"
	prompt <> " "
	end
	end
	diff --git a/lib/pleroma/bookmark.ex b/lib/pleroma/bookmark.ex
	index 7f8fd43b6..d976f949c 100644
	--- a/lib/pleroma/bookmark.ex
	+++ b/lib/pleroma/bookmark.ex
	@@ -1,60 +1,64 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Bookmark do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.FlakeId
	alias Pleroma.Repo
	alias Pleroma.User

	@type t :: %__MODULE__{}

	schema "bookmarks" do
	belongs_to(:user, User, type: FlakeId)
	belongs_to(:activity, Activity, type: FlakeId)

	timestamps()
	end

	@spec create(FlakeId.t(), FlakeId.t()) :: {:ok, Bookmark.t()} \| {:error, Changeset.t()}
	def create(user_id, activity_id) do
	attrs = %{
	user_id: user_id,
	activity_id: activity_id
	}

	%Bookmark{}
	\|> cast(attrs, [:user_id, :activity_id])
	\|> validate_required([:user_id, :activity_id])
	\|> unique_constraint(:activity_id, name: :bookmarks_user_id_activity_id_index)
	\|> Repo.insert()
	end

	@spec for_user_query(FlakeId.t()) :: Ecto.Query.t()
	def for_user_query(user_id) do
	Bookmark
	\|> where(user_id: ^user_id)
	\|> join(:inner, [b], activity in assoc(b, :activity))
	\|> preload([b, a], activity: a)
	end

	def get(user_id, activity_id) do
	Bookmark
	\|> where(user_id: ^user_id)
	\|> where(activity_id: ^activity_id)
	\|> Repo.one()
	end

	@spec destroy(FlakeId.t(), FlakeId.t()) :: {:ok, Bookmark.t()} \| {:error, Changeset.t()}
	def destroy(user_id, activity_id) do
	from(b in Bookmark,
	where: b.user_id == ^user_id,
	where: b.activity_id == ^activity_id
	)
	\|> Repo.one()
	\|> Repo.delete()
	end
	end
	diff --git a/lib/pleroma/config/transfer_task.ex b/lib/pleroma/config/transfer_task.ex
	index cf880aa22..3c13a0558 100644
	--- a/lib/pleroma/config/transfer_task.ex
	+++ b/lib/pleroma/config/transfer_task.ex
	@@ -1,55 +1,59 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Config.TransferTask do
	use Task
	alias Pleroma.Web.AdminAPI.Config

	def start_link do
	load_and_update_env()
	if Pleroma.Config.get(:env) == :test, do: Ecto.Adapters.SQL.Sandbox.checkin(Pleroma.Repo)
	:ignore
	end

	def load_and_update_env do
	if Pleroma.Config.get([:instance, :dynamic_configuration]) and
	Ecto.Adapters.SQL.table_exists?(Pleroma.Repo, "config") do
	for_restart =
	Pleroma.Repo.all(Config)
	\|> Enum.map(&update_env(&1))

	# We need to restart applications for loaded settings take effect
	for_restart
	\|> Enum.reject(&(&1 in [:pleroma, :ok]))
	\|> Enum.each(fn app ->
	Application.stop(app)
	:ok = Application.start(app)
	end)
	end
	end

	defp update_env(setting) do
	try do
	key =
	if String.starts_with?(setting.key, "Pleroma.") do
	"Elixir." <> setting.key
	else
	setting.key
	end

	group = String.to_existing_atom(setting.group)

	Application.put_env(
	group,
	String.to_existing_atom(key),
	Config.from_binary(setting.value)
	)

	group
	rescue
	e ->
	require Logger

	Logger.warn(
	"updating env causes error, key: #{inspect(setting.key)}, error: #{inspect(e)}"
	)
	end
	end
	end
	diff --git a/lib/pleroma/instances.ex b/lib/pleroma/instances.ex
	index fa5043bc5..1b05d573c 100644
	--- a/lib/pleroma/instances.ex
	+++ b/lib/pleroma/instances.ex
	@@ -1,36 +1,40 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Instances do
	@moduledoc "Instances context."

	@adapter Pleroma.Instances.Instance

	defdelegate filter_reachable(urls_or_hosts), to: @adapter
	defdelegate reachable?(url_or_host), to: @adapter
	defdelegate set_reachable(url_or_host), to: @adapter
	defdelegate set_unreachable(url_or_host, unreachable_since \\ nil), to: @adapter

	def set_consistently_unreachable(url_or_host),
	do: set_unreachable(url_or_host, reachability_datetime_threshold())

	def reachability_datetime_threshold do
	federation_reachability_timeout_days =
	Pleroma.Config.get([:instance, :federation_reachability_timeout_days], 0)

	if federation_reachability_timeout_days > 0 do
	NaiveDateTime.add(
	NaiveDateTime.utc_now(),
	-federation_reachability_timeout_days * 24 * 3600,
	:second
	)
	else
	~N[0000-01-01 00:00:00]
	end
	end

	def host(url_or_host) when is_binary(url_or_host) do
	if url_or_host =~ ~r/^http/i do
	URI.parse(url_or_host).host
	else
	url_or_host
	end
	end
	end
	diff --git a/lib/pleroma/instances/instance.ex b/lib/pleroma/instances/instance.ex
	index 420803a8f..4d7ed4ca1 100644
	--- a/lib/pleroma/instances/instance.ex
	+++ b/lib/pleroma/instances/instance.ex
	@@ -1,113 +1,117 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Instances.Instance do
	@moduledoc "Instance."

	alias Pleroma.Instances
	alias Pleroma.Instances.Instance
	alias Pleroma.Repo

	use Ecto.Schema

	import Ecto.Query
	import Ecto.Changeset

	schema "instances" do
	field(:host, :string)
	field(:unreachable_since, :naive_datetime_usec)

	timestamps()
	end

	defdelegate host(url_or_host), to: Instances

	def changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:host, :unreachable_since])
	\|> validate_required([:host])
	\|> unique_constraint(:host)
	end

	def filter_reachable([]), do: %{}

	def filter_reachable(urls_or_hosts) when is_list(urls_or_hosts) do
	hosts =
	urls_or_hosts
	\|> Enum.map(&(&1 && host(&1)))
	\|> Enum.filter(&(to_string(&1) != ""))

	unreachable_since_by_host =
	Repo.all(
	from(i in Instance,
	where: i.host in ^hosts,
	select: {i.host, i.unreachable_since}
	)
	)
	\|> Map.new(& &1)

	reachability_datetime_threshold = Instances.reachability_datetime_threshold()

	for entry <- Enum.filter(urls_or_hosts, &is_binary/1) do
	host = host(entry)
	unreachable_since = unreachable_since_by_host[host]

	if !unreachable_since \|\|
	NaiveDateTime.compare(unreachable_since, reachability_datetime_threshold) == :gt do
	{entry, unreachable_since}
	end
	end
	\|> Enum.filter(& &1)
	\|> Map.new(& &1)
	end

	def reachable?(url_or_host) when is_binary(url_or_host) do
	!Repo.one(
	from(i in Instance,
	where:
	i.host == ^host(url_or_host) and
	i.unreachable_since <= ^Instances.reachability_datetime_threshold(),
	select: true
	)
	)
	end

	def reachable?(_), do: true

	def set_reachable(url_or_host) when is_binary(url_or_host) do
	with host <- host(url_or_host),
	%Instance{} = existing_record <- Repo.get_by(Instance, %{host: host}) do
	{:ok, _instance} =
	existing_record
	\|> changeset(%{unreachable_since: nil})
	\|> Repo.update()
	end
	end

	def set_reachable(_), do: {:error, nil}

	def set_unreachable(url_or_host, unreachable_since \\ nil)

	def set_unreachable(url_or_host, unreachable_since) when is_binary(url_or_host) do
	unreachable_since = unreachable_since \|\| DateTime.utc_now()
	host = host(url_or_host)
	existing_record = Repo.get_by(Instance, %{host: host})

	changes = %{unreachable_since: unreachable_since}

	cond do
	is_nil(existing_record) ->
	%Instance{}
	\|> changeset(Map.put(changes, :host, host))
	\|> Repo.insert()

	existing_record.unreachable_since &&
	NaiveDateTime.compare(existing_record.unreachable_since, unreachable_since) != :gt ->
	{:ok, existing_record}

	true ->
	existing_record
	\|> changeset(changes)
	\|> Repo.update()
	end
	end

	def set_unreachable(_, _), do: {:error, nil}
	end
	diff --git a/lib/pleroma/object/fetcher.ex b/lib/pleroma/object/fetcher.ex
	index fffbf2bbb..101c21f96 100644
	--- a/lib/pleroma/object/fetcher.ex
	+++ b/lib/pleroma/object/fetcher.ex
	@@ -1,95 +1,99 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Object.Fetcher do
	alias Pleroma.HTTP
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.OStatus

	require Logger

	defp reinject_object(data) do
	Logger.debug("Reinjecting object #{data["id"]}")

	with data <- Transmogrifier.fix_object(data),
	{:ok, object} <- Object.create(data) do
	{:ok, object}
	else
	e ->
	Logger.error("Error while processing object: #{inspect(e)}")
	{:error, e}
	end
	end

	# TODO:
	# This will create a Create activity, which we need internally at the moment.
	def fetch_object_from_id(id, options \\ []) do
	if object = Object.get_cached_by_ap_id(id) do
	{:ok, object}
	else
	Logger.info("Fetching #{id} via AP")

	with {:ok, data} <- fetch_and_contain_remote_object_from_id(id),
	nil <- Object.normalize(data, false),
	params <- %{
	"type" => "Create",
	"to" => data["to"],
	"cc" => data["cc"],
	"actor" => data["actor"] \|\| data["attributedTo"],
	"object" => data
	},
	:ok <- Containment.contain_origin(id, params),
	{:ok, activity} <- Transmogrifier.handle_incoming(params, options),
	{:object, _data, %Object{} = object} <-
	{:object, data, Object.normalize(activity, false)} do
	{:ok, object}
	else
	{:error, {:reject, nil}} ->
	{:reject, nil}

	{:object, data, nil} ->
	reinject_object(data)

	object = %Object{} ->
	{:ok, object}

	_e ->
	Logger.info("Couldn't get object via AP, trying out OStatus fetching...")

	case OStatus.fetch_activity_from_url(id) do
	{:ok, [activity \| _]} -> {:ok, Object.normalize(activity, false)}
	e -> e
	end
	end
	end
	end

	def fetch_object_from_id!(id, options \\ []) do
	with {:ok, object} <- fetch_object_from_id(id, options) do
	object
	else
	_e ->
	nil
	end
	end

	def fetch_and_contain_remote_object_from_id(id) do
	Logger.info("Fetching object #{id} via AP")

	with true <- String.starts_with?(id, "http"),
	{:ok, %{body: body, status: code}} when code in 200..299 <-
	HTTP.get(
	id,
	[{:Accept, "application/activity+json"}]
	),
	{:ok, data} <- Jason.decode(body),
	:ok <- Containment.contain_origin_from_id(id, data) do
	{:ok, data}
	else
	{:ok, %{status: code}} when code in [404, 410] ->
	{:error, "Object has been deleted"}

	e ->
	{:error, e}
	end
	end
	end
	diff --git a/lib/pleroma/object_tombstone.ex b/lib/pleroma/object_tombstone.ex
	index 64d836d3e..fe947ffd3 100644
	--- a/lib/pleroma/object_tombstone.ex
	+++ b/lib/pleroma/object_tombstone.ex
	@@ -1,4 +1,8 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.ObjectTombstone do
	@enforce_keys [:id, :formerType, :deleted]
	defstruct [:id, :formerType, :deleted, type: "Tombstone"]
	end
	diff --git a/lib/pleroma/pagination.ex b/lib/pleroma/pagination.ex
	index f435e5c9c..3d7dd9e6a 100644
	--- a/lib/pleroma/pagination.ex
	+++ b/lib/pleroma/pagination.ex
	@@ -1,84 +1,88 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Pagination do
	@moduledoc """
	Implements Mastodon-compatible pagination.
	"""

	import Ecto.Query
	import Ecto.Changeset

	alias Pleroma.Repo

	@default_limit 20

	def fetch_paginated(query, params) do
	options = cast_params(params)

	query
	\|> paginate(options)
	\|> Repo.all()
	\|> enforce_order(options)
	end

	def paginate(query, options) do
	query
	\|> restrict(:min_id, options)
	\|> restrict(:since_id, options)
	\|> restrict(:max_id, options)
	\|> restrict(:order, options)
	\|> restrict(:limit, options)
	end

	defp cast_params(params) do
	param_types = %{
	min_id: :string,
	since_id: :string,
	max_id: :string,
	limit: :integer
	}

	params =
	Enum.reduce(params, %{}, fn
	{key, _value}, acc when is_atom(key) -> Map.drop(acc, [key])
	{key, value}, acc -> Map.put(acc, key, value)
	end)

	changeset = cast({%{}, param_types}, params, Map.keys(param_types))
	changeset.changes
	end

	defp restrict(query, :min_id, %{min_id: min_id}) do
	where(query, [q], q.id > ^min_id)
	end

	defp restrict(query, :since_id, %{since_id: since_id}) do
	where(query, [q], q.id > ^since_id)
	end

	defp restrict(query, :max_id, %{max_id: max_id}) do
	where(query, [q], q.id < ^max_id)
	end

	defp restrict(query, :order, %{min_id: _}) do
	order_by(query, [u], fragment("? asc nulls last", u.id))
	end

	defp restrict(query, :order, _options) do
	order_by(query, [u], fragment("? desc nulls last", u.id))
	end

	defp restrict(query, :limit, options) do
	limit = Map.get(options, :limit, @default_limit)

	query
	\|> limit(^limit)
	end

	defp restrict(query, _, _), do: query

	defp enforce_order(result, %{min_id: _}) do
	result
	\|> Enum.reverse()
	end

	defp enforce_order(result, _), do: result
	end
	diff --git a/lib/pleroma/reverse_proxy/client.ex b/lib/pleroma/reverse_proxy/client.ex
	index 57c2d2cfd..776c4794c 100644
	--- a/lib/pleroma/reverse_proxy/client.ex
	+++ b/lib/pleroma/reverse_proxy/client.ex
	@@ -1,24 +1,28 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.ReverseProxy.Client do
	@callback request(atom(), String.t(), [tuple()], String.t(), list()) ::
	{:ok, pos_integer(), [tuple()], reference() \| map()}
	\| {:ok, pos_integer(), [tuple()]}
	\| {:ok, reference()}
	\| {:error, term()}

	@callback stream_body(reference() \| pid() \| map()) ::
	{:ok, binary()} \| :done \| {:error, String.t()}

	@callback close(reference() \| pid() \| map()) :: :ok

	def request(method, url, headers, "", opts \\ []) do
	client().request(method, url, headers, "", opts)
	end

	def stream_body(ref), do: client().stream_body(ref)

	def close(ref), do: client().close(ref)

	defp client do
	Pleroma.Config.get([Pleroma.ReverseProxy.Client], :hackney)
	end
	end
	diff --git a/lib/pleroma/user/welcome_message.ex b/lib/pleroma/user/welcome_message.ex
	index 2ba65b75a..99fba729e 100644
	--- a/lib/pleroma/user/welcome_message.ex
	+++ b/lib/pleroma/user/welcome_message.ex
	@@ -1,30 +1,34 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.User.WelcomeMessage do
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	def post_welcome_message_to_user(user) do
	with %User{} = sender_user <- welcome_user(),
	message when is_binary(message) <- welcome_message() do
	CommonAPI.post(sender_user, %{
	"visibility" => "direct",
	"status" => "@#{user.nickname}\n#{message}"
	})
	else
	_ -> {:ok, nil}
	end
	end

	defp welcome_user do
	with nickname when is_binary(nickname) <-
	Pleroma.Config.get([:instance, :welcome_user_nickname]),
	%User{local: true} = user <- User.get_cached_by_nickname(nickname) do
	user
	else
	_ -> nil
	end
	end

	defp welcome_message do
	Pleroma.Config.get([:instance, :welcome_message])
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/visibility.ex b/lib/pleroma/web/activity_pub/visibility.ex
	index 8965e3253..9908a2e75 100644
	--- a/lib/pleroma/web/activity_pub/visibility.ex
	+++ b/lib/pleroma/web/activity_pub/visibility.ex
	@@ -1,79 +1,83 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.ActivityPub.Visibility do
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User

	def is_public?(%Object{data: %{"type" => "Tombstone"}}), do: false
	def is_public?(%Object{data: data}), do: is_public?(data)
	def is_public?(%Activity{data: data}), do: is_public?(data)
	def is_public?(%{"directMessage" => true}), do: false

	def is_public?(data) do
	"https://www.w3.org/ns/activitystreams#Public" in (data["to"] ++ (data["cc"] \|\| []))
	end

	def is_private?(activity) do
	with false <- is_public?(activity),
	%User{follower_address: follower_address} <-
	User.get_cached_by_ap_id(activity.data["actor"]) do
	follower_address in activity.data["to"]
	else
	_ -> false
	end
	end

	def is_direct?(%Activity{data: %{"directMessage" => true}}), do: true
	def is_direct?(%Object{data: %{"directMessage" => true}}), do: true

	def is_direct?(activity) do
	!is_public?(activity) && !is_private?(activity)
	end

	def visible_for_user?(activity, nil) do
	is_public?(activity)
	end

	def visible_for_user?(activity, user) do
	x = [user.ap_id \| user.following]
	y = [activity.actor] ++ activity.data["to"] ++ (activity.data["cc"] \|\| [])
	visible_for_user?(activity, nil) \|\| Enum.any?(x, &(&1 in y))
	end

	def entire_thread_visible_for_user?(%Activity{} = activity, %User{} = user) do
	{:ok, %{rows: [[result]]}} =
	Ecto.Adapters.SQL.query(Repo, "SELECT thread_visibility($1, $2)", [
	user.ap_id,
	activity.data["id"]
	])

	result
	end

	def get_visibility(object) do
	public = "https://www.w3.org/ns/activitystreams#Public"
	to = object.data["to"] \|\| []
	cc = object.data["cc"] \|\| []

	cond do
	public in to ->
	"public"

	public in cc ->
	"unlisted"

	# this should use the sql for the object's activity
	Enum.any?(to, &String.contains?(&1, "/followers")) ->
	"private"

	object.data["directMessage"] == true ->
	"direct"

	length(cc) > 0 ->
	"private"

	true ->
	"direct"
	end
	end
	end
	diff --git a/lib/pleroma/web/admin_api/views/config_view.ex b/lib/pleroma/web/admin_api/views/config_view.ex
	index 3ccc9ca46..a31f1041f 100644
	--- a/lib/pleroma/web/admin_api/views/config_view.ex
	+++ b/lib/pleroma/web/admin_api/views/config_view.ex
	@@ -1,17 +1,21 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.AdminAPI.ConfigView do
	use Pleroma.Web, :view

	def render("index.json", %{configs: configs}) do
	%{
	configs: render_many(configs, __MODULE__, "show.json", as: :config)
	}
	end

	def render("show.json", %{config: config}) do
	%{
	key: config.key,
	group: config.group,
	value: Pleroma.Web.AdminAPI.Config.from_binary_to_map(config.value)
	}
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/mastodon_api.ex b/lib/pleroma/web/mastodon_api/mastodon_api.ex
	index 3a3ec7c2a..c82b20123 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api.ex
	@@ -1,84 +1,88 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.MastodonAPI.MastodonAPI do
	import Ecto.Query
	import Ecto.Changeset

	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Pagination
	alias Pleroma.ScheduledActivity
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	def follow(follower, followed, params \\ %{}) do
	options = cast_params(params)
	reblogs = options[:reblogs]

	result =
	if not User.following?(follower, followed) do
	CommonAPI.follow(follower, followed)
	else
	{:ok, follower, followed, nil}
	end

	with {:ok, follower, followed, _} <- result do
	reblogs
	\|> case do
	false -> CommonAPI.hide_reblogs(follower, followed)
	_ -> CommonAPI.show_reblogs(follower, followed)
	end
	\|> case do
	{:ok, follower} -> {:ok, follower}
	_ -> {:ok, follower}
	end
	end
	end

	def get_followers(user, params \\ %{}) do
	user
	\|> User.get_followers_query()
	\|> Pagination.fetch_paginated(params)
	end

	def get_friends(user, params \\ %{}) do
	user
	\|> User.get_friends_query()
	\|> Pagination.fetch_paginated(params)
	end

	def get_notifications(user, params \\ %{}) do
	options = cast_params(params)

	user
	\|> Notification.for_user_query()
	\|> restrict(:exclude_types, options)
	\|> Pagination.fetch_paginated(params)
	end

	def get_scheduled_activities(user, params \\ %{}) do
	user
	\|> ScheduledActivity.for_user_query()
	\|> Pagination.fetch_paginated(params)
	end

	defp cast_params(params) do
	param_types = %{
	exclude_types: {:array, :string},
	reblogs: :boolean
	}

	changeset = cast({%{}, param_types}, params, Map.keys(param_types))
	changeset.changes
	end

	defp restrict(query, :exclude_types, %{exclude_types: mastodon_types = [_ \| _]}) do
	ap_types =
	mastodon_types
	\|> Enum.map(&Activity.from_mastodon_notification_type/1)
	\|> Enum.filter(& &1)

	query
	\|> where([q, a], not fragment("? @> ARRAY[?->>'type']::varchar[]", ^ap_types, a.data))
	end

	defp restrict(query, _, _), do: query
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/conversation_view.ex b/lib/pleroma/web/mastodon_api/views/conversation_view.ex
	index af1dcf66d..38bdec737 100644
	--- a/lib/pleroma/web/mastodon_api/views/conversation_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/conversation_view.ex
	@@ -1,43 +1,47 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.MastodonAPI.ConversationView do
	use Pleroma.Web, :view

	alias Pleroma.Activity
	alias Pleroma.Repo
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView

	def render("participation.json", %{participation: participation, user: user}) do
	participation = Repo.preload(participation, conversation: :users)

	last_activity_id =
	with nil <- participation.last_activity_id do
	ActivityPub.fetch_latest_activity_id_for_context(participation.conversation.ap_id, %{
	"user" => user,
	"blocking_user" => user
	})
	end

	activity = Activity.get_by_id_with_object(last_activity_id)

	last_status = StatusView.render("status.json", %{activity: activity, for: user})

	# Conversations return all users except the current user.
	users =
	participation.conversation.users
	\|> Enum.reject(&(&1.id == user.id))

	accounts =
	AccountView.render("accounts.json", %{
	users: users,
	as: :user
	})

	%{
	id: participation.id \|> to_string(),
	accounts: accounts,
	unread: !participation.read,
	last_status: last_status
	}
	end
	end
	diff --git a/lib/pleroma/web/metadata/player_view.ex b/lib/pleroma/web/metadata/player_view.ex
	index e9a8cfc8d..4289ebdbd 100644
	--- a/lib/pleroma/web/metadata/player_view.ex
	+++ b/lib/pleroma/web/metadata/player_view.ex
	@@ -1,21 +1,25 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.Metadata.PlayerView do
	use Pleroma.Web, :view
	import Phoenix.HTML.Tag, only: [content_tag: 3, tag: 2]

	def render("player.html", %{"mediaType" => type, "href" => href}) do
	{tag_type, tag_attrs} =
	case type do
	"audio" <> _ -> {:audio, []}
	"video" <> _ -> {:video, [loop: true]}
	end

	content_tag(
	tag_type,
	[
	tag(:source, src: href, type: type),
	"Your browser does not support #{type} playback."
	],
	[controls: true] ++ tag_attrs
	)
	end
	end
	diff --git a/lib/pleroma/web/metadata/rel_me.ex b/lib/pleroma/web/metadata/rel_me.ex
	index 03af899c4..f87fc1973 100644
	--- a/lib/pleroma/web/metadata/rel_me.ex
	+++ b/lib/pleroma/web/metadata/rel_me.ex
	@@ -1,13 +1,17 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.Metadata.Providers.RelMe do
	alias Pleroma.Web.Metadata.Providers.Provider
	@behaviour Provider

	@impl Provider
	def build_tags(%{user: user}) do
	(Floki.attribute(user.bio, "link[rel~=me]", "href") ++
	Floki.attribute(user.bio, "a[rel~=me]", "href"))
	\|> Enum.map(fn link ->
	{:link, [rel: "me", href: link], []}
	end)
	end
	end
	diff --git a/lib/pleroma/web/oauth/token/response.ex b/lib/pleroma/web/oauth/token/response.ex
	index 2648571ad..266110814 100644
	--- a/lib/pleroma/web/oauth/token/response.ex
	+++ b/lib/pleroma/web/oauth/token/response.ex
	@@ -1,32 +1,36 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.OAuth.Token.Response do
	@moduledoc false

	alias Pleroma.User
	alias Pleroma.Web.OAuth.Token.Utils

	@doc false
	def build(%User{} = user, token, opts \\ %{}) do
	%{
	token_type: "Bearer",
	access_token: token.token,
	refresh_token: token.refresh_token,
	expires_in: expires_in(),
	scope: Enum.join(token.scopes, " "),
	me: user.ap_id
	}
	\|> Map.merge(opts)
	end

	def build_for_client_credentials(token) do
	%{
	token_type: "Bearer",
	access_token: token.token,
	refresh_token: token.refresh_token,
	created_at: Utils.format_created_at(token),
	expires_in: expires_in(),
	scope: Enum.join(token.scopes, " ")
	}
	end

	defp expires_in, do: Pleroma.Config.get([:oauth2, :token_expires_in], 600)
	end
	diff --git a/lib/pleroma/web/oauth/token/strategy/refresh_token.ex b/lib/pleroma/web/oauth/token/strategy/refresh_token.ex
	index 7df0be14e..c620050c8 100644
	--- a/lib/pleroma/web/oauth/token/strategy/refresh_token.ex
	+++ b/lib/pleroma/web/oauth/token/strategy/refresh_token.ex
	@@ -1,54 +1,58 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.OAuth.Token.Strategy.RefreshToken do
	@moduledoc """
	Functions for dealing with refresh token strategy.
	"""

	alias Pleroma.Config
	alias Pleroma.Repo
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.OAuth.Token.Strategy.Revoke

	@doc """
	Will grant access token by refresh token.
	"""
	@spec grant(Token.t()) :: {:ok, Token.t()} \| {:error, any()}
	def grant(token) do
	access_token = Repo.preload(token, [:user, :app])

	result =
	Repo.transaction(fn ->
	token_params = %{
	app: access_token.app,
	user: access_token.user,
	scopes: access_token.scopes
	}

	access_token
	\|> revoke_access_token()
	\|> create_access_token(token_params)
	end)

	case result do
	{:ok, {:error, reason}} -> {:error, reason}
	{:ok, {:ok, token}} -> {:ok, token}
	{:error, reason} -> {:error, reason}
	end
	end

	defp revoke_access_token(token) do
	Revoke.revoke(token)
	end

	defp create_access_token({:error, error}, _), do: {:error, error}

	defp create_access_token({:ok, token}, %{app: app, user: user} = token_params) do
	Token.create_token(app, user, add_refresh_token(token_params, token.refresh_token))
	end

	defp add_refresh_token(params, token) do
	case Config.get([:oauth2, :issue_new_refresh_token], false) do
	true -> Map.put(params, :refresh_token, token)
	false -> params
	end
	end
	end
	diff --git a/lib/pleroma/web/oauth/token/strategy/revoke.ex b/lib/pleroma/web/oauth/token/strategy/revoke.ex
	index dea63ca54..983f095b4 100644
	--- a/lib/pleroma/web/oauth/token/strategy/revoke.ex
	+++ b/lib/pleroma/web/oauth/token/strategy/revoke.ex
	@@ -1,22 +1,26 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.OAuth.Token.Strategy.Revoke do
	@moduledoc """
	Functions for dealing with revocation.
	"""

	alias Pleroma.Repo
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OAuth.Token

	@doc "Finds and revokes access token for app and by token"
	@spec revoke(App.t(), map()) :: {:ok, Token.t()} \| {:error, :not_found \| Ecto.Changeset.t()}
	def revoke(%App{} = app, %{"token" => token} = _attrs) do
	with {:ok, token} <- Token.get_by_token(app, token),
	do: revoke(token)
	end

	@doc "Revokes access token"
	@spec revoke(Token.t()) :: {:ok, Token.t()} \| {:error, Ecto.Changeset.t()}
	def revoke(%Token{} = token) do
	Repo.delete(token)
	end
	end
	diff --git a/lib/pleroma/web/oauth/token/utils.ex b/lib/pleroma/web/oauth/token/utils.ex
	index 7a4fddafd..1e8765e93 100644
	--- a/lib/pleroma/web/oauth/token/utils.ex
	+++ b/lib/pleroma/web/oauth/token/utils.ex
	@@ -1,68 +1,72 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.OAuth.Token.Utils do
	@moduledoc """
	Auxiliary functions for dealing with tokens.
	"""

	alias Pleroma.Repo
	alias Pleroma.Web.OAuth.App

	@doc "Fetch app by client credentials from request"
	@spec fetch_app(Plug.Conn.t()) :: {:ok, App.t()} \| {:error, :not_found}
	def fetch_app(conn) do
	res =
	conn
	\|> fetch_client_credentials()
	\|> fetch_client

	case res do
	%App{} = app -> {:ok, app}
	_ -> {:error, :not_found}
	end
	end

	defp fetch_client({id, secret}) when is_binary(id) and is_binary(secret) do
	Repo.get_by(App, client_id: id, client_secret: secret)
	end

	defp fetch_client({_id, _secret}), do: nil

	defp fetch_client_credentials(conn) do
	# Per RFC 6749, HTTP Basic is preferred to body params
	with ["Basic " <> encoded] <- Plug.Conn.get_req_header(conn, "authorization"),
	{:ok, decoded} <- Base.decode64(encoded),
	[id, secret] <-
	Enum.map(
	String.split(decoded, ":"),
	fn s -> URI.decode_www_form(s) end
	) do
	{id, secret}
	else
	_ -> {conn.params["client_id"], conn.params["client_secret"]}
	end
	end

	@doc "convert token inserted_at to unix timestamp"
	def format_created_at(%{inserted_at: inserted_at} = _token) do
	inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> DateTime.to_unix()
	end

	@doc false
	@spec generate_token(keyword()) :: binary()
	def generate_token(opts \\ []) do
	opts
	\|> Keyword.get(:size, 32)
	\|> :crypto.strong_rand_bytes()
	\|> Base.url_encode64(padding: false)
	end

	# XXX - for whatever reason our token arrives urlencoded, but Plug.Conn should be
	# decoding it. Investigate sometime.
	def fix_padding(token) do
	token
	\|> URI.decode()
	\|> Base.url_decode64!(padding: false)
	\|> Base.url_encode64(padding: false)
	end
	end
	diff --git a/lib/pleroma/web/rich_media/parsers/meta_tags_parser.ex b/lib/pleroma/web/rich_media/parsers/meta_tags_parser.ex
	index fb79630e4..913975616 100644
	--- a/lib/pleroma/web/rich_media/parsers/meta_tags_parser.ex
	+++ b/lib/pleroma/web/rich_media/parsers/meta_tags_parser.ex
	@@ -1,49 +1,53 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.RichMedia.Parsers.MetaTagsParser do
	def parse(html, data, prefix, error_message, key_name, value_name \\ "content") do
	meta_data =
	html
	\|> get_elements(key_name, prefix)
	\|> Enum.reduce(data, fn el, acc ->
	attributes = normalize_attributes(el, prefix, key_name, value_name)

	Map.merge(acc, attributes)
	end)
	\|> maybe_put_title(html)

	if Enum.empty?(meta_data) do
	{:error, error_message}
	else
	{:ok, meta_data}
	end
	end

	defp get_elements(html, key_name, prefix) do
	html \|> Floki.find("meta[#{key_name}^='#{prefix}:']")
	end

	defp normalize_attributes(html_node, prefix, key_name, value_name) do
	{_tag, attributes, _children} = html_node

	data =
	Enum.into(attributes, %{}, fn {name, value} ->
	{name, String.trim_leading(value, "#{prefix}:")}
	end)

	%{String.to_atom(data[key_name]) => data[value_name]}
	end

	defp maybe_put_title(%{title: _} = meta, _), do: meta

	defp maybe_put_title(meta, html) when meta != %{} do
	case get_page_title(html) do
	"" -> meta
	title -> Map.put_new(meta, :title, title)
	end
	end

	defp maybe_put_title(meta, _), do: meta

	defp get_page_title(html) do
	Floki.find(html, "title") \|> Floki.text()
	end
	end
	diff --git a/lib/pleroma/web/rich_media/parsers/oembed_parser.ex b/lib/pleroma/web/rich_media/parsers/oembed_parser.ex
	index 2530b8c9d..875637c4d 100644
	--- a/lib/pleroma/web/rich_media/parsers/oembed_parser.ex
	+++ b/lib/pleroma/web/rich_media/parsers/oembed_parser.ex
	@@ -1,31 +1,35 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.RichMedia.Parsers.OEmbed do
	def parse(html, _data) do
	with elements = [_ \| _] <- get_discovery_data(html),
	{:ok, oembed_url} <- get_oembed_url(elements),
	{:ok, oembed_data} <- get_oembed_data(oembed_url) do
	{:ok, oembed_data}
	else
	_e -> {:error, "No OEmbed data found"}
	end
	end

	defp get_discovery_data(html) do
	html \|> Floki.find("link[type='application/json+oembed']")
	end

	defp get_oembed_url(nodes) do
	{"link", attributes, _children} = nodes \|> hd()

	{:ok, Enum.into(attributes, %{})["href"]}
	end

	defp get_oembed_data(url) do
	{:ok, %Tesla.Env{body: json}} = Pleroma.HTTP.get(url, [], adapter: [pool: :media])

	{:ok, data} = Jason.decode(json)

	data = data \|> Map.new(fn {k, v} -> {String.to_atom(k), v} end)

	{:ok, data}
	end
	end
	diff --git a/lib/pleroma/web/rich_media/parsers/ogp.ex b/lib/pleroma/web/rich_media/parsers/ogp.ex
	index 0e1a0e719..d40fa009f 100644
	--- a/lib/pleroma/web/rich_media/parsers/ogp.ex
	+++ b/lib/pleroma/web/rich_media/parsers/ogp.ex
	@@ -1,11 +1,15 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.RichMedia.Parsers.OGP do
	def parse(html, data) do
	Pleroma.Web.RichMedia.Parsers.MetaTagsParser.parse(
	html,
	data,
	"og",
	"No OGP metadata found",
	"property"
	)
	end
	end
	diff --git a/lib/pleroma/web/rich_media/parsers/twitter_card.ex b/lib/pleroma/web/rich_media/parsers/twitter_card.ex
	index a317c3e78..e4efe2dd0 100644
	--- a/lib/pleroma/web/rich_media/parsers/twitter_card.ex
	+++ b/lib/pleroma/web/rich_media/parsers/twitter_card.ex
	@@ -1,11 +1,15 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.RichMedia.Parsers.TwitterCard do
	def parse(html, data) do
	Pleroma.Web.RichMedia.Parsers.MetaTagsParser.parse(
	html,
	data,
	"twitter",
	"No twitter card metadata found",
	"name"
	)
	end
	end
	diff --git a/lib/pleroma/web/uploader_controller.ex b/lib/pleroma/web/uploader_controller.ex
	index 5d8a77346..d11e8e63e 100644
	--- a/lib/pleroma/web/uploader_controller.ex
	+++ b/lib/pleroma/web/uploader_controller.ex
	@@ -1,25 +1,29 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.Web.UploaderController do
	use Pleroma.Web, :controller

	alias Pleroma.Uploaders.Uploader

	def callback(conn, %{"upload_path" => upload_path} = params) do
	process_callback(conn, :global.whereis_name({Uploader, upload_path}), params)
	end

	def callbacks(conn, _) do
	send_resp(conn, 400, "bad request")
	end

	defp process_callback(conn, pid, params) when is_pid(pid) do
	send(pid, {Uploader, self(), conn, params})

	receive do
	{Uploader, conn} -> conn
	end
	end

	defp process_callback(conn, _, _) do
	send_resp(conn, 400, "bad request")
	end
	end
	diff --git a/lib/transports.ex b/lib/transports.ex
	index 42f645b21..9f3fc535d 100644
	--- a/lib/transports.ex
	+++ b/lib/transports.ex
	@@ -1,85 +1,89 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Phoenix.Transports.WebSocket.Raw do
	import Plug.Conn,
	only: [
	fetch_query_params: 1,
	send_resp: 3
	]

	alias Phoenix.Socket.Transport

	def default_config do
	[
	timeout: 60_000,
	transport_log: false,
	cowboy: Phoenix.Endpoint.CowboyWebSocket
	]
	end

	def init(%Plug.Conn{method: "GET"} = conn, {endpoint, handler, transport}) do
	{_, opts} = handler.__transport__(transport)

	conn =
	conn
	\|> fetch_query_params
	\|> Transport.transport_log(opts[:transport_log])
	\|> Transport.force_ssl(handler, endpoint, opts)
	\|> Transport.check_origin(handler, endpoint, opts)

	case conn do
	%{halted: false} = conn ->
	case Transport.connect(endpoint, handler, transport, __MODULE__, nil, conn.params) do
	{:ok, socket} ->
	{:ok, conn, {__MODULE__, {socket, opts}}}

	:error ->
	send_resp(conn, :forbidden, "")
	{:error, conn}
	end

	_ ->
	{:error, conn}
	end
	end

	def init(conn, _) do
	send_resp(conn, :bad_request, "")
	{:error, conn}
	end

	def ws_init({socket, config}) do
	Process.flag(:trap_exit, true)
	{:ok, %{socket: socket}, config[:timeout]}
	end

	def ws_handle(op, data, state) do
	state.socket.handler
	\|> apply(:handle, [op, data, state])
	\|> case do
	{op, data} ->
	{:reply, {op, data}, state}

	{op, data, state} ->
	{:reply, {op, data}, state}

	%{} = state ->
	{:ok, state}

	_ ->
	{:ok, state}
	end
	end

	def ws_info({_, _} = tuple, state) do
	{:reply, tuple, state}
	end

	def ws_info(_tuple, state), do: {:ok, state}

	def ws_close(state) do
	ws_handle(:closed, :normal, state)
	end

	def ws_terminate(reason, state) do
	ws_handle(:closed, reason, state)
	end
	end
	diff --git a/lib/xml_builder.ex b/lib/xml_builder.ex
	index b58602c7b..ceeef2755 100644
	--- a/lib/xml_builder.ex
	+++ b/lib/xml_builder.ex
	@@ -1,45 +1,49 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	defmodule Pleroma.XmlBuilder do
	def to_xml({tag, attributes, content}) do
	open_tag = make_open_tag(tag, attributes)

	content_xml = to_xml(content)

	"<#{open_tag}>#{content_xml}</#{tag}>"
	end

	def to_xml({tag, %{} = attributes}) do
	open_tag = make_open_tag(tag, attributes)

	"<#{open_tag} />"
	end

	def to_xml({tag, content}), do: to_xml({tag, %{}, content})

	def to_xml(content) when is_binary(content) do
	to_string(content)
	end

	def to_xml(content) when is_list(content) do
	for element <- content do
	to_xml(element)
	end
	\|> Enum.join()
	end

	def to_xml(%NaiveDateTime{} = time) do
	NaiveDateTime.to_iso8601(time)
	end

	def to_doc(content), do: ~s(<?xml version="1.0" encoding="UTF-8"?>) <> to_xml(content)

	defp make_open_tag(tag, attributes) do
	attributes_string =
	for {attribute, value} <- attributes do
	value = String.replace(value, "\"", """)
	"#{attribute}=\"#{value}\""
	end
	\|> Enum.join(" ")

	[tag, attributes_string] \|> Enum.join(" ") \|> String.trim()
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Tue, Oct 13, 3:55 PM (1 d, 21 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1786817
Default Alt Text: (52 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions