Page Menu
Home
Phorge
Search
Configure Global Search
Log In
Files
F85949259
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Flag For Later
Award Token
Authored By
Unknown
Size
28 KB
Referenced Files
None
Subscribers
None
View Options
diff --git a/changelog.d/home-timeline-bounded.change b/changelog.d/home-timeline-bounded.change
new file mode 100644
index 000000000..67a4ff554
--- /dev/null
+++ b/changelog.d/home-timeline-bounded.change
@@ -0,0 +1 @@
+Speed up home timelines with large recipient sets using a bounded, time-limited query and an exact fallback; preserve pagination, visibility filters and empty polling responses.
diff --git a/changelog.d/home-timeline-exact-gin.fix b/changelog.d/home-timeline-exact-gin.fix
new file mode 100644
index 000000000..0aefa5dd0
--- /dev/null
+++ b/changelog.d/home-timeline-exact-gin.fix
@@ -0,0 +1 @@
+Keep home timeline queries exact even when a fuzzy GIN search limit is configured, without changing the limit used by search.
diff --git a/lib/pleroma/pagination.ex b/lib/pleroma/pagination.ex
index 3fc249f56..81f3fe1ad 100644
--- a/lib/pleroma/pagination.ex
+++ b/lib/pleroma/pagination.ex
@@ -68,7 +68,7 @@ defmodule Pleroma.Pagination do
Enum.slice(list, offset, limit)
end
- @spec paginate(Ecto.Query.t(), map(), type(), atom() | nil) :: [Ecto.Schema.t()]
+ @spec paginate(Ecto.Query.t(), map(), type(), atom() | nil) :: Ecto.Query.t()
def paginate(query, options, method \\ :keyset, table_binding \\ nil)
def paginate(query, options, :keyset, table_binding) do
@@ -87,7 +87,11 @@ defmodule Pleroma.Pagination do
|> restrict(:limit, options, table_binding)
end
- defp cast_params(params) do
+ @doc false
+ def page_size(options), do: min(Map.get(options, :limit, @default_limit), @max_limit)
+
+ @doc false
+ def cast_params(params) do
param_types = %{
min_id: params[:id_type] || :string,
since_id: params[:id_type] || :string,
@@ -153,14 +157,7 @@ defmodule Pleroma.Pagination do
end
defp restrict(query, :limit, options, _table_binding) do
- limit =
- case Map.get(options, :limit, @default_limit) do
- limit when limit < @max_limit -> limit
- _ -> @max_limit
- end
-
- query
- |> limit(^limit)
+ limit(query, ^page_size(options))
end
defp restrict(query, _, _, _), do: query
diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
index 807e68ffb..231a9bfcf 100644
--- a/lib/pleroma/web/activity_pub/activity_pub.ex
+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
@@ -21,6 +21,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
alias Pleroma.Repo
alias Pleroma.Upload
alias Pleroma.User
+ alias Pleroma.Web.ActivityPub.HomeTimeline
alias Pleroma.Web.ActivityPub.MRF
alias Pleroma.Web.ActivityPub.ObjectValidators.UserValidator
alias Pleroma.Web.ActivityPub.Transmogrifier
@@ -555,6 +556,19 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
defp pagination_binding(%{favorited_by: _}), do: :favorited_activity
defp pagination_binding(_), do: nil
+ def fetch_home_activities(recipients, opts) do
+ HomeTimeline.with_exact_queries(fn ->
+ list_memberships = Pleroma.List.memberships(opts[:user])
+ recipients = Enum.uniq(recipients ++ list_memberships)
+
+ HomeTimeline.fetch(recipients, opts, fn source, matching ->
+ fetch_activities_query(recipients, opts, source, matching)
+ end)
+ |> Enum.reverse()
+ |> maybe_update_cc(list_memberships, opts[:user])
+ end)
+ end
+
def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
list_memberships = Pleroma.List.memberships(opts[:user])
@@ -970,19 +984,35 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
)
end
+ defp restrict_recipients(query, recipients, user, :overlap) do
+ restrict_recipients(query, recipients, user)
+ end
+
+ defp restrict_recipients(query, recipients, user, :exists) do
+ from(activity in query,
+ where:
+ fragment(
+ "EXISTS (SELECT 1 FROM unnest(?) AS recipient WHERE recipient = ANY(?))",
+ activity.recipients,
+ type(^recipients, {:array, :string})
+ ),
+ or_where: activity.actor == ^user.ap_id
+ )
+ end
+
# Essentially, either look for activities addressed to `recipients`, _OR_ ones
# that reference a hashtag that the user follows
# Firstly, two fallbacks in case there's no hashtag constraint, or the user doesn't
# follow any
- defp restrict_recipients_or_hashtags(query, recipients, user, nil) do
- restrict_recipients(query, recipients, user)
+ defp restrict_recipients_or_hashtags(query, recipients, user, nil, matching) do
+ restrict_recipients(query, recipients, user, matching)
end
- defp restrict_recipients_or_hashtags(query, recipients, user, []) do
- restrict_recipients(query, recipients, user)
+ defp restrict_recipients_or_hashtags(query, recipients, user, [], matching) do
+ restrict_recipients(query, recipients, user, matching)
end
- defp restrict_recipients_or_hashtags(query, recipients, _user, hashtag_ids) do
+ defp restrict_recipients_or_hashtags(query, recipients, _user, hashtag_ids, _matching) do
from([activity, object] in query)
|> join(:left, [activity, object], hto in "hashtags_objects",
on: hto.object_id == object.id,
@@ -1555,6 +1585,10 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
end
def fetch_activities_query(recipients, opts \\ %{}) do
+ fetch_activities_query(recipients, opts, Activity, :overlap)
+ end
+
+ defp fetch_activities_query(recipients, opts, source, matching) do
opts = normalize_fetch_activities_query_opts(opts)
{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
@@ -1565,14 +1599,19 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
}
query =
- Activity
+ source
|> maybe_preload_objects(opts)
|> maybe_preload_bookmarks(opts)
|> maybe_preload_report_notes(opts)
|> maybe_set_thread_muted_field(opts)
|> maybe_order(opts)
|> maybe_restrict_unauthenticated(opts)
- |> restrict_recipients_or_hashtags(recipients, opts[:user], opts[:followed_hashtags])
+ |> restrict_recipients_or_hashtags(
+ recipients,
+ opts[:user],
+ opts[:followed_hashtags],
+ matching
+ )
|> restrict_replies(opts)
|> restrict_since(opts)
|> restrict_local(opts)
diff --git a/lib/pleroma/web/activity_pub/home_timeline.ex b/lib/pleroma/web/activity_pub/home_timeline.ex
new file mode 100644
index 000000000..1f9fbba79
--- /dev/null
+++ b/lib/pleroma/web/activity_pub/home_timeline.ex
@@ -0,0 +1,163 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2026 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.ActivityPub.HomeTimeline do
+ @moduledoc false
+
+ import Ecto.Query
+
+ alias Pleroma.Activity
+ alias Pleroma.Pagination
+ alias Pleroma.Repo
+
+ @minimum_recipients 128
+ @candidate_limit 8192
+ @budget_ms 250
+
+ # Home selection must be exact, but search still benefits from the configured
+ # fuzzy GIN limit. A savepoint also restores settings inside caller transactions
+ # (including SQL Sandbox), where SET LOCAL alone would leak into later queries.
+ # Only read-only selection belongs here, never rendering or job insertion.
+ def with_exact_queries(fun) do
+ if Repo.in_transaction?() do
+ exact_queries(fun)
+ else
+ {:ok, result} = Repo.transaction(fn -> exact_queries(fun) end)
+ result
+ end
+ end
+
+ defp exact_queries(fun) do
+ read_only_savepoint("home_timeline", fn ->
+ Repo.query!("SET LOCAL gin_fuzzy_search_limit = 0")
+ fun.()
+ end)
+ end
+
+ def fetch(recipients, opts, build_query) do
+ opts = Map.put(opts, :skip_extra_order, true)
+
+ result =
+ if length(recipients) >= @minimum_recipients and opts[:followed_hashtags] in [nil, []] do
+ attempt(opts, build_query)
+ else
+ :fallback
+ end
+
+ case result do
+ {:ok, activities} ->
+ activities
+
+ :fallback ->
+ build_query.(Activity, :overlap) |> Pagination.fetch_paginated(opts, :keyset, nil)
+ end
+ end
+
+ defp attempt(opts, build_query) do
+ read_only_savepoint("home_timeline_fast", fn ->
+ deadline = System.monotonic_time(:millisecond) + @budget_ms
+ set_timeout(@budget_ms)
+ options = Pagination.cast_params(opts)
+ rows = select_candidates(options, opts, build_query)
+ ids = for {id, _count} <- rows, not is_nil(id), do: id
+ {_id, count} = hd(rows)
+
+ cond do
+ length(ids) < Pagination.page_size(options) and count > @candidate_limit ->
+ :fallback
+
+ ids == [] ->
+ {:ok, []}
+
+ true ->
+ hydrate(ids, opts, build_query, deadline)
+ end
+ end)
+ rescue
+ error in Postgrex.Error ->
+ if error.postgres[:code] == :query_canceled do
+ :fallback
+ else
+ reraise error, __STACKTRACE__
+ end
+ end
+
+ defp select_candidates(options, opts, build_query) do
+ # The extra ID proves whether the requested range was exhausted. Metadata and
+ # filtered IDs are selected in ONE snapshot, including when no posts match.
+ range =
+ Activity
+ |> candidate_order(opts)
+ |> Pagination.paginate(options)
+
+ candidates =
+ range
+ |> limit(^(@candidate_limit + 1))
+ |> select([a], %{id: a.id})
+
+ # Both bounded scans share the same range, order and statement snapshot.
+ # Keep the activity scan ordered and limited BEFORE every filter; joining
+ # candidate IDs back to activities can lose that order and force a full sort.
+ source = range |> limit(^@candidate_limit) |> subquery()
+
+ page =
+ build_query.(source, :exists)
+ |> exclude(:preload)
+ |> exclude(:select)
+ |> select([a], %{id: a.id})
+ |> Pagination.paginate(options)
+
+ metadata = from(c in "home_timeline_candidates", select: %{count: count(c.id)})
+
+ from(m in subquery(metadata),
+ left_join: a in subquery(page),
+ on: true,
+ select: {a.id, m.count}
+ )
+ |> with_cte("home_timeline_candidates", as: ^candidates, materialized: true)
+ |> Repo.all()
+ end
+
+ defp candidate_order(query, %{order: direction}) when direction in [:asc, :desc] do
+ order_by(query, [a], [{^direction, a.id}])
+ end
+
+ defp candidate_order(query, _), do: query
+
+ defp hydrate(ids, opts, build_query, deadline) do
+ remaining = deadline - System.monotonic_time(:millisecond)
+
+ if remaining > 0 do
+ set_timeout(remaining)
+
+ # Reload at most one page through the same filters and typed preloads. A
+ # concurrent delete/visibility change may remove a post, never add one.
+ activities =
+ build_query.(Activity, :exists)
+ |> where([a], a.id in ^ids)
+ |> Pagination.fetch_paginated(opts, :keyset, nil)
+
+ {:ok, activities}
+ else
+ :fallback
+ end
+ end
+
+ defp set_timeout(milliseconds) do
+ Repo.query!("SELECT set_config('statement_timeout', $1, true)", ["#{milliseconds}ms"])
+ end
+
+ defp read_only_savepoint(name, fun) do
+ Repo.query!("SAVEPOINT #{name}")
+
+ try do
+ fun.()
+ after
+ # Roll back even on success to restore the caller's settings. This also
+ # recovers an aborted transaction after PostgreSQL cancels a slow attempt.
+ Repo.query!("ROLLBACK TO SAVEPOINT #{name}")
+ Repo.query!("RELEASE SAVEPOINT #{name}")
+ end
+ end
+end
diff --git a/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex b/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex
index 99a5b6957..49f5b8714 100644
--- a/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex
+++ b/lib/pleroma/web/mastodon_api/controllers/timeline_controller.ex
@@ -63,7 +63,7 @@ defmodule Pleroma.Web.MastodonAPI.TimelineController do
activities =
[user.ap_id | User.following(user) -- excluded_list_members]
- |> ActivityPub.fetch_activities(params)
+ |> ActivityPub.fetch_home_activities(params)
|> Enum.reverse()
conn
diff --git a/test/pleroma/web/activity_pub/home_timeline_test.exs b/test/pleroma/web/activity_pub/home_timeline_test.exs
new file mode 100644
index 000000000..7af863dee
--- /dev/null
+++ b/test/pleroma/web/activity_pub/home_timeline_test.exs
@@ -0,0 +1,448 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2026 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.ActivityPub.HomeTimelineTest do
+ use Pleroma.DataCase
+
+ import Mock
+ require Pleroma.Constants
+ import Pleroma.Factory
+
+ alias Pleroma.Pagination
+ alias Pleroma.Web.ActivityPub.ActivityPub
+
+ defp setting(name), do: Repo.query!("SELECT current_setting($1)", [name]).rows |> hd() |> hd()
+
+ describe "exact home timeline queries" do
+ test "uses exact GIN only for home selection and restores the caller's setting" do
+ user = insert(:user)
+ Repo.query!("SET LOCAL gin_fuzzy_search_limit = 321")
+
+ with_mock Pagination, [:passthrough],
+ fetch_paginated: fn _query, _opts, :keyset, nil ->
+ send(self(), {:gin_limit, setting("gin_fuzzy_search_limit")})
+ []
+ end do
+ assert ActivityPub.fetch_home_activities([user.ap_id], %{user: user}) == []
+ assert_received {:gin_limit, "0"}
+ assert setting("gin_fuzzy_search_limit") == "321"
+
+ assert ActivityPub.fetch_activities([user.ap_id], %{user: user}) == []
+ assert_received {:gin_limit, "321"}
+ end
+ end
+
+ test "restores settings inside an existing transaction" do
+ user = insert(:user)
+
+ assert {:ok, :ok} =
+ Repo.transaction(fn ->
+ Repo.query!("SET LOCAL gin_fuzzy_search_limit = 123")
+ ActivityPub.fetch_home_activities([user.ap_id], %{user: user})
+ assert setting("gin_fuzzy_search_limit") == "123"
+ :ok
+ end)
+ end
+
+ test "restores the caller's transaction after a database error" do
+ user = insert(:user)
+ Repo.query!("SET LOCAL gin_fuzzy_search_limit = 123")
+
+ with_mock Pagination, [:passthrough],
+ fetch_paginated: fn _query, _opts, :keyset, nil ->
+ Repo.query!("SELECT 1 / 0")
+ end do
+ assert_raise Postgrex.Error, fn ->
+ ActivityPub.fetch_home_activities([user.ap_id], %{user: user})
+ end
+ end
+
+ assert setting("gin_fuzzy_search_limit") == "123"
+ assert Repo.query!("SELECT 1").rows == [[1]]
+ end
+ end
+
+ describe "bounded fast selection" do
+ setup do
+ user = insert(:user)
+ recipients = [user.ap_id | Enum.map(1..127, &"https://example.org/followers/#{&1}")]
+ opts = %{user: user, type: ["Create", "Announce"], limit: 2}
+ %{user: user, recipients: recipients, opts: opts}
+ end
+
+ test "gates on unique recipients and excludes followed hashtags", ctx do
+ for {recipients, opts} <- [
+ {Enum.take(ctx.recipients, 127), ctx.opts},
+ {List.duplicate(ctx.user.ap_id, 128), ctx.opts},
+ {ctx.recipients, Map.put(ctx.opts, :followed_hashtags, [123])}
+ ] do
+ {[], queries} = queries(fn -> ActivityPub.fetch_home_activities(recipients, opts) end)
+ refute fast?(queries)
+ end
+
+ {[], queries} =
+ queries(fn -> ActivityPub.fetch_home_activities(ctx.recipients, ctx.opts) end)
+
+ assert fast?(queries)
+ refute fallback?(queries)
+ end
+
+ test "returns a full page with self posts, recipient posts, and preloaded objects", ctx do
+ own = insert(:note_activity, user: ctx.user)
+
+ addressed =
+ insert(:note_activity,
+ recipients: [ctx.user.ap_id],
+ data_attrs: %{"to" => [ctx.user.ap_id]}
+ )
+
+ insert(:note_activity)
+
+ {activities, queries} =
+ queries(fn -> ActivityPub.fetch_home_activities(ctx.recipients, ctx.opts) end)
+
+ assert Enum.map(activities, & &1.id) == [own.id, addressed.id]
+ assert Enum.all?(activities, &Ecto.assoc_loaded?(&1.object))
+ assert fast?(queries)
+ refute fallback?(queries)
+ end
+
+ test "returns exhausted partial and empty polling pages without fallback", ctx do
+ old = insert(:note_activity, user: ctx.user)
+ newest = insert(:note_activity, user: ctx.user)
+
+ for {since_id, expected} <- [{old.id, [newest.id]}, {newest.id, []}] do
+ {activities, queries} =
+ queries(fn ->
+ ActivityPub.fetch_home_activities(
+ ctx.recipients,
+ Map.put(ctx.opts, :since_id, since_id)
+ )
+ end)
+
+ assert Enum.map(activities, & &1.id) == expected
+ assert fast?(queries)
+ refute fallback?(queries)
+ end
+ end
+
+ test "falls back when sparse matches lie beyond the candidate window", ctx do
+ old = insert(:note_activity, user: ctx.user)
+ insert_gap(8192, ctx.user)
+ newest = insert(:note_activity, user: ctx.user)
+
+ {activities, queries} =
+ queries(fn -> ActivityPub.fetch_home_activities(ctx.recipients, ctx.opts) end)
+
+ assert Enum.map(activities, & &1.id) == [old.id, newest.id]
+ assert fast?(queries)
+ assert fallback?(queries)
+ end
+
+ test "distinguishes exactly 8192 candidates from a truncated empty window", ctx do
+ old = insert(:note_activity, user: ctx.user)
+ insert_gap(8191, ctx.user)
+
+ {activities, first_queries} =
+ queries(fn -> ActivityPub.fetch_home_activities(ctx.recipients, ctx.opts) end)
+
+ assert Enum.map(activities, & &1.id) == [old.id]
+ assert fast?(first_queries)
+ refute fallback?(first_queries)
+
+ insert_gap(1, ctx.user)
+
+ {activities, second_queries} =
+ queries(fn -> ActivityPub.fetch_home_activities(ctx.recipients, ctx.opts) end)
+
+ assert Enum.map(activities, & &1.id) == [old.id]
+ assert fast?(second_queries)
+ assert fallback?(second_queries)
+ end
+
+ test "applies min, max and since bounds before bounding candidates", ctx do
+ oldest = insert(:note_activity, user: ctx.user)
+ middle = insert(:note_activity, user: ctx.user)
+ newest = insert(:note_activity, user: ctx.user)
+ insert_gap(8193, ctx.user)
+
+ for bounds <- [
+ %{max_id: newest.id},
+ %{min_id: oldest.id, max_id: newest.id},
+ %{since_id: oldest.id, max_id: newest.id},
+ %{min_id: oldest.id, limit: "1"},
+ %{min_id: middle.id, order_asc: true, limit: 1}
+ ] do
+ opts = Map.merge(ctx.opts, bounds)
+ expected = ActivityPub.fetch_activities(ctx.recipients, opts) |> Enum.map(& &1.id)
+
+ {activities, queries} =
+ queries(fn -> ActivityPub.fetch_home_activities(ctx.recipients, opts) end)
+
+ assert Enum.map(activities, & &1.id) == expected
+ assert fast?(queries)
+ refute fallback?(queries)
+ end
+ end
+
+ test "preserves block, mute, media, locality and visibility filters", ctx do
+ author = insert(:user)
+ muted = insert(:user)
+ blocked = insert(:user)
+ Pleroma.User.mute(ctx.user, muted)
+ Pleroma.User.block(ctx.user, blocked)
+
+ for user <- [author, muted, blocked] do
+ insert(:note_activity,
+ user: user,
+ recipients: [ctx.user.ap_id],
+ data_attrs: %{"to" => [ctx.user.ap_id]}
+ )
+ end
+
+ insert(:note_activity, user: ctx.user, local: false)
+ insert(:note_activity, user: ctx.user)
+
+ media =
+ insert(:note_activity,
+ user: ctx.user,
+ note:
+ insert(:note,
+ user: ctx.user,
+ data: %{
+ "attachment" => [%{"type" => "Image", "url" => "https://example.org/image.png"}]
+ }
+ )
+ )
+
+ {:ok, _bookmark} = Pleroma.Bookmark.create(ctx.user.id, media.id)
+
+ for filters <- [
+ %{},
+ %{with_muted: true},
+ %{local_only: true},
+ %{remote: true},
+ %{only_media: true},
+ %{exclude_visibilities: ["public"]}
+ ] do
+ opts =
+ Map.merge(
+ ctx.opts,
+ Map.merge(%{blocking_user: ctx.user, muting_user: ctx.user, limit: 40}, filters)
+ )
+
+ expected = ActivityPub.fetch_activities(ctx.recipients, opts)
+
+ {activities, queries} =
+ queries(fn -> ActivityPub.fetch_home_activities(ctx.recipients, opts) end)
+
+ assert activities == expected
+ assert fast?(queries)
+ refute fallback?(queries)
+ end
+ end
+
+ test "preserves reply filtering and the virtual thread mute field", ctx do
+ parent = insert(:note_activity, user: ctx.user)
+
+ reply =
+ insert(:note_activity,
+ user: ctx.user,
+ note: insert(:note, user: ctx.user, data: %{"inReplyTo" => parent.data["object"]})
+ )
+
+ {:ok, _} = Pleroma.ThreadMute.add_mute(ctx.user.id, reply.data["context"])
+
+ opts =
+ Map.merge(ctx.opts, %{
+ with_muted: true,
+ muting_user: ctx.user,
+ reply_filtering_user: ctx.user
+ })
+
+ for filters <- [
+ %{},
+ %{reply_visibility: "self"},
+ %{reply_visibility: "following"},
+ %{exclude_replies: true}
+ ] do
+ opts = Map.merge(opts, filters)
+ expected = ActivityPub.fetch_activities(ctx.recipients, opts)
+
+ {activities, queries} =
+ queries(fn -> ActivityPub.fetch_home_activities(ctx.recipients, opts) end)
+
+ assert activities == expected
+ assert fast?(queries)
+ refute fallback?(queries)
+ end
+
+ activities = ActivityPub.fetch_home_activities(ctx.recipients, opts)
+ assert Enum.find(activities, &(&1.id == reply.id)).thread_muted?
+ end
+
+ test "includes list memberships in the gate and preserves list bcc postprocessing", ctx do
+ owner = insert(:user)
+ {:ok, list} = Pleroma.List.create(%{title: "members"}, owner)
+ {:ok, list} = Pleroma.List.follow(list, ctx.user)
+
+ activity =
+ insert(:note_activity,
+ user: owner,
+ recipients: [list.ap_id, Pleroma.Constants.as_public()],
+ data_attrs: %{"bcc" => [list.ap_id], "cc" => [], "to" => [ctx.user.ap_id]}
+ )
+
+ recipients = Enum.take(ctx.recipients, 127)
+
+ {activities, queries} =
+ queries(fn -> ActivityPub.fetch_home_activities(recipients, ctx.opts) end)
+
+ assert [result] = activities
+ assert result.id == activity.id
+ assert result.data["cc"] == [ctx.user.ap_id]
+ assert fast?(queries)
+ refute fallback?(queries)
+ end
+
+ test "uses the configured default and maximum page sizes", ctx do
+ for _ <- 1..41, do: insert(:note_activity, user: ctx.user)
+
+ for opts <- [Map.delete(ctx.opts, :limit), Map.put(ctx.opts, :limit, "100")] do
+ expected = ActivityPub.fetch_activities(ctx.recipients, opts)
+
+ {activities, queries} =
+ queries(fn -> ActivityPub.fetch_home_activities(ctx.recipients, opts) end)
+
+ assert activities == expected
+ assert fast?(queries)
+ refute fallback?(queries)
+ end
+ end
+
+ test "does not swallow non-cancellation errors in the fast query", ctx do
+ Repo.query!("SET LOCAL gin_fuzzy_search_limit = 123")
+ Repo.query!("SET LOCAL statement_timeout = '5s'")
+
+ with_mock Repo, [:passthrough],
+ all: fn query ->
+ {sql, _} = Ecto.Adapters.SQL.to_sql(:all, Repo, query)
+
+ if String.contains?(sql, "home_timeline_candidates"),
+ do: Repo.query!("SELECT 1 / 0"),
+ else: :meck.passthrough([query])
+ end do
+ error =
+ assert_raise Postgrex.Error, fn ->
+ ActivityPub.fetch_home_activities(ctx.recipients, ctx.opts)
+ end
+
+ assert error.postgres.code == :division_by_zero
+ end
+
+ assert setting("statement_timeout") == "5s"
+ assert setting("gin_fuzzy_search_limit") == "123"
+ end
+
+ test "also recovers when bounded hydration times out", ctx do
+ activity = insert(:note_activity, user: ctx.user)
+
+ with_mock Repo, [:passthrough],
+ all: fn query ->
+ {sql, _} = Ecto.Adapters.SQL.to_sql(:all, Repo, query)
+
+ if String.contains?(sql, "unnest(") and
+ not String.contains?(sql, "home_timeline_candidates") do
+ send(self(), :hydration_timeout)
+ Repo.query!("SELECT pg_sleep(1)")
+ else
+ :meck.passthrough([query])
+ end
+ end do
+ assert [result] = ActivityPub.fetch_home_activities(ctx.recipients, ctx.opts)
+ assert result.id == activity.id
+ assert_received :hydration_timeout
+ end
+ end
+
+ test "recovers from a real statement timeout and restores both settings", ctx do
+ activity = insert(:note_activity, user: ctx.user)
+ Repo.query!("SET LOCAL statement_timeout = '5s'")
+ Repo.query!("SET LOCAL gin_fuzzy_search_limit = 123")
+
+ with_mock Repo, [:passthrough],
+ all: fn query ->
+ {sql, _} = Ecto.Adapters.SQL.to_sql(:all, Repo, query)
+
+ if String.contains?(sql, "home_timeline_candidates") do
+ assert setting("gin_fuzzy_search_limit") == "0"
+ send(self(), :timed_fast_query)
+ Repo.query!("SELECT pg_sleep(1)")
+ else
+ result = :meck.passthrough([query])
+
+ if String.contains?(sql, " && ") do
+ assert setting("gin_fuzzy_search_limit") == "0"
+ assert setting("statement_timeout") == "5s"
+ end
+
+ result
+ end
+ end do
+ assert [result] = ActivityPub.fetch_home_activities(ctx.recipients, ctx.opts)
+ assert result.id == activity.id
+ assert_received :timed_fast_query
+ end
+
+ assert setting("statement_timeout") == "5s"
+ assert setting("gin_fuzzy_search_limit") == "123"
+ assert Repo.query!("SELECT 1").rows == [[1]]
+ end
+ end
+
+ defp insert_gap(count, user) do
+ now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
+
+ rows =
+ for _ <- 1..count,
+ do: %{
+ id: FlakeId.get(),
+ actor: user.ap_id,
+ recipients: [],
+ data: %{"type" => "Like"},
+ inserted_at: now,
+ updated_at: now
+ }
+
+ Repo.insert_all(Pleroma.Activity, rows)
+ end
+
+ defp queries(fun) do
+ id = {__MODULE__, make_ref()}
+ :ok = :telemetry.attach(id, [:pleroma, :repo, :query], &__MODULE__.record_query/4, self())
+
+ try do
+ result = fun.()
+ {result, drain_queries()}
+ after
+ :telemetry.detach(id)
+ end
+ end
+
+ def record_query(_event, _measurements, metadata, pid), do: send(pid, {:query, metadata.query})
+
+ defp drain_queries do
+ receive do
+ {:query, query} -> [query | drain_queries()]
+ after
+ 0 -> []
+ end
+ end
+
+ defp fast?(queries), do: Enum.any?(queries, &String.contains?(&1, "home_timeline_candidates"))
+
+ defp fallback?(queries),
+ do:
+ Enum.any?(queries, &(String.contains?(&1, " && ") and not String.contains?(&1, "unnest(")))
+end
diff --git a/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs
index bed897e23..7257b2cf3 100644
--- a/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs
+++ b/test/pleroma/web/mastodon_api/controllers/timeline_controller_test.exs
@@ -150,6 +150,35 @@ defmodule Pleroma.Web.MastodonAPI.TimelineControllerTest do
|> json_response_and_validate_schema(200) == []
end
+ test "bounded home selection preserves exclusive lists and response order", %{
+ user: user,
+ conn: conn
+ } do
+ import Mock
+ author = insert(:user)
+ excluded = insert(:user)
+ {:ok, user, _} = User.follow(user, author)
+ {:ok, user, _} = User.follow(user, excluded)
+ {:ok, list} = Pleroma.List.create(%{title: "exclusive", exclusive: true}, user)
+ {:ok, _list} = Pleroma.List.follow(list, excluded)
+ {:ok, first} = CommonAPI.post(author, %{status: "first"})
+ {:ok, _excluded} = CommonAPI.post(excluded, %{status: "excluded"})
+ {:ok, second} = CommonAPI.post(author, %{status: "second"})
+
+ with_mock User, [:passthrough],
+ following: fn user ->
+ :meck.passthrough([user]) ++ Enum.map(1..128, &"https://example.org/followers/#{&1}")
+ end do
+ response =
+ conn
+ |> assign(:user, user)
+ |> get("/api/v1/timelines/home")
+ |> json_response_and_validate_schema(200)
+
+ assert Enum.map(response, & &1["id"]) == [second.id, first.id]
+ end
+ end
+
test "the home timeline excludes posts from users in exclusive lists", %{
user: user,
conn: conn
File Metadata
Details
Attached
Mime Type
text/x-diff
Expires
Tue, Nov 17, 9:53 PM (17 h, 14 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
1839822
Default Alt Text
(28 KB)
Attached To
Mode
rPUBE pleroma-upstream
Attached
Detach File
Event Timeline