git.squeep.com Git - akkoma/blob - benchmarks/load_testing/users.ex

   1 defmodule Pleroma.LoadTesting.Users do
   2   @moduledoc """
   3   Module for generating users with friends.
   4   """
   5   import Ecto.Query
   6   import Pleroma.LoadTesting.Helper, only: [to_sec: 1]
   7
   8   alias Pleroma.Repo
   9   alias Pleroma.User
  10   alias Pleroma.User.Query
  11
  12   @defaults [
  13     users: 20_000,
  14     friends: 100
  15   ]
  16
  17   @max_concurrency 30
  18
  19   @spec generate(keyword()) :: User.t()
  20   def generate(opts \\ []) do
  21     opts = Keyword.merge(@defaults, opts)
  22
  23     IO.puts("Starting generating #{opts[:users]} users...")
  24
  25     {time, _} = :timer.tc(fn -> generate_users(opts[:users]) end)
  26
  27     IO.puts("Generating users take #{to_sec(time)} sec.\n")
  28
  29     main_user =
  30       Repo.one(from(u in User, where: u.local == true, order_by: fragment("RANDOM()"), limit: 1))
  31
  32     IO.puts("Starting making friends for #{opts[:friends]} users...")
  33     {time, _} = :timer.tc(fn -> make_friends(main_user, opts[:friends]) end)
  34
  35     IO.puts("Making friends take #{to_sec(time)} sec.\n")
  36
  37     Repo.get(User, main_user.id)
  38   end
  39
  40   defp generate_users(max) do
  41     Task.async_stream(
  42       1..max,
  43       &generate_user(&1),
  44       max_concurrency: @max_concurrency,
  45       timeout: 30_000
  46     )
  47     |> Stream.run()
  48   end
  49
  50   defp generate_user(i) do
  51     remote = Enum.random([true, false])
  52
  53     %User{
  54       name: "Test テスト User #{i}",
  55       email: "user#{i}@example.com",
  56       nickname: "nick#{i}",
  57       password_hash: Comeonin.Pbkdf2.hashpwsalt("test"),
  58       bio: "Tester Number #{i}",
  59       local: !remote
  60     }
  61     |> user_urls()
  62     |> Repo.insert!()
  63   end
  64
  65   defp user_urls(%{local: true} = user) do
  66     urls = %{
  67       ap_id: User.ap_id(user),
  68       follower_address: User.ap_followers(user),
  69       following_address: User.ap_following(user)
  70     }
  71
  72     Map.merge(user, urls)
  73   end
  74
  75   defp user_urls(%{local: false} = user) do
  76     base_domain = Enum.random(["domain1.com", "domain2.com", "domain3.com"])
  77
  78     ap_id = "https://#{base_domain}/users/#{user.nickname}"
  79
  80     urls = %{
  81       ap_id: ap_id,
  82       follower_address: ap_id <> "/followers",
  83       following_address: ap_id <> "/following"
  84     }
  85
  86     Map.merge(user, urls)
  87   end
  88
  89   defp make_friends(main_user, max) when is_integer(max) do
  90     number_of_users =
  91       (max / 2)
  92       |> Kernel.trunc()
  93
  94     main_user
  95     |> get_users(%{limit: number_of_users, local: :local})
  96     |> run_stream(main_user)
  97
  98     main_user
  99     |> get_users(%{limit: number_of_users, local: :external})
 100     |> run_stream(main_user)
 101   end
 102
 103   defp make_friends(%User{} = main_user, %User{} = user) do
 104     {:ok, _} = User.follow(main_user, user)
 105     {:ok, _} = User.follow(user, main_user)
 106   end
 107
 108   @spec get_users(User.t(), keyword()) :: [User.t()]
 109   def get_users(user, opts) do
 110     criteria = %{limit: opts[:limit]}
 111
 112     criteria =
 113       if opts[:local] do
 114         Map.put(criteria, opts[:local], true)
 115       else
 116         criteria
 117       end
 118
 119     criteria =
 120       if opts[:friends?] do
 121         Map.put(criteria, :friends, user)
 122       else
 123         criteria
 124       end
 125
 126     query =
 127       criteria
 128       |> Query.build()
 129       |> random_without_user(user)
 130
 131     query =
 132       if opts[:friends?] == false do
 133         friends_ids =
 134           %{friends: user}
 135           |> Query.build()
 136           |> Repo.all()
 137           |> Enum.map(& &1.id)
 138
 139         from(u in query, where: u.id not in ^friends_ids)
 140       else
 141         query
 142       end
 143
 144     Repo.all(query)
 145   end
 146
 147   defp random_without_user(query, user) do
 148     from(u in query,
 149       where: u.id != ^user.id,
 150       order_by: fragment("RANDOM()")
 151     )
 152   end
 153
 154   defp run_stream(users, main_user) do
 155     Task.async_stream(users, &make_friends(main_user, &1),
 156       max_concurrency: @max_concurrency,
 157       timeout: 30_000
 158     )
 159     |> Stream.run()
 160   end
 161 end