Page MenuHomePhorge

No OneTemporary

Authored By
Unknown
Size
28 KB
Referenced Files
None
Subscribers
None
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

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)

Event Timeline