No OneTemporary
Actions

Size

46 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/activity.ex b/lib/pleroma/activity.ex
	index a35ccc9b4..afd09982f 100644
	--- a/lib/pleroma/activity.ex
	+++ b/lib/pleroma/activity.ex
	@@ -1,45 +1,45 @@
	defmodule Pleroma.Activity do
	use Ecto.Schema
	alias Pleroma.{Repo, Activity, Notification}
	import Ecto.Query

	schema "activities" do
	field :data, :map
	field :local, :boolean, default: true
	field :actor, :string
	- has_many :notifications, Notification
	+ has_many :notifications, Notification, on_delete: :delete_all

	timestamps()
	end

	def get_by_ap_id(ap_id) do
	Repo.one(from activity in Activity,
	where: fragment("(?)->>'id' = ?", activity.data, ^to_string(ap_id)))
	end

	# TODO:
	# Go through these and fix them everywhere.
	# Wrong name, only returns create activities
	def all_by_object_ap_id_q(ap_id) do
	from activity in Activity,
	where: fragment("coalesce((?)->'object'->>'id', (?)->>'object') = ?", activity.data, activity.data, ^to_string(ap_id)),
	where: fragment("(?)->>'type' = 'Create'", activity.data)
	end

	# Wrong name, returns all.
	def all_non_create_by_object_ap_id_q(ap_id) do
	from activity in Activity,
	where: fragment("coalesce((?)->'object'->>'id', (?)->>'object') = ?", activity.data, activity.data, ^to_string(ap_id))
	end

	# Wrong name plz fix thx
	def all_by_object_ap_id(ap_id) do
	Repo.all(all_by_object_ap_id_q(ap_id))
	end

	def get_create_activity_by_object_ap_id(ap_id) do
	Repo.one(from activity in Activity,
	where: fragment("coalesce((?)->'object'->>'id', (?)->>'object') = ?", activity.data, activity.data, ^to_string(ap_id)),
	where: fragment("(?)->>'type' = 'Create'", activity.data))
	end
	end
	diff --git a/lib/pleroma/plugs/authentication_plug.ex b/lib/pleroma/plugs/authentication_plug.ex
	index beb02eb88..60f6faf49 100644
	--- a/lib/pleroma/plugs/authentication_plug.ex
	+++ b/lib/pleroma/plugs/authentication_plug.ex
	@@ -1,63 +1,64 @@
	defmodule Pleroma.Plugs.AuthenticationPlug do
	alias Comeonin.Pbkdf2
	import Plug.Conn
	alias Pleroma.User

	def init(options) do
	options
	end

	def call(%{assigns: %{user: %User{}}} = conn, _), do: conn

	def call(conn, opts) do
	with {:ok, username, password} <- decode_header(conn),
	{:ok, user} <- opts[:fetcher].(username),
	+ false <- !!user.info["deactivated"],
	saved_user_id <- get_session(conn, :user_id),
	{:ok, verified_user} <- verify(user, password, saved_user_id)
	do
	conn
	\|> assign(:user, verified_user)
	\|> put_session(:user_id, verified_user.id)
	else
	_ -> conn \|> halt_or_continue(opts)
	end
	end

	# Short-circuit if we have a cookie with the id for the given user.
	defp verify(%{id: id} = user, _password, id) do
	{:ok, user}
	end

	defp verify(nil, _password, _user_id) do
	Pbkdf2.dummy_checkpw
	:error
	end

	defp verify(user, password, _user_id) do
	if Pbkdf2.checkpw(password, user.password_hash) do
	{:ok, user}
	else
	:error
	end
	end

	defp decode_header(conn) do
	with ["Basic " <> header] <- get_req_header(conn, "authorization"),
	{:ok, userinfo} <- Base.decode64(header),
	[username, password] <- String.split(userinfo, ":", parts: 2)
	do
	{:ok, username, password}
	end
	end

	defp halt_or_continue(conn, %{optional: true}) do
	conn \|> assign(:user, nil)
	end

	defp halt_or_continue(conn, _) do
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Poison.encode!(%{error: "Invalid credentials."}))
	\|> halt
	end
	end
	diff --git a/lib/pleroma/plugs/oauth_plug.ex b/lib/pleroma/plugs/oauth_plug.ex
	index 775423bb1..be737dc9a 100644
	--- a/lib/pleroma/plugs/oauth_plug.ex
	+++ b/lib/pleroma/plugs/oauth_plug.ex
	@@ -1,26 +1,27 @@
	defmodule Pleroma.Plugs.OAuthPlug do
	import Plug.Conn
	alias Pleroma.User
	alias Pleroma.Repo
	alias Pleroma.Web.OAuth.Token

	def init(options) do
	options
	end

	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) do
	+ %User{} = user <- Repo.get(User, user_id),
	+ false <- !!user.info["deactivated"] do
	conn
	\|> assign(:user, user)
	else
	_ -> conn
	end
	end
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index afc62f265..09bcf0cb4 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,337 +1,379 @@
	defmodule Pleroma.User do
	use Ecto.Schema

	import Ecto.{Changeset, Query}
	alias Pleroma.{Repo, User, Object, Web, Activity, Notification}
	alias Comeonin.Pbkdf2
	alias Pleroma.Web.{OStatus, Websub}
	- alias Pleroma.Web.ActivityPub.Utils
	+ alias Pleroma.Web.ActivityPub.{Utils, ActivityPub}

	schema "users" do
	field :bio, :string
	field :email, :string
	field :name, :string
	field :nickname, :string
	field :password_hash, :string
	field :password, :string, virtual: true
	field :password_confirmation, :string, virtual: true
	field :following, {:array, :string}, default: []
	field :ap_id, :string
	field :avatar, :map
	field :local, :boolean, default: true
	field :info, :map, default: %{}
	field :follower_address, :string
	has_many :notifications, Notification

	timestamps()
	end

	def avatar_url(user) do
	case user.avatar do
	%{"url" => [%{"href" => href} \| _]} -> href
	_ -> "https://placehold.it/48x48"
	end
	end

	def banner_url(user) do
	case user.info["banner"] do
	%{"url" => [%{"href" => href} \| _]} -> href
	_ -> nil
	end
	end

	def ap_id(%User{nickname: nickname}) do
	"#{Web.base_url}/users/#{nickname}"
	end

	def ap_followers(%User{} = user) do
	"#{ap_id(user)}/followers"
	end

	def follow_changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:following])
	\|> validate_required([:following])
	end

	def info_changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:info])
	\|> validate_required([:info])
	end

	def user_info(%User{} = user) do
	oneself = if user.local, do: 1, else: 0
	%{
	following_count: length(user.following) - oneself,
	note_count: user.info["note_count"] \|\| 0,
	follower_count: user.info["follower_count"] \|\| 0
	}
	end

	@email_regex ~r/^[a-zA-Z0-9.!#$%&'+\/=?^_`{\|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)$/
	def remote_user_creation(params) do
	changes = %User{}
	\|> cast(params, [:bio, :name, :ap_id, :nickname, :info, :avatar])
	\|> validate_required([:name, :ap_id, :nickname])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, @email_regex)
	\|> validate_length(:bio, max: 5000)
	\|> validate_length(:name, max: 100)
	\|> put_change(:local, false)
	if changes.valid? do
	followers = User.ap_followers(%User{nickname: changes.changes[:nickname]})
	changes
	\|> put_change(:follower_address, followers)
	else
	changes
	end
	end

	def update_changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:bio, :name])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, ~r/^[a-zA-Z\d]+$/)
	\|> validate_length(:bio, min: 1, max: 1000)
	\|> validate_length(:name, min: 1, max: 100)
	end

	def password_update_changeset(struct, params) do
	changeset = struct
	\|> cast(params, [:password, :password_confirmation])
	\|> validate_required([:password, :password_confirmation])
	\|> validate_confirmation(:password)

	if changeset.valid? do
	hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])
	changeset
	\|> put_change(:password_hash, hashed)
	else
	changeset
	end
	end

	def reset_password(user, data) do
	- Repo.update(password_update_changeset(user, data))
	+ update_and_set_cache(password_update_changeset(user, data))
	end

	def register_changeset(struct, params \\ %{}) do
	changeset = struct
	\|> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation])
	\|> validate_required([:bio, :email, :name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, ~r/^[a-zA-Z\d]+$/)
	\|> validate_format(:email, @email_regex)
	\|> validate_length(:bio, min: 1, max: 1000)
	\|> validate_length(:name, min: 1, max: 100)

	if changeset.valid? do
	hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])
	ap_id = User.ap_id(%User{nickname: changeset.changes[:nickname]})
	followers = User.ap_followers(%User{nickname: changeset.changes[:nickname]})
	changeset
	\|> put_change(:password_hash, hashed)
	\|> put_change(:ap_id, ap_id)
	\|> put_change(:following, [followers])
	\|> put_change(:follower_address, followers)
	else
	changeset
	end
	end

	- def follow(%User{} = follower, %User{} = followed) do
	+ def follow(%User{} = follower, %User{info: info} = followed) do
	ap_followers = followed.follower_address
	- if following?(follower, followed) do
	+ if following?(follower, followed) or info["deactivated"] do
	{:error,
	"Could not follow user: #{followed.nickname} is already on your list."}
	else
	if !followed.local && follower.local do
	Websub.subscribe(follower, followed)
	end

	following = [ap_followers \| follower.following]
	\|> Enum.uniq

	follower = follower
	\|> follow_changeset(%{following: following})
	- \|> Repo.update
	+ \|> update_and_set_cache

	{:ok, _} = update_follower_count(followed)

	follower
	end
	end

	def unfollow(%User{} = follower, %User{} = followed) do
	ap_followers = followed.follower_address
	if following?(follower, followed) and follower.ap_id != followed.ap_id do
	following = follower.following
	\|> List.delete(ap_followers)

	{ :ok, follower } = follower
	\|> follow_changeset(%{following: following})
	- \|> Repo.update
	+ \|> update_and_set_cache

	{:ok, followed} = update_follower_count(followed)

	{:ok, follower, Utils.fetch_latest_follow(follower, followed)}
	else
	{:error, "Not subscribed!"}
	end
	end

	def following?(%User{} = follower, %User{} = followed) do
	Enum.member?(follower.following, followed.follower_address)
	end

	def get_by_ap_id(ap_id) do
	Repo.get_by(User, ap_id: ap_id)
	end

	+ def update_and_set_cache(changeset) do
	+ with {:ok, user} <- Repo.update(changeset) do
	+ Cachex.set(:user_cache, "ap_id:#{user.ap_id}", user)
	+ Cachex.set(:user_cache, "nickname:#{user.nickname}", user)
	+ Cachex.set(:user_cache, "user_info:#{user.id}", user_info(user))
	+ {:ok, user}
	+ else
	+ e -> e
	+ end
	+ end
	+
	def get_cached_by_ap_id(ap_id) do
	key = "ap_id:#{ap_id}"
	Cachex.get!(:user_cache, key, fallback: fn(_) -> get_by_ap_id(ap_id) end)
	end

	def get_cached_by_nickname(nickname) do
	key = "nickname:#{nickname}"
	Cachex.get!(:user_cache, key, fallback: fn(_) -> get_or_fetch_by_nickname(nickname) end)
	end

	def get_by_nickname(nickname) do
	Repo.get_by(User, nickname: nickname)
	end

	def get_cached_user_info(user) do
	key = "user_info:#{user.id}"
	Cachex.get!(:user_cache, key, fallback: fn(_) -> user_info(user) end)
	end

	def get_or_fetch_by_nickname(nickname) do
	with %User{} = user <- get_by_nickname(nickname) do
	user
	else _e ->
	with [_nick, _domain] <- String.split(nickname, "@"),
	{:ok, user} <- OStatus.make_user(nickname) do
	user
	else _e -> nil
	end
	end
	end

	# TODO: these queries could be more efficient if the type in postgresql wasn't map, but array.
	def get_followers(%User{id: id, follower_address: follower_address}) do
	q = from u in User,
	where: fragment("? @> ?", u.following, ^follower_address ),
	where: u.id != ^id

	{:ok, Repo.all(q)}
	end

	def get_friends(%User{id: id, following: following}) do
	q = from u in User,
	where: u.follower_address in ^following,
	where: u.id != ^id

	{:ok, Repo.all(q)}
	end

	def increase_note_count(%User{} = user) do
	note_count = (user.info["note_count"] \|\| 0) + 1
	new_info = Map.put(user.info, "note_count", note_count)

	cs = info_changeset(user, %{info: new_info})

	- Repo.update(cs)
	+ update_and_set_cache(cs)
	end

	def update_note_count(%User{} = user) do
	note_count_query = from a in Object,
	where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
	select: count(a.id)

	note_count = Repo.one(note_count_query)

	new_info = Map.put(user.info, "note_count", note_count)

	cs = info_changeset(user, %{info: new_info})

	- Repo.update(cs)
	+ update_and_set_cache(cs)
	end

	def update_follower_count(%User{} = user) do
	follower_count_query = from u in User,
	where: fragment("? @> ?", u.following, ^user.follower_address),
	where: u.id != ^user.id,
	select: count(u.id)

	follower_count = Repo.one(follower_count_query)

	new_info = Map.put(user.info, "follower_count", follower_count)

	cs = info_changeset(user, %{info: new_info})

	- Repo.update(cs)
	+ update_and_set_cache(cs)
	end

	def get_notified_from_activity(%Activity{data: %{"to" => to}}) do
	query = from u in User,
	where: u.ap_id in ^to,
	where: u.local == true

	Repo.all(query)
	end

	def get_recipients_from_activity(%Activity{data: %{"to" => to}}) do
	query = from u in User,
	where: u.ap_id in ^to,
	or_where: fragment("? \\\?\| ?", u.following, ^to)

	query = from u in query,
	where: u.local == true

	Repo.all(query)
	end

	def search(query, resolve) do
	if resolve do
	User.get_or_fetch_by_nickname(query)
	end
	q = from u in User,
	where: fragment("(to_tsvector('english', ?) \|\| to_tsvector('english', ?)) @@ plainto_tsquery('english', ?)", u.nickname, u.name, ^query),
	limit: 20
	Repo.all(q)
	end

	def block(user, %{ap_id: ap_id}) do
	blocks = user.info["blocks"] \|\| []
	new_blocks = Enum.uniq([ap_id \| blocks])
	new_info = Map.put(user.info, "blocks", new_blocks)

	cs = User.info_changeset(user, %{info: new_info})
	- Repo.update(cs)
	+ update_and_set_cache(cs)
	end

	def unblock(user, %{ap_id: ap_id}) do
	blocks = user.info["blocks"] \|\| []
	new_blocks = List.delete(blocks, ap_id)
	new_info = Map.put(user.info, "blocks", new_blocks)

	cs = User.info_changeset(user, %{info: new_info})
	- Repo.update(cs)
	+ update_and_set_cache(cs)
	end

	def blocks?(user, %{ap_id: ap_id}) do
	blocks = user.info["blocks"] \|\| []
	Enum.member?(blocks, ap_id)
	end

	def local_user_query() do
	from u in User,
	where: u.local == true
	end

	+ def deactivate (%User{} = user) do
	+ new_info = Map.put(user.info, "deactivated", true)
	+ cs = User.info_changeset(user, %{info: new_info})
	+ update_and_set_cache(cs)
	+ end
	+
	+ def delete (%User{} = user) do
	+ {:ok, user} = User.deactivate(user)
	+
	+ # Remove all relationships
	+ {:ok, followers } = User.get_followers(user)
	+ followers
	+ \|> Enum.each(fn (follower) -> User.unfollow(follower, user) end)
	+
	+ {:ok, friends} = User.get_friends(user)
	+ friends
	+ \|> Enum.each(fn (followed) -> User.unfollow(user, followed) end)
	+
	+ query = from a in Activity,
	+ where: a.actor == ^user.ap_id
	+
	+ Repo.all(query)
	+ \|> Enum.each(fn (activity) ->
	+ case activity.data["type"] do
	+ "Create" -> ActivityPub.delete(Object.get_by_ap_id(activity.data["object"]["id"]))
	+ _ -> "Doing nothing" # TODO: Do something with likes, follows, repeats.
	+ end
	+ end)
	+
	+ :ok
	+ end
	end
	diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
	index 51fac6fe2..ac20a2822 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,214 +1,219 @@
	defmodule Pleroma.Web.ActivityPub.Utils do
	alias Pleroma.{Repo, Web, Object, Activity, User}
	alias Pleroma.Web.Router.Helpers
	alias Pleroma.Web.Endpoint
	alias Ecto.{Changeset, UUID}
	import Ecto.Query

	def make_date do
	DateTime.utc_now() \|> DateTime.to_iso8601
	end

	def generate_activity_id do
	generate_id("activities")
	end

	def generate_context_id do
	generate_id("contexts")
	end

	def generate_object_id do
	Helpers.o_status_url(Endpoint, :object, UUID.generate)
	end

	def generate_id(type) do
	"#{Web.base_url()}/#{type}/#{UUID.generate}"
	end

	@doc """
	Enqueues an activity for federation if it's local
	"""
	def maybe_federate(%Activity{local: true} = activity) do
	- Pleroma.Web.Federator.enqueue(:publish, activity)
	+ priority = case activity.data["type"] do
	+ "Delete" -> 10
	+ "Create" -> 1
	+ _ -> 5
	+ end
	+ Pleroma.Web.Federator.enqueue(:publish, activity, priority)
	:ok
	end
	def maybe_federate(_), do: :ok

	@doc """
	Adds an id and a published data if they aren't there,
	also adds it to an included object
	"""
	def lazy_put_activity_defaults(map) do
	map = map
	\|> Map.put_new_lazy("id", &generate_activity_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)

	if is_map(map["object"]) do
	object = lazy_put_object_defaults(map["object"])
	%{map \| "object" => object}
	else
	map
	end
	end

	@doc """
	Adds an id and published date if they aren't there.
	"""
	def lazy_put_object_defaults(map) do
	map
	\|> Map.put_new_lazy("id", &generate_object_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	end

	@doc """
	Inserts a full object if it is contained in an activity.
	"""
	def insert_full_object(%{"object" => object_data}) when is_map(object_data) do
	with {:ok, _} <- Object.create(object_data) do
	:ok
	end
	end
	def insert_full_object(_), do: :ok

	def update_object_in_activities(%{data: %{"id" => id}} = object) do
	# TODO
	# Update activities that already had this. Could be done in a seperate process.
	# Alternatively, just don't do this and fetch the current object each time. Most
	# could probably be taken from cache.
	relevant_activities = Activity.all_by_object_ap_id(id)
	Enum.map(relevant_activities, fn (activity) ->
	new_activity_data = activity.data \|> Map.put("object", object.data)
	changeset = Changeset.change(activity, data: new_activity_data)
	Repo.update(changeset)
	end)
	end

	#### Like-related helpers

	@doc """
	Returns an existing like if a user already liked an object
	"""
	def get_existing_like(actor, %{data: %{"id" => id}}) do
	query = from activity in Activity,
	where: fragment("(?)->>'actor' = ?", activity.data, ^actor),
	# this is to use the index
	where: fragment("coalesce((?)->'object'->>'id', (?)->>'object') = ?", activity.data, activity.data, ^id),
	where: fragment("(?)->>'type' = 'Like'", activity.data)

	Repo.one(query)
	end

	def make_like_data(%User{ap_id: ap_id} = actor, %{data: %{"id" => id}} = object, activity_id) do
	data = %{
	"type" => "Like",
	"actor" => ap_id,
	"object" => id,
	"to" => [actor.follower_address, object.data["actor"]],
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def update_element_in_object(property, element, object) do
	with new_data <- object.data \|> Map.put("#{property}_count", length(element)) \|> Map.put("#{property}s", element),
	changeset <- Changeset.change(object, data: new_data),
	{:ok, object} <- Repo.update(changeset),
	_ <- update_object_in_activities(object) do
	{:ok, object}
	end
	end

	def update_likes_in_object(likes, object) do
	update_element_in_object("like", likes, object)
	end

	def add_like_to_object(%Activity{data: %{"actor" => actor}}, object) do
	with likes <- [actor \| (object.data["likes"] \|\| [])] \|> Enum.uniq do
	update_likes_in_object(likes, object)
	end
	end

	def remove_like_from_object(%Activity{data: %{"actor" => actor}}, object) do
	with likes <- (object.data["likes"] \|\| []) \|> List.delete(actor) do
	update_likes_in_object(likes, object)
	end
	end

	#### Follow-related helpers

	@doc """
	Makes a follow activity data for the given follower and followed
	"""
	def make_follow_data(%User{ap_id: follower_id}, %User{ap_id: followed_id}, activity_id) do
	data = %{
	"type" => "Follow",
	"actor" => follower_id,
	"to" => [followed_id],
	"object" => followed_id
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def fetch_latest_follow(%User{ap_id: follower_id},
	%User{ap_id: followed_id}) do
	query = from activity in Activity,
	where: fragment("? @> ?", activity.data, ^%{type: "Follow", actor: follower_id,
	object: followed_id}),
	order_by: [desc: :id],
	limit: 1
	Repo.one(query)
	end

	#### Announce-related helpers

	@doc """
	Make announce activity data for the given actor and object
	"""
	def make_announce_data(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object, activity_id) do
	data = %{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address, object.data["actor"]],
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def add_announce_to_object(%Activity{data: %{"actor" => actor}}, object) do
	with announcements <- [actor \| (object.data["announcements"] \|\| [])] \|> Enum.uniq do
	update_element_in_object("announcement", announcements, object)
	end
	end

	#### Unfollow-related helpers

	def make_unfollow_data(follower, followed, follow_activity) do
	%{
	"type" => "Undo",
	"actor" => follower.ap_id,
	"to" => [followed.ap_id],
	"object" => follow_activity.data["id"]
	}
	end


	#### Create-related helpers

	def make_create_data(params, additional) do
	published = params.published \|\| make_date()

	%{
	"type" => "Create",
	"to" => params.to \|> Enum.uniq,
	"actor" => params.actor.ap_id,
	"object" => params.object,
	"published" => published,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end
	end
	diff --git a/lib/pleroma/web/federator/federator.ex b/lib/pleroma/web/federator/federator.ex
	index 9f6f983aa..b23ed5fcc 100644
	--- a/lib/pleroma/web/federator/federator.ex
	+++ b/lib/pleroma/web/federator/federator.ex
	@@ -1,129 +1,138 @@
	defmodule Pleroma.Web.Federator do
	use GenServer
	alias Pleroma.User
	alias Pleroma.Web.{WebFinger, Websub}
	require Logger

	@websub Application.get_env(:pleroma, :websub)
	@ostatus Application.get_env(:pleroma, :ostatus)
	@httpoison Application.get_env(:pleroma, :httpoison)
	@max_jobs 10

	def start_link do
	spawn(fn ->
	Process.sleep(1000 * 60 * 1) # 1 minute
	enqueue(:refresh_subscriptions, nil)
	end)
	GenServer.start_link(__MODULE__, %{
	- in: {:sets.new(), :queue.new()},
	- out: {:sets.new(), :queue.new()}
	+ in: {:sets.new(), []},
	+ out: {:sets.new(), []}
	}, name: __MODULE__)
	end

	def handle(:refresh_subscriptions, _) do
	Logger.debug("Federator running refresh subscriptions")
	Websub.refresh_subscriptions()
	spawn(fn ->
	Process.sleep(1000 * 60 * 60 * 6) # 6 hours
	enqueue(:refresh_subscriptions, nil)
	end)
	end

	def handle(:request_subscription, websub) do
	Logger.debug("Refreshing #{websub.topic}")
	with {:ok, websub } <- Websub.request_subscription(websub) do
	Logger.debug("Successfully refreshed #{websub.topic}")
	else
	_e -> Logger.debug("Couldn't refresh #{websub.topic}")
	end
	end

	def handle(:publish, activity) do
	Logger.debug(fn -> "Running publish for #{activity.data["id"]}" end)
	with actor when not is_nil(actor) <- User.get_cached_by_ap_id(activity.data["actor"]) do
	Logger.debug(fn -> "Sending #{activity.data["id"]} out via websub" end)
	Websub.publish(Pleroma.Web.OStatus.feed_path(actor), actor, activity)

	{:ok, actor} = WebFinger.ensure_keys_present(actor)
	Logger.debug(fn -> "Sending #{activity.data["id"]} out via salmon" end)
	Pleroma.Web.Salmon.publish(actor, activity)
	end
	end

	def handle(:verify_websub, websub) do
	Logger.debug(fn -> "Running websub verification for #{websub.id} (#{websub.topic}, #{websub.callback})" end)
	@websub.verify(websub)
	end

	def handle(:incoming_doc, doc) do
	Logger.debug("Got document, trying to parse")
	@ostatus.handle_incoming(doc)
	end

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

	with {:ok, %{status_code: code}} <- @httpoison.post(callback, xml, [
	{"Content-Type", "application/atom+xml"},
	{"X-Hub-Signature", "sha1=#{signature}"}
	], timeout: 10000, recv_timeout: 20000) do
	Logger.debug(fn -> "Pushed to #{callback}, code #{code}" end)
	else e ->
	Logger.debug(fn -> "Couldn't push to #{callback}, #{inspect(e)}" end)
	end
	end

	def handle(type, _) do
	Logger.debug(fn -> "Unknown task: #{type}" end)
	{:error, "Don't know what do do with this"}
	end

	- def enqueue(type, payload) do
	+ def enqueue(type, payload, priority \\ 1) do
	if Mix.env == :test do
	handle(type, payload)
	else
	- GenServer.cast(__MODULE__, {:enqueue, type, payload})
	+ GenServer.cast(__MODULE__, {:enqueue, type, payload, priority})
	end
	end

	def maybe_start_job(running_jobs, queue) do
	- if (:sets.size(running_jobs) < @max_jobs) && !:queue.is_empty(queue) do
	- {{:value, {type, payload}}, queue} = :queue.out(queue)
	+ if (:sets.size(running_jobs) < @max_jobs) && queue != [] do
	+ {{type, payload}, queue} = queue_pop(queue)
	{:ok, pid} = Task.start(fn -> handle(type, payload) end)
	mref = Process.monitor(pid)
	{:sets.add_element(mref, running_jobs), queue}
	else
	{running_jobs, queue}
	end
	end

	- def handle_cast({:enqueue, type, payload}, state) when type in [:incoming_doc] do
	+ def handle_cast({:enqueue, type, payload, priority}, state) when type in [:incoming_doc] do
	%{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}} = state
	- i_queue = :queue.in({type, payload}, i_queue)
	+ i_queue = enqueue_sorted(i_queue, {type, payload}, 1)
	{i_running_jobs, i_queue} = maybe_start_job(i_running_jobs, i_queue)
	{:noreply, %{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}}}
	end

	- def handle_cast({:enqueue, type, payload}, state) do
	+ def handle_cast({:enqueue, type, payload, priority}, state) do
	%{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}} = state
	- o_queue = :queue.in({type, payload}, o_queue)
	+ o_queue = enqueue_sorted(o_queue, {type, payload}, 1)
	{o_running_jobs, o_queue} = maybe_start_job(o_running_jobs, o_queue)
	{:noreply, %{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}}}
	end

	def handle_cast(m, state) do
	IO.inspect("Unknown: #{inspect(m)}, #{inspect(state)}")
	{:noreply, state}
	end

	def handle_info({:DOWN, ref, :process, _pid, _reason}, state) do
	%{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}} = state
	i_running_jobs = :sets.del_element(ref, i_running_jobs)
	o_running_jobs = :sets.del_element(ref, o_running_jobs)
	{i_running_jobs, i_queue} = maybe_start_job(i_running_jobs, i_queue)
	{o_running_jobs, o_queue} = maybe_start_job(o_running_jobs, o_queue)

	{:noreply, %{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}}}
	end
	+
	+ def enqueue_sorted(queue, element, priority) do
	+ [%{item: element, priority: priority} \| queue]
	+ \|> Enum.sort_by(fn (%{priority: priority}) -> priority end)
	+ end
	+
	+ def queue_pop([%{item: element} \| queue]) do
	+ {element, queue}
	+ end
	end
	diff --git a/test/plugs/authentication_plug_test.exs b/test/plugs/authentication_plug_test.exs
	index 9d6c2cd70..5480dab43 100644
	--- a/test/plugs/authentication_plug_test.exs
	+++ b/test/plugs/authentication_plug_test.exs
	@@ -1,166 +1,193 @@
	defmodule Pleroma.Plugs.AuthenticationPlugTest do
	use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Plugs.AuthenticationPlug
	alias Pleroma.User

	defp fetch_nil(_name) do
	{:ok, nil}
	end

	@user %User{
	id: 1,
	name: "dude",
	password_hash: Comeonin.Pbkdf2.hashpwsalt("guy")
	}

	+ @deactivated %User{
	+ id: 1,
	+ name: "dude",
	+ password_hash: Comeonin.Pbkdf2.hashpwsalt("guy"),
	+ info: %{"deactivated" => true}
	+ }
	+
	@session_opts [
	store: :cookie,
	key: "_test",
	signing_salt: "cooldude"
	]

	defp fetch_user(_name) do
	{:ok, @user}
	end

	defp basic_auth_enc(username, password) do
	"Basic " <> Base.encode64("#{username}:#{password}")
	end

	describe "without an authorization header" do
	test "it halts the application" do
	conn = build_conn()
	\|> Plug.Session.call(Plug.Session.init(@session_opts))
	\|> fetch_session
	\|> AuthenticationPlug.call(%{})

	assert conn.status == 403
	assert conn.halted == true
	end

	test "it assigns a nil user if the 'optional' option is used" do
	conn = build_conn()
	\|> Plug.Session.call(Plug.Session.init(@session_opts))
	\|> fetch_session
	\|> AuthenticationPlug.call(%{optional: true})

	assert %{ user: nil } == conn.assigns
	end
	end

	describe "with an authorization header for a nonexisting user" do
	test "it halts the application" do
	conn =
	build_conn()
	\|> Plug.Session.call(Plug.Session.init(@session_opts))
	\|> fetch_session
	\|> AuthenticationPlug.call(%{fetcher: &fetch_nil/1})

	assert conn.status == 403
	assert conn.halted == true
	end

	test "it assigns a nil user if the 'optional' option is used" do
	conn =
	build_conn()
	\|> Plug.Session.call(Plug.Session.init(@session_opts))
	\|> fetch_session
	\|> AuthenticationPlug.call(%{optional: true, fetcher: &fetch_nil/1 })

	assert %{ user: nil } == conn.assigns
	end
	end

	describe "with an incorrect authorization header for a enxisting user" do
	test "it halts the application" do
	opts = %{
	fetcher: &fetch_user/1
	}

	header = basic_auth_enc("dude", "man")

	conn =
	build_conn()
	\|> Plug.Session.call(Plug.Session.init(@session_opts))
	\|> fetch_session
	\|> put_req_header("authorization", header)
	\|> AuthenticationPlug.call(opts)

	assert conn.status == 403
	assert conn.halted == true
	end

	test "it assigns a nil user if the 'optional' option is used" do
	opts = %{
	optional: true,
	fetcher: &fetch_user/1
	}

	header = basic_auth_enc("dude", "man")

	conn =
	build_conn()
	\|> Plug.Session.call(Plug.Session.init(@session_opts))
	\|> fetch_session
	\|> put_req_header("authorization", header)
	\|> AuthenticationPlug.call(opts)

	assert %{ user: nil } == conn.assigns
	end
	end

	describe "with a correct authorization header for an existing user" do
	test "it assigns the user", %{conn: conn} do
	opts = %{
	optional: true,
	fetcher: &fetch_user/1
	}

	header = basic_auth_enc("dude", "guy")

	conn = conn
	\|> Plug.Session.call(Plug.Session.init(@session_opts))
	\|> fetch_session
	\|> put_req_header("authorization", header)
	\|> AuthenticationPlug.call(opts)

	assert %{ user: @user } == conn.assigns
	assert get_session(conn, :user_id) == @user.id
	assert conn.halted == false
	end
	end

	+ describe "with a correct authorization header for an deactiviated user" do
	+ test "it halts the appication", %{conn: conn} do
	+ opts = %{
	+ optional: false,
	+ fetcher: fn _ -> @deactivated end
	+ }
	+
	+ header = basic_auth_enc("dude", "guy")
	+
	+ conn = conn
	+ \|> Plug.Session.call(Plug.Session.init(@session_opts))
	+ \|> fetch_session
	+ \|> put_req_header("authorization", header)
	+ \|> AuthenticationPlug.call(opts)
	+
	+ assert conn.status == 403
	+ assert conn.halted == true
	+ end
	+ end
	+
	describe "with a user_id in the session for an existing user" do
	test "it assigns the user", %{conn: conn} do
	opts = %{
	optional: true,
	fetcher: &fetch_user/1
	}

	header = basic_auth_enc("dude", "THIS IS WRONG")

	conn = conn
	\|> Plug.Session.call(Plug.Session.init(@session_opts))
	\|> fetch_session
	\|> put_session(:user_id, @user.id)
	\|> put_req_header("authorization", header)
	\|> AuthenticationPlug.call(opts)

	assert %{ user: @user } == conn.assigns
	assert get_session(conn, :user_id) == @user.id
	assert conn.halted == false
	end
	end

	describe "with an assigned user" do
	test "it does nothing, returning the incoming conn", %{conn: conn} do
	conn = conn
	\|> assign(:user, @user)

	conn_result = AuthenticationPlug.call(conn, %{})

	assert conn == conn_result
	end
	end
	end
	diff --git a/test/user_test.exs b/test/user_test.exs
	index 31c5962e2..16d43e619 100644
	--- a/test/user_test.exs
	+++ b/test/user_test.exs
	@@ -1,329 +1,373 @@
	defmodule Pleroma.UserTest do
	alias Pleroma.Builders.UserBuilder
	- alias Pleroma.{User, Repo}
	+ alias Pleroma.{User, Repo, Activity}
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.Websub.WebsubClientSubscription
	alias Pleroma.Web.CommonAPI
	use Pleroma.DataCase

	import Pleroma.Factory
	import Ecto.Query

	test "ap_id returns the activity pub id for the user" do
	user = UserBuilder.build

	expected_ap_id = "#{Pleroma.Web.base_url}/users/#{user.nickname}"

	assert expected_ap_id == User.ap_id(user)
	end

	test "ap_followers returns the followers collection for the user" do
	user = UserBuilder.build

	expected_followers_collection = "#{User.ap_id(user)}/followers"

	assert expected_followers_collection == User.ap_followers(user)
	end

	test "follow takes a user and another user" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user} = User.follow(user, followed)

	user = Repo.get(User, user.id)

	followed = User.get_by_ap_id(followed.ap_id)
	assert followed.info["follower_count"] == 1

	assert User.ap_followers(followed) in user.following
	end

	+ test "can't follow a deactivated users" do
	+ user = insert(:user)
	+ followed = insert(:user, info: %{"deactivated" => true})
	+
	+ {:error, _} = User.follow(user, followed)
	+ end
	+
	test "following a remote user will ensure a websub subscription is present" do
	user = insert(:user)
	{:ok, followed} = OStatus.make_user("shp@social.heldscal.la")

	assert followed.local == false

	{:ok, user} = User.follow(user, followed)
	assert User.ap_followers(followed) in user.following

	query = from w in WebsubClientSubscription,
	where: w.topic == ^followed.info["topic"]
	websub = Repo.one(query)

	assert websub
	end

	test "unfollow takes a user and another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	{:ok, user, _activity } = User.unfollow(user, followed)

	user = Repo.get(User, user.id)

	assert user.following == []
	end

	test "unfollow doesn't unfollow yourself" do
	user = insert(:user)

	{:error, _} = User.unfollow(user, user)

	user = Repo.get(User, user.id)
	assert user.following == [user.ap_id]
	end


	test "test if a user is following another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	assert User.following?(user, followed)
	refute User.following?(followed, user)
	end

	describe "user registration" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	test "it requires a bio, email, name, nickname and password" do
	@full_user_data
	\|> Map.keys
	\|> Enum.each(fn (key) ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)
	assert changeset.valid? == false
	end)
	end

	test "it sets the password_hash, ap_id and following fields" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	assert is_binary(changeset.changes[:password_hash])
	assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})
	assert changeset.changes[:following] == [User.ap_followers(%User{nickname: @full_user_data.nickname})]
	assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
	end
	end

	describe "fetching a user from nickname or trying to build one" do
	test "gets an existing user" do
	user = insert(:user)
	fetched_user = User.get_or_fetch_by_nickname(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user, case insensitive" do
	user = insert(:user, nickname: "nick")
	fetched_user = User.get_or_fetch_by_nickname("NICK")

	assert user == fetched_user
	end

	test "fetches an external user via ostatus if no user exists" do
	fetched_user = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
	assert fetched_user.nickname == "shp@social.heldscal.la"
	end

	test "returns nil if no user could be fetched" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
	assert fetched_user == nil
	end

	test "returns nil for nonexistant local user" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant")
	assert fetched_user == nil
	end
	end

	test "returns an ap_id for a user" do
	user = insert(:user)
	assert User.ap_id(user) == Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :feed_redirect, user.nickname)
	end

	test "returns an ap_followers link for a user" do
	user = insert(:user)
	assert User.ap_followers(user) == Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :feed_redirect, user.nickname) <> "/followers"
	end

	describe "remote user creation changeset" do
	@valid_remote %{
	bio: "hello",
	name: "Someone",
	nickname: "a@b.de",
	ap_id: "http...",
	info: %{some: "info"},
	avatar: %{some: "avatar"}
	}

	test "it confirms validity" do
	cs = User.remote_user_creation(@valid_remote)
	assert cs.valid?
	end

	test "it sets the follower_adress" do
	cs = User.remote_user_creation(@valid_remote)
	# remote users get a fake local follower address
	assert cs.changes.follower_address == User.ap_followers(%User{ nickname: @valid_remote[:nickname] })
	end

	test "it enforces the fqn format for nicknames" do
	cs = User.remote_user_creation(%{@valid_remote \| nickname: "bla"})
	assert cs.changes.local == false
	assert cs.changes.avatar
	refute cs.valid?
	end

	test "it has required fields" do
	[:name, :nickname, :ap_id]
	\|> Enum.each(fn (field) ->
	cs = User.remote_user_creation(Map.delete(@valid_remote, field))
	refute cs.valid?
	end)
	end

	test "it restricts some sizes" do
	[bio: 5000, name: 100]
	\|> Enum.each(fn ({field, size}) ->
	string = String.pad_leading(".", size)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	assert cs.valid?

	string = String.pad_leading(".", size + 1)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	refute cs.valid?
	end)
	end
	end

	describe "followers and friends" do
	test "gets all followers for a given user" do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

	{:ok, follower_one} = User.follow(follower_one, user)
	{:ok, follower_two} = User.follow(follower_two, user)

	{:ok, res} = User.get_followers(user)

	assert Enum.member?(res, follower_one)
	assert Enum.member?(res, follower_two)
	refute Enum.member?(res, not_follower)
	end

	test "gets all friends (followed users) for a given user" do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	not_followed = insert(:user)

	{:ok, user} = User.follow(user, followed_one)
	{:ok, user} = User.follow(user, followed_two)

	{:ok, res} = User.get_friends(user)

	followed_one = User.get_by_ap_id(followed_one.ap_id)
	followed_two = User.get_by_ap_id(followed_two.ap_id)
	assert Enum.member?(res, followed_one)
	assert Enum.member?(res, followed_two)
	refute Enum.member?(res, not_followed)
	end
	end

	describe "updating note and follower count" do
	test "it sets the info->note_count property" do
	note = insert(:note)

	user = User.get_by_ap_id(note.data["actor"])

	assert user.info["note_count"] == nil

	{:ok, user} = User.update_note_count(user)

	assert user.info["note_count"] == 1
	end

	test "it increases the info->note_count property" do
	note = insert(:note)
	user = User.get_by_ap_id(note.data["actor"])

	assert user.info["note_count"] == nil

	{:ok, user} = User.increase_note_count(user)

	assert user.info["note_count"] == 1

	{:ok, user} = User.increase_note_count(user)

	assert user.info["note_count"] == 2
	end

	test "it sets the info->follower_count property" do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	assert user.info["follower_count"] == nil

	{:ok, user} = User.update_follower_count(user)

	assert user.info["follower_count"] == 1
	end
	end

	describe "blocks" do
	test "it blocks people" do
	user = insert(:user)
	blocked_user = insert(:user)

	refute User.blocks?(user, blocked_user)

	{:ok, user} = User.block(user, blocked_user)

	assert User.blocks?(user, blocked_user)
	end

	test "it unblocks users" do
	user = insert(:user)
	blocked_user = insert(:user)

	{:ok, user} = User.block(user, blocked_user)
	{:ok, user} = User.unblock(user, blocked_user)

	refute User.blocks?(user, blocked_user)
	end
	end

	test "get recipients from activity" do
	actor = insert(:user)
	user = insert(:user, local: true)
	user_two = insert(:user, local: false)
	addressed = insert(:user, local: true)
	addressed_remote = insert(:user, local: false)
	{:ok, activity} = CommonAPI.post(actor, %{"status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"})

	assert [addressed] == User.get_recipients_from_activity(activity)

	{:ok, user} = User.follow(user, actor)
	{:ok, user_two} = User.follow(user_two, actor)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 2
	assert user in recipients
	assert addressed in recipients
	end
	-end

	+ test ".deactivate deactivates a user" do
	+ user = insert(:user)
	+ assert false == !!user.info["deactivated"]
	+ {:ok, user} = User.deactivate(user)
	+ assert true == user.info["deactivated"]
	+ end
	+
	+ test ".delete deactivates a user, all follow relationships and all create activities" do
	+ user = insert(:user)
	+ followed = insert(:user)
	+ follower = insert(:user)
	+
	+ {:ok, user} = User.follow(user, followed)
	+ {:ok, follower} = User.follow(follower, user)
	+
	+ {:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
	+ {:ok, activity_two} = CommonAPI.post(follower, %{"status" => "3hu"})
	+
	+ {:ok, _, _} = CommonAPI.favorite(activity_two.id, user)
	+ {:ok, _, _} = CommonAPI.favorite(activity.id, follower)
	+ {:ok, _, _} = CommonAPI.repeat(activity.id, follower)
	+
	+ :ok = User.delete(user)
	+
	+ followed = Repo.get(User, followed.id)
	+ follower = Repo.get(User, follower.id)
	+ user = Repo.get(User, user.id)
	+
	+ assert user.info["deactivated"]
	+
	+ refute User.following?(user, followed)
	+ refute User.following?(followed, follower)
	+
	+ # TODO: Remove favorites, repeats, delete activities.
	+
	+ refute Repo.get(Activity, activity.id)
	+ end
	+end
	diff --git a/test/web/federator_test.exs b/test/web/federator_test.exs
	new file mode 100644
	index 000000000..09533362a
	--- /dev/null
	+++ b/test/web/federator_test.exs
	@@ -0,0 +1,20 @@
	+defmodule Pleroma.Web.FederatorTest do
	+ alias Pleroma.Web.Federator
	+ use Pleroma.DataCase
	+
	+ test "enqueues an element according to priority" do
	+ queue = [%{item: 1, priority: 2}]
	+
	+ new_queue = Federator.enqueue_sorted(queue, 2, 1)
	+ assert new_queue == [%{item: 2, priority: 1}, %{item: 1, priority: 2}]
	+
	+ new_queue = Federator.enqueue_sorted(queue, 2, 3)
	+ assert new_queue == [%{item: 1, priority: 2}, %{item: 2, priority: 3}]
	+ end
	+
	+ test "pop first item" do
	+ queue = [%{item: 2, priority: 1}, %{item: 1, priority: 2}]
	+
	+ assert {2, [%{item: 1, priority: 2}]} = Federator.queue_pop(queue)
	+ end
	+end

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 14, 7:40 AM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 166791
Default Alt Text: (46 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions