No OneTemporary
Actions

Authored By

Unknown

Size

48 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/instances.ex b/lib/pleroma/instances.ex
	index 25b739520..6d445d6b3 100644
	--- a/lib/pleroma/instances.ex
	+++ b/lib/pleroma/instances.ex
	@@ -1,12 +1,21 @@
	defmodule Pleroma.Instances do
	@moduledoc "Instances context."

	@adapter Pleroma.Instances.Instance

	+ defdelegate filter_reachable(urls), to: @adapter
	defdelegate reachable?(url), to: @adapter
	defdelegate set_reachable(url), to: @adapter
	defdelegate set_unreachable(url, unreachable_since \\ nil), to: @adapter

	def reachability_time_threshold,
	do: NaiveDateTime.add(NaiveDateTime.utc_now(), -30 * 24 * 3600, :second)
	+
	+ 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 fe52331a3..a17c8dab1 100644
	--- a/lib/pleroma/instances/instance.ex
	+++ b/lib/pleroma/instances/instance.ex
	@@ -1,85 +1,106 @@
	defmodule Pleroma.Instances.Instance do
	@moduledoc "Instance."

	alias Pleroma.Instances
	alias Pleroma.Instances.Instance

	use Ecto.Schema

	import Ecto.{Query, Changeset}

	alias Pleroma.Repo

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

	timestamps()
	end

	- def update_changeset(struct, params \\ %{}) do
	+ defdelegate host(url), to: Instances
	+
	+ def changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:host, :unreachable_since, :reachability_checked_at])
	+ \|> validate_required([:host])
	\|> unique_constraint(:host)
	end

	+ def filter_reachable([]), do: []
	+
	+ def filter_reachable(urls) when is_list(urls) do
	+ hosts =
	+ urls
	+ \|> Enum.map(&(&1 && host(&1)))
	+ \|> Enum.filter(&(to_string(&1) != ""))
	+
	+ unreachable_hosts =
	+ Repo.all(
	+ from(i in Instance,
	+ where:
	+ i.host in ^hosts and i.unreachable_since <= ^Instances.reachability_time_threshold(),
	+ select: i.host
	+ )
	+ )
	+
	+ Enum.filter(urls, &(&1 && host(&1) not in unreachable_hosts))
	+ end
	+
	def reachable?(url) when is_binary(url) do
	!Repo.one(
	from(i in Instance,
	where:
	i.host == ^host(url) and i.unreachable_since <= ^Instances.reachability_time_threshold(),
	select: true
	)
	)
	end

	def reachable?(_), do: true

	def set_reachable(url) when is_binary(url) do
	- Repo.update_all(
	- from(i in Instance, where: i.host == ^host(url)),
	- set: [
	- unreachable_since: nil,
	- reachability_checked_at: DateTime.utc_now()
	- ]
	- )
	+ with host <- host(url),
	+ %Instance{} = existing_record <- Repo.get_by(Instance, %{host: host}) do
	+ {:ok, _instance} =
	+ existing_record
	+ \|> changeset(%{unreachable_since: nil, reachability_checked_at: DateTime.utc_now()})
	+ \|> Repo.update()
	+ end
	end

	def set_reachable(_), do: {0, :noop}

	def set_unreachable(url, unreachable_since \\ nil)

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

	changes = %{
	unreachable_since: unreachable_since,
	reachability_checked_at: NaiveDateTime.utc_now()
	}

	if existing_record do
	update_changes =
	if existing_record.unreachable_since &&
	NaiveDateTime.compare(existing_record.unreachable_since, unreachable_since) != :gt,
	do: Map.delete(changes, :unreachable_since),
	else: changes

	- {:ok, _instance} = Repo.update(update_changeset(existing_record, update_changes))
	+ {:ok, _instance} =
	+ existing_record
	+ \|> changeset(update_changes)
	+ \|> Repo.update()
	else
	- {:ok, _instance} = Repo.insert(update_changeset(%Instance{}, Map.put(changes, :host, host)))
	+ {:ok, _instance} =
	+ %Instance{}
	+ \|> changeset(Map.put(changes, :host, host))
	+ \|> Repo.insert()
	end
	end

	def set_unreachable(_, _), do: {0, :noop}
	-
	- defp host(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/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 44c295d65..4b34334a0 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,885 +1,886 @@
	# 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.ActivityPub do
	alias Pleroma.{Activity, Repo, Object, Upload, User, Notification, Instances}
	alias Pleroma.Web.ActivityPub.{Transmogrifier, MRF}
	alias Pleroma.Web.WebFinger
	alias Pleroma.Web.Federator
	alias Pleroma.Web.OStatus
	import Ecto.Query
	import Pleroma.Web.ActivityPub.Utils
	require Logger

	@httpoison Application.get_env(:pleroma, :httpoison)

	# For Announce activities, we filter the recipients based on following status for any actors
	# that match actual users. See issue #164 for more information about why this is necessary.
	defp get_recipients(%{"type" => "Announce"} = data) do
	to = data["to"] \|\| []
	cc = data["cc"] \|\| []
	recipients = to ++ cc
	actor = User.get_cached_by_ap_id(data["actor"])

	recipients
	\|> Enum.filter(fn recipient ->
	case User.get_cached_by_ap_id(recipient) do
	nil ->
	true

	user ->
	User.following?(user, actor)
	end
	end)

	{recipients, to, cc}
	end

	defp get_recipients(data) do
	to = data["to"] \|\| []
	cc = data["cc"] \|\| []
	recipients = to ++ cc
	{recipients, to, cc}
	end

	defp check_actor_is_active(actor) do
	if not is_nil(actor) do
	with user <- User.get_cached_by_ap_id(actor),
	false <- user.info.deactivated do
	:ok
	else
	_e -> :reject
	end
	else
	:ok
	end
	end

	defp check_remote_limit(%{"object" => %{"content" => content}}) do
	limit = Pleroma.Config.get([:instance, :remote_limit])
	String.length(content) <= limit
	end

	defp check_remote_limit(_), do: true

	def insert(map, local \\ true) when is_map(map) do
	with nil <- Activity.normalize(map),
	map <- lazy_put_activity_defaults(map),
	:ok <- check_actor_is_active(map["actor"]),
	{_, true} <- {:remote_limit_error, check_remote_limit(map)},
	{:ok, map} <- MRF.filter(map),
	:ok <- insert_full_object(map) do
	{recipients, _, _} = get_recipients(map)

	{:ok, activity} =
	Repo.insert(%Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients
	})

	Notification.create_notifications(activity)
	stream_out(activity)
	{:ok, activity}
	else
	%Activity{} = activity -> {:ok, activity}
	error -> {:error, error}
	end
	end

	def stream_out(activity) do
	public = "https://www.w3.org/ns/activitystreams#Public"

	if activity.data["type"] in ["Create", "Announce", "Delete"] do
	Pleroma.Web.Streamer.stream("user", activity)
	Pleroma.Web.Streamer.stream("list", activity)

	if Enum.member?(activity.data["to"], public) do
	Pleroma.Web.Streamer.stream("public", activity)

	if activity.local do
	Pleroma.Web.Streamer.stream("public:local", activity)
	end

	if activity.data["type"] in ["Create"] do
	activity.data["object"]
	\|> Map.get("tag", [])
	\|> Enum.filter(fn tag -> is_bitstring(tag) end)
	\|> Enum.map(fn tag -> Pleroma.Web.Streamer.stream("hashtag:" <> tag, activity) end)

	if activity.data["object"]["attachment"] != [] do
	Pleroma.Web.Streamer.stream("public:media", activity)

	if activity.local do
	Pleroma.Web.Streamer.stream("public:local:media", activity)
	end
	end
	end
	else
	if !Enum.member?(activity.data["cc"] \|\| [], public) &&
	!Enum.member?(
	activity.data["to"],
	User.get_by_ap_id(activity.data["actor"]).follower_address
	),
	do: Pleroma.Web.Streamer.stream("direct", activity)
	end
	end
	end

	def create(%{to: to, actor: actor, context: context, object: object} = params) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]

	with create_data <-
	make_create_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	),
	{:ok, activity} <- insert(create_data, local),
	# Changing note count prior to enqueuing federation task in order to avoid race conditions on updating user.info
	{:ok, _actor} <- User.increase_note_count(actor),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def accept(%{to: to, actor: actor, object: object} = params) do
	# only accept false as false value
	local = !(params[:local] == false)

	with data <- %{"to" => to, "type" => "Accept", "actor" => actor, "object" => object},
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def reject(%{to: to, actor: actor, object: object} = params) do
	# only accept false as false value
	local = !(params[:local] == false)

	with data <- %{"to" => to, "type" => "Reject", "actor" => actor, "object" => object},
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
	# only accept false as false value
	local = !(params[:local] == false)

	with data <- %{
	"to" => to,
	"cc" => cc,
	"type" => "Update",
	"actor" => actor,
	"object" => object
	},
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	# TODO: This is weird, maybe we shouldn't check here if we can make the activity.
	def like(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => _}} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with nil <- get_existing_like(ap_id, object),
	like_data <- make_like_data(user, object, activity_id),
	{:ok, activity} <- insert(like_data, local),
	{:ok, object} <- add_like_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	%Activity{} = activity -> {:ok, activity, object}
	error -> {:error, error}
	end
	end

	def unlike(
	%User{} = actor,
	%Object{} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
	unlike_data <- make_unlike_data(actor, like_activity, activity_id),
	{:ok, unlike_activity} <- insert(unlike_data, local),
	{:ok, _activity} <- Repo.delete(like_activity),
	{:ok, object} <- remove_like_from_object(like_activity, object),
	:ok <- maybe_federate(unlike_activity) do
	{:ok, unlike_activity, like_activity, object}
	else
	_e -> {:ok, object}
	end
	end

	def announce(
	%User{ap_id: _} = user,
	%Object{data: %{"id" => _}} = object,
	activity_id \\ nil,
	local \\ true,
	public \\ true
	) do
	with true <- is_public?(object),
	announce_data <- make_announce_data(user, object, activity_id, public),
	{:ok, activity} <- insert(announce_data, local),
	{:ok, object} <- add_announce_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	error -> {:error, error}
	end
	end

	def unannounce(
	%User{} = actor,
	%Object{} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
	unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
	{:ok, unannounce_activity} <- insert(unannounce_data, local),
	:ok <- maybe_federate(unannounce_activity),
	{:ok, _activity} <- Repo.delete(announce_activity),
	{:ok, object} <- remove_announce_from_object(announce_activity, object) do
	{:ok, unannounce_activity, object}
	else
	_e -> {:ok, object}
	end
	end

	def follow(follower, followed, activity_id \\ nil, local \\ true) do
	with data <- make_follow_data(follower, followed, activity_id),
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
	with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
	unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
	{:ok, activity} <- insert(unfollow_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, local \\ true) do
	user = User.get_cached_by_ap_id(actor)

	data = %{
	"type" => "Delete",
	"actor" => actor,
	"object" => id,
	"to" => [user.follower_address, "https://www.w3.org/ns/activitystreams#Public"]
	}

	with {:ok, _} <- Object.delete(object),
	{:ok, activity} <- insert(data, local),
	# Changing note count prior to enqueuing federation task in order to avoid race conditions on updating user.info
	{:ok, _actor} <- User.decrease_note_count(user),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def block(blocker, blocked, activity_id \\ nil, local \\ true) do
	ap_config = Application.get_env(:pleroma, :activitypub)
	unfollow_blocked = Keyword.get(ap_config, :unfollow_blocked)
	outgoing_blocks = Keyword.get(ap_config, :outgoing_blocks)

	with true <- unfollow_blocked do
	follow_activity = fetch_latest_follow(blocker, blocked)

	if follow_activity do
	unfollow(blocker, blocked, nil, local)
	end
	end

	with true <- outgoing_blocks,
	block_data <- make_block_data(blocker, blocked, activity_id),
	{:ok, activity} <- insert(block_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	_e -> {:ok, nil}
	end
	end

	def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
	with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
	unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
	{:ok, activity} <- insert(unblock_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def fetch_activities_for_context(context, opts \\ %{}) do
	public = ["https://www.w3.org/ns/activitystreams#Public"]

	recipients =
	if opts["user"], do: [opts["user"].ap_id \| opts["user"].following] ++ public, else: public

	query = from(activity in Activity)

	query =
	query
	\|> restrict_blocked(opts)
	\|> restrict_recipients(recipients, opts["user"])

	query =
	from(
	activity in query,
	where:
	fragment(
	"?->>'type' = ? and ?->>'context' = ?",
	activity.data,
	"Create",
	activity.data,
	^context
	),
	order_by: [desc: :id]
	)

	Repo.all(query)
	end

	def fetch_public_activities(opts \\ %{}) do
	q = fetch_activities_query(["https://www.w3.org/ns/activitystreams#Public"], opts)

	q
	\|> restrict_unlisted()
	\|> Repo.all()
	\|> Enum.reverse()
	end

	@valid_visibilities ~w[direct unlisted public private]

	defp restrict_visibility(query, %{visibility: visibility})
	when visibility in @valid_visibilities do
	query =
	from(
	a in query,
	where:
	fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
	)

	Ecto.Adapters.SQL.to_sql(:all, Repo, query)

	query
	end

	defp restrict_visibility(_query, %{visibility: visibility})
	when visibility not in @valid_visibilities do
	Logger.error("Could not restrict visibility to #{visibility}")
	end

	defp restrict_visibility(query, _visibility), do: query

	def fetch_user_activities(user, reading_user, params \\ %{}) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("actor_id", user.ap_id)
	\|> Map.put("whole_db", true)
	\|> Map.put("pinned_activity_ids", user.info.pinned_activities)

	recipients =
	if reading_user do
	["https://www.w3.org/ns/activitystreams#Public"] ++
	[reading_user.ap_id \| reading_user.following]
	else
	["https://www.w3.org/ns/activitystreams#Public"]
	end

	fetch_activities(recipients, params)
	\|> Enum.reverse()
	end

	defp restrict_since(query, %{"since_id" => since_id}) do
	from(activity in query, where: activity.id > ^since_id)
	end

	defp restrict_since(query, _), do: query

	defp restrict_tag(query, %{"tag" => tag}) do
	from(
	activity in query,
	where: fragment("? <@ (? #> '{\"object\",\"tag\"}')", ^tag, activity.data)
	)
	end

	defp restrict_tag(query, _), do: query

	defp restrict_to_cc(query, recipients_to, recipients_cc) do
	from(
	activity in query,
	where:
	fragment(
	"(?->'to' \\?\| ?) or (?->'cc' \\?\| ?)",
	activity.data,
	^recipients_to,
	activity.data,
	^recipients_cc
	)
	)
	end

	defp restrict_recipients(query, [], _user), do: query

	defp restrict_recipients(query, recipients, nil) do
	from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
	end

	defp restrict_recipients(query, recipients, user) do
	from(
	activity in query,
	where: fragment("? && ?", ^recipients, activity.recipients),
	or_where: activity.actor == ^user.ap_id
	)
	end

	defp restrict_limit(query, %{"limit" => limit}) do
	from(activity in query, limit: ^limit)
	end

	defp restrict_limit(query, _), do: query

	defp restrict_local(query, %{"local_only" => true}) do
	from(activity in query, where: activity.local == true)
	end

	defp restrict_local(query, _), do: query

	defp restrict_max(query, %{"max_id" => max_id}) do
	from(activity in query, where: activity.id < ^max_id)
	end

	defp restrict_max(query, _), do: query

	defp restrict_actor(query, %{"actor_id" => actor_id}) do
	from(activity in query, where: activity.actor == ^actor_id)
	end

	defp restrict_actor(query, _), do: query

	defp restrict_type(query, %{"type" => type}) when is_binary(type) do
	restrict_type(query, %{"type" => [type]})
	end

	defp restrict_type(query, %{"type" => type}) do
	from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
	end

	defp restrict_type(query, _), do: query

	defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
	from(
	activity in query,
	where: fragment("? <@ (? #> '{\"object\",\"likes\"}')", ^ap_id, activity.data)
	)
	end

	defp restrict_favorited_by(query, _), do: query

	defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
	from(
	activity in query,
	where: fragment("not (? #> '{\"object\",\"attachment\"}' = ?)", activity.data, ^[])
	)
	end

	defp restrict_media(query, _), do: query

	defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
	from(
	activity in query,
	where: fragment("?->'object'->>'inReplyTo' is null", activity.data)
	)
	end

	defp restrict_replies(query, _), do: query

	defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
	from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
	end

	defp restrict_reblogs(query, _), do: query

	defp restrict_blocked(query, %{"blocking_user" => %User{info: info}}) do
	blocks = info.blocks \|\| []
	domain_blocks = info.domain_blocks \|\| []

	from(
	activity in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
	where: fragment("not (?->'to' \\?\| ?)", activity.data, ^blocks),
	where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks)
	)
	end

	defp restrict_blocked(query, _), do: query

	defp restrict_unlisted(query) do
	from(
	activity in query,
	where:
	fragment(
	"not (coalesce(?->'cc', '{}'::jsonb) \\?\| ?)",
	activity.data,
	^["https://www.w3.org/ns/activitystreams#Public"]
	)
	)
	end

	defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
	from(activity in query, where: activity.id in ^ids)
	end

	defp restrict_pinned(query, _), do: query

	def fetch_activities_query(recipients, opts \\ %{}) do
	base_query =
	from(
	activity in Activity,
	limit: 20,
	order_by: [fragment("? desc nulls last", activity.id)]
	)

	base_query
	\|> restrict_recipients(recipients, opts["user"])
	\|> restrict_tag(opts)
	\|> restrict_since(opts)
	\|> restrict_local(opts)
	\|> restrict_limit(opts)
	\|> restrict_max(opts)
	\|> restrict_actor(opts)
	\|> restrict_type(opts)
	\|> restrict_favorited_by(opts)
	\|> restrict_blocked(opts)
	\|> restrict_media(opts)
	\|> restrict_visibility(opts)
	\|> restrict_replies(opts)
	\|> restrict_reblogs(opts)
	\|> restrict_pinned(opts)
	end

	def fetch_activities(recipients, opts \\ %{}) do
	fetch_activities_query(recipients, opts)
	\|> Repo.all()
	\|> Enum.reverse()
	end

	def fetch_activities_bounded(recipients_to, recipients_cc, opts \\ %{}) do
	fetch_activities_query([], opts)
	\|> restrict_to_cc(recipients_to, recipients_cc)
	\|> Repo.all()
	\|> Enum.reverse()
	end

	def upload(file, opts \\ []) do
	with {:ok, data} <- Upload.store(file, opts) do
	obj_data =
	if opts[:actor] do
	Map.put(data, "actor", opts[:actor])
	else
	data
	end

	Repo.insert(%Object{data: obj_data})
	end
	end

	def user_data_from_user_object(data) do
	avatar =
	data["icon"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["icon"]["url"]}]
	}

	banner =
	data["image"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["image"]["url"]}]
	}

	locked = data["manuallyApprovesFollowers"] \|\| false
	data = Transmogrifier.maybe_fix_user_object(data)

	user_data = %{
	ap_id: data["id"],
	info: %{
	"ap_enabled" => true,
	"source_data" => data,
	"banner" => banner,
	"locked" => locked
	},
	avatar: avatar,
	name: data["name"],
	follower_address: data["followers"],
	bio: data["summary"]
	}

	# nickname can be nil because of virtual actors
	user_data =
	if data["preferredUsername"] do
	Map.put(
	user_data,
	:nickname,
	"#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
	)
	else
	Map.put(user_data, :nickname, nil)
	end

	{:ok, user_data}
	end

	def fetch_and_prepare_user_from_ap_id(ap_id) do
	with {:ok, data} <- fetch_and_contain_remote_object_from_id(ap_id) do
	user_data_from_user_object(data)
	else
	e -> Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	end
	end

	def make_user_from_ap_id(ap_id) do
	if _user = User.get_by_ap_id(ap_id) do
	Transmogrifier.upgrade_user_from_ap_id(ap_id)
	else
	with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
	User.insert_or_update_user(data)
	else
	e -> {:error, e}
	end
	end
	end

	def make_user_from_nickname(nickname) do
	with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
	make_user_from_ap_id(ap_id)
	else
	_e -> {:error, "No AP id in WebFinger"}
	end
	end

	def should_federate?(inbox, public) do
	if public do
	true
	else
	inbox_info = URI.parse(inbox)
	!Enum.member?(Pleroma.Config.get([:instance, :quarantined_instances], []), inbox_info.host)
	end
	end

	def publish(actor, activity) do
	- followers =
	+ remote_followers =
	if actor.follower_address in activity.recipients do
	{:ok, followers} = User.get_followers(actor)
	followers \|> Enum.filter(&(!&1.local))
	else
	[]
	end

	public = is_public?(activity)

	remote_inboxes =
	- (Pleroma.Web.Salmon.remote_users(activity) ++ followers)
	+ (Pleroma.Web.Salmon.remote_users(activity) ++ remote_followers)
	\|> Enum.filter(fn user -> User.ap_enabled?(user) end)
	\|> Enum.map(fn %{info: %{source_data: data}} ->
	(is_map(data["endpoints"]) && Map.get(data["endpoints"], "sharedInbox")) \|\| data["inbox"]
	end)
	\|> Enum.uniq()
	\|> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
	+ \|> Instances.filter_reachable()

	{:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
	json = Jason.encode!(data)

	Enum.each(remote_inboxes, fn inbox ->
	Federator.enqueue(:publish_single_ap, %{
	inbox: inbox,
	json: json,
	actor: actor,
	id: activity.data["id"]
	})
	end)
	end

	def publish_one(%{inbox: inbox} = activity) do
	if Instances.reachable?(inbox) do
	do_publish_one(activity)
	else
	{:error, :noop}
	end
	end

	defp do_publish_one(%{inbox: inbox, json: json, actor: actor, id: id}) do
	Logger.info("Federating #{id} to #{inbox}")
	host = URI.parse(inbox).host

	digest = "SHA-256=" <> (:crypto.hash(:sha256, json) \|> Base.encode64())

	signature =
	Pleroma.Web.HTTPSignatures.sign(actor, %{
	host: host,
	"content-length": byte_size(json),
	digest: digest
	})

	with {:ok, %{status: code}} when code in 200..299 <-
	result =
	@httpoison.post(
	inbox,
	json,
	[
	{"Content-Type", "application/activity+json"},
	{"signature", signature},
	{"digest", digest},
	{"referer", Pleroma.Web.Endpoint.url()}
	]
	) do
	Instances.set_reachable(inbox)
	result
	else
	e ->
	Instances.set_unreachable(inbox)
	e
	end
	end

	# TODO:
	# This will create a Create activity, which we need internally at the moment.
	def fetch_object_from_id(id) 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),
	params <- %{
	"type" => "Create",
	"to" => data["to"],
	"cc" => data["cc"],
	"actor" => data["actor"] \|\| data["attributedTo"],
	"object" => data
	},
	:ok <- Transmogrifier.contain_origin(id, params),
	{:ok, activity} <- Transmogrifier.handle_incoming(params) do
	{:ok, Object.normalize(activity.data["object"])}
	else
	{:error, {:reject, nil}} ->
	{:reject, nil}

	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.data["object"])}
	e -> e
	end
	end
	end
	end

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

	with true <- String.starts_with?(id, "http"),
	{:ok, %{body: body, status: code}} when code in 200..299 <-
	@httpoison.get(
	id,
	[{:Accept, "application/activity+json"}]
	),
	{:ok, data} <- Jason.decode(body),
	:ok <- Transmogrifier.contain_origin_from_id(id, data) do
	{:ok, data}
	else
	e ->
	{:error, e}
	end
	end

	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
	!is_public?(activity) && Enum.any?(activity.data["to"], &String.contains?(&1, "/followers"))
	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.data["to"] ++ (activity.data["cc"] \|\| [])
	visible_for_user?(activity, nil) \|\| Enum.any?(x, &(&1 in y))
	end

	# guard
	def entire_thread_visible_for_user?(nil, _user), do: false

	# child
	def entire_thread_visible_for_user?(
	%Activity{data: %{"object" => %{"inReplyTo" => parent_id}}} = tail,
	user
	)
	when is_binary(parent_id) do
	parent = Activity.get_in_reply_to_activity(tail)
	visible_for_user?(tail, user) && entire_thread_visible_for_user?(parent, user)
	end

	# root
	def entire_thread_visible_for_user?(tail, user), do: visible_for_user?(tail, user)

	# filter out broken threads
	def contain_broken_threads(%Activity{} = activity, %User{} = user) do
	entire_thread_visible_for_user?(activity, user)
	end

	# do post-processing on a specific activity
	def contain_activity(%Activity{} = activity, %User{} = user) do
	contain_broken_threads(activity, user)
	end

	# do post-processing on a timeline
	def contain_timeline(timeline, user) do
	timeline
	\|> Enum.filter(fn activity ->
	contain_activity(activity, user)
	end)
	end
	end
	diff --git a/lib/pleroma/web/salmon/salmon.ex b/lib/pleroma/web/salmon/salmon.ex
	index e4d2d9517..848131d52 100644
	--- a/lib/pleroma/web/salmon/salmon.ex
	+++ b/lib/pleroma/web/salmon/salmon.ex
	@@ -1,235 +1,241 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Salmon do
	@httpoison Application.get_env(:pleroma, :httpoison)

	use Bitwise
	alias Pleroma.Instances
	alias Pleroma.Web.XML
	alias Pleroma.Web.OStatus.ActivityRepresenter
	alias Pleroma.User
	require Logger

	def decode(salmon) do
	doc = XML.parse_document(salmon)

	{:xmlObj, :string, data} = :xmerl_xpath.string('string(//me:data[1])', doc)
	{:xmlObj, :string, sig} = :xmerl_xpath.string('string(//me:sig[1])', doc)
	{:xmlObj, :string, alg} = :xmerl_xpath.string('string(//me:alg[1])', doc)
	{:xmlObj, :string, encoding} = :xmerl_xpath.string('string(//me:encoding[1])', doc)
	{:xmlObj, :string, type} = :xmerl_xpath.string('string(//me:data[1]/@type)', doc)

	{:ok, data} = Base.url_decode64(to_string(data), ignore: :whitespace)
	{:ok, sig} = Base.url_decode64(to_string(sig), ignore: :whitespace)
	alg = to_string(alg)
	encoding = to_string(encoding)
	type = to_string(type)

	[data, type, encoding, alg, sig]
	end

	def fetch_magic_key(salmon) do
	with [data, _, _, _, _] <- decode(salmon),
	doc <- XML.parse_document(data),
	uri when not is_nil(uri) <- XML.string_from_xpath("/entry/author[1]/uri", doc),
	{:ok, public_key} <- User.get_public_key_for_ap_id(uri),
	magic_key <- encode_key(public_key) do
	{:ok, magic_key}
	end
	end

	def decode_and_validate(magickey, salmon) do
	[data, type, encoding, alg, sig] = decode(salmon)

	signed_text =
	[data, type, encoding, alg]
	\|> Enum.map(&Base.url_encode64/1)
	\|> Enum.join(".")

	key = decode_key(magickey)

	verify = :public_key.verify(signed_text, :sha256, sig, key)

	if verify do
	{:ok, data}
	else
	:error
	end
	end

	def decode_key("RSA." <> magickey) do
	make_integer = fn bin ->
	list = :erlang.binary_to_list(bin)
	Enum.reduce(list, 0, fn el, acc -> acc <<< 8 \|\|\| el end)
	end

	[modulus, exponent] =
	magickey
	\|> String.split(".")
	\|> Enum.map(fn n -> Base.url_decode64!(n, padding: false) end)
	\|> Enum.map(make_integer)

	{:RSAPublicKey, modulus, exponent}
	end

	def encode_key({:RSAPublicKey, modulus, exponent}) do
	modulus_enc = :binary.encode_unsigned(modulus) \|> Base.url_encode64()
	exponent_enc = :binary.encode_unsigned(exponent) \|> Base.url_encode64()

	"RSA.#{modulus_enc}.#{exponent_enc}"
	end

	# Native generation of RSA keys is only available since OTP 20+ and in default build conditions
	# We try at compile time to generate natively an RSA key otherwise we fallback on the old way.
	try do
	_ = :public_key.generate_key({:rsa, 2048, 65537})

	def generate_rsa_pem do
	key = :public_key.generate_key({:rsa, 2048, 65537})
	entry = :public_key.pem_entry_encode(:RSAPrivateKey, key)
	pem = :public_key.pem_encode([entry]) \|> String.trim_trailing()
	{:ok, pem}
	end
	rescue
	_ ->
	def generate_rsa_pem do
	port = Port.open({:spawn, "openssl genrsa"}, [:binary])

	{:ok, pem} =
	receive do
	{^port, {:data, pem}} -> {:ok, pem}
	end

	Port.close(port)

	if Regex.match?(~r/RSA PRIVATE KEY/, pem) do
	{:ok, pem}
	else
	:error
	end
	end
	end

	def keys_from_pem(pem) do
	[private_key_code] = :public_key.pem_decode(pem)
	private_key = :public_key.pem_entry_decode(private_key_code)
	{:RSAPrivateKey, _, modulus, exponent, _, _, _, _, _, _, _} = private_key
	public_key = {:RSAPublicKey, modulus, exponent}
	{:ok, private_key, public_key}
	end

	def encode(private_key, doc) do
	type = "application/atom+xml"
	encoding = "base64url"
	alg = "RSA-SHA256"

	signed_text =
	[doc, type, encoding, alg]
	\|> Enum.map(&Base.url_encode64/1)
	\|> Enum.join(".")

	signature =
	signed_text
	\|> :public_key.sign(:sha256, private_key)
	\|> to_string
	\|> Base.url_encode64()

	doc_base64 =
	doc
	\|> Base.url_encode64()

	# Don't need proper xml building, these strings are safe to leave unescaped
	salmon = """
	<?xml version="1.0" encoding="UTF-8"?>
	<me:env xmlns:me="http://salmon-protocol.org/ns/magic-env">
	<me:data type="application/atom+xml">#{doc_base64}</me:data>
	<me:encoding>#{encoding}</me:encoding>
	<me:alg>#{alg}</me:alg>
	<me:sig>#{signature}</me:sig>
	</me:env>
	"""

	{:ok, salmon}
	end

	def remote_users(%{data: %{"to" => to} = data}) do
	to = to ++ (data["cc"] \|\| [])

	to
	\|> Enum.map(fn id -> User.get_cached_by_ap_id(id) end)
	\|> Enum.filter(fn user -> user && !user.local end)
	end

	# push an activity to remote accounts
	#
	defp send_to_user(%{info: %{salmon: salmon}}, feed, poster),
	do: send_to_user(salmon, feed, poster)

	defp send_to_user(url, feed, poster) when is_binary(url) do
	with {:reachable, true} <- {:reachable, Instances.reachable?(url)},
	{:ok, %{status: code}} when code in 200..299 <-
	poster.(
	url,
	feed,
	[
	{"Content-Type", "application/magic-envelope+xml"},
	{"referer", Pleroma.Web.Endpoint.url()}
	]
	) do
	Instances.set_reachable(url)
	Logger.debug(fn -> "Pushed to #{url}, code #{code}" end)
	else
	{:reachable, false} ->
	Logger.debug(fn -> "Pushing Salmon to #{url} skipped as marked unreachable)" end)
	:noop

	e ->
	Instances.set_unreachable(url)
	Logger.debug(fn -> "Pushing Salmon to #{url} failed, #{inspect(e)}" end)
	end
	end

	defp send_to_user(_, _, _), do: nil

	@supported_activities [
	"Create",
	"Follow",
	"Like",
	"Announce",
	"Undo",
	"Delete"
	]

	@doc """
	Publishes an activity to remote accounts
	"""
	@spec publish(User.t(), Pleroma.Activity.t(), Pleroma.HTTP.t()) :: none
	def publish(user, activity, poster \\ &@httpoison.post/3)

	def publish(%{info: %{keys: keys}} = user, %{data: %{"type" => type}} = activity, poster)
	when type in @supported_activities do
	feed = ActivityRepresenter.to_simple_form(activity, user, true)

	if feed do
	feed =
	ActivityRepresenter.wrap_with_entry(feed)
	\|> :xmerl.export_simple(:xmerl_xml)
	\|> to_string

	{:ok, private, _} = keys_from_pem(keys)
	{:ok, feed} = encode(private, feed)

	- remote_users(activity)
	+ remote_users = remote_users(activity)
	+
	+ salmon_urls = Enum.map(remote_users, & &1.info.salmon)
	+ reachable_salmon_urls = Instances.filter_reachable(salmon_urls)
	+
	+ remote_users
	+ \|> Enum.filter(&(&1.info.salmon in reachable_salmon_urls))
	\|> Enum.each(fn remote_user ->
	Task.start(fn ->
	Logger.debug(fn -> "Sending Salmon to #{remote_user.ap_id}" end)
	send_to_user(remote_user, feed, poster)
	end)
	end)
	end
	end

	def publish(%{id: id}, _, _), do: Logger.debug(fn -> "Keys missing for user #{id}" end)
	end
	diff --git a/lib/pleroma/web/websub/websub.ex b/lib/pleroma/web/websub/websub.ex
	index ac8903913..bb4442591 100644
	--- a/lib/pleroma/web/websub/websub.ex
	+++ b/lib/pleroma/web/websub/websub.ex
	@@ -1,296 +1,300 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Websub do
	alias Ecto.Changeset
	alias Pleroma.Repo
	alias Pleroma.Instances
	alias Pleroma.Web.Websub.{WebsubServerSubscription, WebsubClientSubscription}
	alias Pleroma.Web.OStatus.FeedRepresenter
	alias Pleroma.Web.{XML, Endpoint, OStatus}
	alias Pleroma.Web.Router.Helpers
	require Logger

	import Ecto.Query

	@httpoison Application.get_env(:pleroma, :httpoison)

	def verify(subscription, getter \\ &@httpoison.get/3) do
	challenge = Base.encode16(:crypto.strong_rand_bytes(8))
	lease_seconds = NaiveDateTime.diff(subscription.valid_until, subscription.updated_at)
	lease_seconds = lease_seconds \|> to_string

	params = %{
	"hub.challenge": challenge,
	"hub.lease_seconds": lease_seconds,
	"hub.topic": subscription.topic,
	"hub.mode": "subscribe"
	}

	url = hd(String.split(subscription.callback, "?"))
	query = URI.parse(subscription.callback).query \|\| ""
	params = Map.merge(params, URI.decode_query(query))

	with {:ok, response} <- getter.(url, [], params: params),
	^challenge <- response.body do
	changeset = Changeset.change(subscription, %{state: "active"})
	Repo.update(changeset)
	else
	e ->
	Logger.debug("Couldn't verify subscription")
	Logger.debug(inspect(e))
	{:error, subscription}
	end
	end

	@supported_activities [
	"Create",
	"Follow",
	"Like",
	"Announce",
	"Undo",
	"Delete"
	]
	def publish(topic, user, %{data: %{"type" => type}} = activity)
	when type in @supported_activities do
	- # TODO: Only send to still valid subscriptions.
	+ response =
	+ user
	+ \|> FeedRepresenter.to_simple_form([activity], [user])
	+ \|> :xmerl.export_simple(:xmerl_xml)
	+ \|> to_string
	+
	query =
	from(
	sub in WebsubServerSubscription,
	where: sub.topic == ^topic and sub.state == "active",
	where: fragment("? > NOW()", sub.valid_until)
	)

	subscriptions = Repo.all(query)

	- Enum.each(subscriptions, fn sub ->
	- response =
	- user
	- \|> FeedRepresenter.to_simple_form([activity], [user])
	- \|> :xmerl.export_simple(:xmerl_xml)
	- \|> to_string
	+ callbacks = Enum.map(subscriptions, & &1.callback)
	+ reachable_callbacks = Instances.filter_reachable(callbacks)

	+ subscriptions
	+ \|> Enum.filter(&(&1.callback in reachable_callbacks))
	+ \|> Enum.each(fn sub ->
	data = %{
	xml: response,
	topic: topic,
	callback: sub.callback,
	secret: sub.secret
	}

	Pleroma.Web.Federator.enqueue(:publish_single_websub, data)
	end)
	end

	def publish(_, _, _), do: ""

	def sign(secret, doc) do
	:crypto.hmac(:sha, secret, to_string(doc)) \|> Base.encode16() \|> String.downcase()
	end

	def incoming_subscription_request(user, %{"hub.mode" => "subscribe"} = params) do
	with {:ok, topic} <- valid_topic(params, user),
	{:ok, lease_time} <- lease_time(params),
	secret <- params["hub.secret"],
	callback <- params["hub.callback"] do
	subscription = get_subscription(topic, callback)

	data = %{
	state: subscription.state \|\| "requested",
	topic: topic,
	secret: secret,
	callback: callback
	}

	change = Changeset.change(subscription, data)
	websub = Repo.insert_or_update!(change)

	change =
	Changeset.change(websub, %{valid_until: NaiveDateTime.add(websub.updated_at, lease_time)})

	websub = Repo.update!(change)

	Pleroma.Web.Federator.enqueue(:verify_websub, websub)

	{:ok, websub}
	else
	{:error, reason} ->
	Logger.debug("Couldn't create subscription")
	Logger.debug(inspect(reason))

	{:error, reason}
	end
	end

	def incoming_subscription_request(user, params) do
	Logger.info("Unhandled WebSub request for #{user.nickname}: #{inspect(params)}")

	{:error, "Invalid WebSub request"}
	end

	defp get_subscription(topic, callback) do
	Repo.get_by(WebsubServerSubscription, topic: topic, callback: callback) \|\|
	%WebsubServerSubscription{}
	end

	# Temp hack for mastodon.
	defp lease_time(%{"hub.lease_seconds" => ""}) do
	# three days
	{:ok, 60 * 60 * 24 * 3}
	end

	defp lease_time(%{"hub.lease_seconds" => lease_seconds}) do
	{:ok, String.to_integer(lease_seconds)}
	end

	defp lease_time(_) do
	# three days
	{:ok, 60 * 60 * 24 * 3}
	end

	defp valid_topic(%{"hub.topic" => topic}, user) do
	if topic == OStatus.feed_path(user) do
	{:ok, OStatus.feed_path(user)}
	else
	{:error, "Wrong topic requested, expected #{OStatus.feed_path(user)}, got #{topic}"}
	end
	end

	def subscribe(subscriber, subscribed, requester \\ &request_subscription/1) do
	topic = subscribed.info.topic
	# FIXME: Race condition, use transactions
	{:ok, subscription} =
	with subscription when not is_nil(subscription) <-
	Repo.get_by(WebsubClientSubscription, topic: topic) do
	subscribers = [subscriber.ap_id \| subscription.subscribers] \|> Enum.uniq()
	change = Ecto.Changeset.change(subscription, %{subscribers: subscribers})
	Repo.update(change)
	else
	_e ->
	subscription = %WebsubClientSubscription{
	topic: topic,
	hub: subscribed.info.hub,
	subscribers: [subscriber.ap_id],
	state: "requested",
	secret: :crypto.strong_rand_bytes(8) \|> Base.url_encode64(),
	user: subscribed
	}

	Repo.insert(subscription)
	end

	requester.(subscription)
	end

	def gather_feed_data(topic, getter \\ &@httpoison.get/1) do
	with {:ok, response} <- getter.(topic),
	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),
	hub when not is_nil(hub) <- XML.string_from_xpath(~S{/feed/link[@rel="hub"]/@href}, doc) do
	name = XML.string_from_xpath("/feed/author[1]/name", doc)
	preferredUsername = XML.string_from_xpath("/feed/author[1]/poco:preferredUsername", doc)
	displayName = XML.string_from_xpath("/feed/author[1]/poco:displayName", doc)
	avatar = OStatus.make_avatar_object(doc)
	bio = XML.string_from_xpath("/feed/author[1]/summary", doc)

	{:ok,
	%{
	"uri" => uri,
	"hub" => hub,
	"nickname" => preferredUsername \|\| name,
	"name" => displayName \|\| name,
	"host" => URI.parse(uri).host,
	"avatar" => avatar,
	"bio" => bio
	}}
	else
	e ->
	{:error, e}
	end
	end

	def request_subscription(websub, poster \\ &@httpoison.post/3, timeout \\ 10_000) do
	data = [
	"hub.mode": "subscribe",
	"hub.topic": websub.topic,
	"hub.secret": websub.secret,
	"hub.callback": Helpers.websub_url(Endpoint, :websub_subscription_confirmation, websub.id)
	]

	# This checks once a second if we are confirmed yet
	websub_checker = fn ->
	helper = fn helper ->
	:timer.sleep(1000)
	websub = Repo.get_by(WebsubClientSubscription, id: websub.id, state: "accepted")
	if websub, do: websub, else: helper.(helper)
	end

	helper.(helper)
	end

	task = Task.async(websub_checker)

	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}
	else
	e ->
	Task.shutdown(task)

	change = Ecto.Changeset.change(websub, %{state: "rejected"})
	{:ok, websub} = Repo.update(change)

	Logger.debug(fn -> "Couldn't confirm subscription: #{inspect(websub)}" end)
	Logger.debug(fn -> "error: #{inspect(e)}" end)

	{:error, websub}
	end
	end

	def refresh_subscriptions(delta \\ 60 * 60 * 24) do
	Logger.debug("Refreshing subscriptions")

	cut_off = NaiveDateTime.add(NaiveDateTime.utc_now(), delta)

	query = from(sub in WebsubClientSubscription, where: sub.valid_until < ^cut_off)

	subs = Repo.all(query)

	Enum.each(subs, fn sub ->
	Pleroma.Web.Federator.enqueue(:request_subscription, sub)
	end)
	end

	def publish_one(%{xml: xml, topic: topic, callback: callback, secret: secret}) do
	signature = sign(secret \|\| "", xml)
	Logger.info(fn -> "Pushing #{topic} to #{callback}" end)

	with {:reachable, true} <- {:reachable, Instances.reachable?(callback)},
	{:ok, %{status: code}} when code in 200..299 <-
	@httpoison.post(
	callback,
	xml,
	[
	{"Content-Type", "application/atom+xml"},
	{"X-Hub-Signature", "sha1=#{signature}"},
	{"referer", Pleroma.Web.Endpoint.url()}
	]
	) do
	Instances.set_reachable(callback)
	Logger.info(fn -> "Pushed to #{callback}, code #{code}" end)
	{:ok, code}
	else
	{:reachable, false} ->
	Logger.debug(fn -> "Pushing to #{callback} skipped as marked unreachable)" end)
	{:error, :noop}

	e ->
	Instances.set_unreachable(callback)
	Logger.debug(fn -> "Couldn't push to #{callback}, #{inspect(e)}" end)
	{:error, e}
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 11:17 PM (18 h, 6 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1800715
Default Alt Text: (48 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions