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

   1 defmodule Pleroma.LoadTesting.Generator do
   2   use Pleroma.LoadTesting.Helper
   3   alias Pleroma.Web.CommonAPI
   4
   5   def generate_like_activities(user, posts) do
   6     count_likes = Kernel.trunc(length(posts) / 4)
   7     IO.puts("Starting generating #{count_likes} like activities...")
   8
   9     {time, _} =
  10       :timer.tc(fn ->
  11         Task.async_stream(
  12            Enum.take_random(posts, count_likes),
  13           fn post -> {:ok, _, _} = CommonAPI.favorite(post.id, user) end,
  14           max_concurrency: 10,
  15           timeout: 30_000
  16         )
  17         |> Stream.run()
  18       end)
  19
  20     IO.puts("Inserting like activities take #{to_sec(time)} sec.\n")
  21   end
  22
  23   def generate_users(opts) do
  24     IO.puts("Starting generating #{opts[:users_max]} users...")
  25     {time, _} = :timer.tc(fn -> do_generate_users(opts) end)
  26
  27     IO.puts("Inserting users take #{to_sec(time)} sec.\n")
  28   end
  29
  30   defp do_generate_users(opts) do
  31     max = Keyword.get(opts, :users_max)
  32
  33     Task.async_stream(
  34       1..max,
  35       &generate_user_data(&1),
  36       max_concurrency: 10,
  37       timeout: 30_000
  38     )
  39     |> Enum.to_list()
  40   end
  41
  42   defp generate_user_data(i) do
  43     remote = Enum.random([true, false])
  44
  45     user = %User{
  46       name: "Test テスト User #{i}",
  47       email: "user#{i}@example.com",
  48       nickname: "nick#{i}",
  49       password_hash:
  50         "$pbkdf2-sha512$160000$bU.OSFI7H/yqWb5DPEqyjw$uKp/2rmXw12QqnRRTqTtuk2DTwZfF8VR4MYW2xMeIlqPR/UX1nT1CEKVUx2CowFMZ5JON8aDvURrZpJjSgqXrg",
  51       bio: "Tester Number #{i}",
  52       info: %{},
  53       local: remote
  54     }
  55
  56     user_urls =
  57       if remote do
  58         base_url =
  59           Enum.random(["https://domain1.com", "https://domain2.com", "https://domain3.com"])
  60
  61         ap_id = "#{base_url}/users/#{user.nickname}"
  62
  63         %{
  64           ap_id: ap_id,
  65           follower_address: ap_id <> "/followers",
  66           following_address: ap_id <> "/following"
  67         }
  68       else
  69         %{
  70           ap_id: User.ap_id(user),
  71           follower_address: User.ap_followers(user),
  72           following_address: User.ap_following(user)
  73         }
  74       end
  75
  76     user = Map.merge(user, user_urls)
  77
  78     Repo.insert!(user)
  79   end
  80
  81   def generate_activities(user, users) do
  82     do_generate_activities(user, users)
  83   end
  84
  85   defp do_generate_activities(user, users) do
  86     IO.puts("Starting generating 20000 common activities...")
  87
  88     {time, _} =
  89       :timer.tc(fn ->
  90         Task.async_stream(
  91           1..20_000,
  92           fn _ ->
  93             do_generate_activity([user | users])
  94           end,
  95           max_concurrency: 10,
  96           timeout: 30_000
  97         )
  98         |> Stream.run()
  99       end)
 100
 101     IO.puts("Inserting common activities take #{to_sec(time)} sec.\n")
 102
 103     IO.puts("Starting generating 20000 activities with mentions...")
 104
 105     {time, _} =
 106       :timer.tc(fn ->
 107         Task.async_stream(
 108           1..20_000,
 109           fn _ ->
 110             do_generate_activity_with_mention(user, users)
 111           end,
 112           max_concurrency: 10,
 113           timeout: 30_000
 114         )
 115         |> Stream.run()
 116       end)
 117
 118     IO.puts("Inserting activities with menthions take #{to_sec(time)} sec.\n")
 119
 120     IO.puts("Starting generating 10000 activities with threads...")
 121
 122     {time, _} =
 123       :timer.tc(fn ->
 124         Task.async_stream(
 125           1..10_000,
 126           fn _ ->
 127             do_generate_threads([user | users])
 128           end,
 129           max_concurrency: 10,
 130           timeout: 30_000
 131         )
 132         |> Stream.run()
 133       end)
 134
 135     IO.puts("Inserting activities with threads take #{to_sec(time)} sec.\n")
 136   end
 137
 138   defp do_generate_activity(users) do
 139     post = %{
 140       "status" => "Some status without mention with random user"
 141     }
 142
 143     CommonAPI.post(Enum.random(users), post)
 144   end
 145
 146   defp do_generate_activity_with_mention(user, users) do
 147     mentions_cnt = Enum.random([2, 3, 4, 5])
 148     with_user = Enum.random([true, false])
 149     users = Enum.shuffle(users)
 150     mentions_users = Enum.take(users, mentions_cnt)
 151     mentions_users = if with_user, do: [user | mentions_users], else: mentions_users
 152
 153     mentions_str =
 154       Enum.map(mentions_users, fn user -> "@" <> user.nickname end) |> Enum.join(", ")
 155
 156     post = %{
 157       "status" => mentions_str <> "some status with mentions random users"
 158     }
 159
 160     CommonAPI.post(Enum.random(users), post)
 161   end
 162
 163   defp do_generate_threads(users) do
 164     thread_length = Enum.random([2, 3, 4, 5])
 165     actor = Enum.random(users)
 166
 167     post = %{
 168       "status" => "Start of the thread"
 169     }
 170
 171     {:ok, activity} = CommonAPI.post(actor, post)
 172
 173     Enum.each(1..thread_length, fn _ ->
 174       user = Enum.random(users)
 175
 176       post = %{
 177         "status" => "@#{actor.nickname} reply to thread",
 178         "in_reply_to_status_id" => activity.id
 179       }
 180
 181       CommonAPI.post(user, post)
 182     end)
 183   end
 184
 185   def generate_remote_activities(user, users) do
 186     do_generate_remote_activities(user, users)
 187   end
 188
 189   defp do_generate_remote_activities(user, users) do
 190     IO.puts("Starting generating 10000 remote activities...")
 191
 192     {time, _} =
 193       :timer.tc(fn ->
 194         Task.async_stream(
 195           1..10_000,
 196           fn i ->
 197             do_generate_remote_activity(i, user, users)
 198           end,
 199           max_concurrency: 10,
 200           timeout: 30_000
 201         )
 202         |> Stream.run()
 203       end)
 204
 205     IO.puts("Inserting remote activities take #{to_sec(time)} sec.\n")
 206   end
 207
 208   defp do_generate_remote_activity(i, user, users) do
 209     actor = Enum.random(users)
 210     %{host: host} = URI.parse(actor.ap_id)
 211     date = Date.utc_today()
 212     datetime = DateTime.utc_now()
 213
 214     map = %{
 215       "actor" => actor.ap_id,
 216       "cc" => [actor.follower_address, user.ap_id],
 217       "context" => "tag:mastodon.example.org,#{date}:objectId=#{i}:objectType=Conversation",
 218       "id" => actor.ap_id <> "/statuses/#{i}/activity",
 219       "object" => %{
 220         "actor" => actor.ap_id,
 221         "atomUri" => actor.ap_id <> "/statuses/#{i}",
 222         "attachment" => [],
 223         "attributedTo" => actor.ap_id,
 224         "bcc" => [],
 225         "bto" => [],
 226         "cc" => [actor.follower_address, user.ap_id],
 227         "content" =>
 228           "<p><span class=\"h-card\"><a href=\"" <>
 229             user.ap_id <>
 230             "\" class=\"u-url mention\">@<span>" <> user.nickname <> "</span></a></span></p>",
 231         "context" => "tag:mastodon.example.org,#{date}:objectId=#{i}:objectType=Conversation",
 232         "conversation" =>
 233           "tag:mastodon.example.org,#{date}:objectId=#{i}:objectType=Conversation",
 234         "emoji" => %{},
 235         "id" => actor.ap_id <> "/statuses/#{i}",
 236         "inReplyTo" => nil,
 237         "inReplyToAtomUri" => nil,
 238         "published" => datetime,
 239         "sensitive" => true,
 240         "summary" => "cw",
 241         "tag" => [
 242           %{
 243             "href" => user.ap_id,
 244             "name" => "@#{user.nickname}@#{host}",
 245             "type" => "Mention"
 246           }
 247         ],
 248         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
 249         "type" => "Note",
 250         "url" => "http://#{host}/@#{actor.nickname}/#{i}"
 251       },
 252       "published" => datetime,
 253       "to" => ["https://www.w3.org/ns/activitystreams#Public"],
 254       "type" => "Create"
 255     }
 256
 257     Pleroma.Web.ActivityPub.ActivityPub.insert(map, false)
 258   end
 259
 260   def generate_dms(user, users, opts) do
 261     IO.puts("Starting generating #{opts[:dms_max]} DMs")
 262     {time, _} = :timer.tc(fn -> do_generate_dms(user, users, opts) end)
 263     IO.puts("Inserting dms take #{to_sec(time)} sec.\n")
 264   end
 265
 266   defp do_generate_dms(user, users, opts) do
 267     Task.async_stream(
 268       1..opts[:dms_max],
 269       fn _ ->
 270         do_generate_dm(user, users)
 271       end,
 272       max_concurrency: 10,
 273       timeout: 30_000
 274     )
 275     |> Stream.run()
 276   end
 277
 278   defp do_generate_dm(user, users) do
 279     post = %{
 280       "status" => "@#{user.nickname} some direct message",
 281       "visibility" => "direct"
 282     }
 283
 284     CommonAPI.post(Enum.random(users), post)
 285   end
 286
 287   def generate_long_thread(user, users, opts) do
 288     IO.puts("Starting generating long thread with #{opts[:thread_length]} replies")
 289     {time, activity} = :timer.tc(fn -> do_generate_long_thread(user, users, opts) end)
 290     IO.puts("Inserting long thread replies take #{to_sec(time)} sec.\n")
 291     {:ok, activity}
 292   end
 293
 294   defp do_generate_long_thread(user, users, opts) do
 295     {:ok, %{id: id} = activity} = CommonAPI.post(user, %{"status" => "Start of long thread"})
 296
 297     Task.async_stream(
 298       1..opts[:thread_length],
 299       fn _ -> do_generate_thread(users, id) end,
 300       max_concurrency: 10,
 301       timeout: 30_000
 302     )
 303     |> Stream.run()
 304
 305     activity
 306   end
 307
 308   defp do_generate_thread(users, activity_id) do
 309     CommonAPI.post(Enum.random(users), %{
 310       "status" => "reply to main post",
 311       "in_reply_to_status_id" => activity_id
 312     })
 313   end
 314
 315   def generate_non_visible_message(user, users) do
 316     IO.puts("Starting generating 1000 non visible posts")
 317
 318     {time, _} =
 319       :timer.tc(fn ->
 320         do_generate_non_visible_posts(user, users)
 321       end)
 322
 323     IO.puts("Inserting non visible posts take #{to_sec(time)} sec.\n")
 324   end
 325
 326   defp do_generate_non_visible_posts(user, users) do
 327     [not_friend | users] = users
 328
 329     make_friends(user, users)
 330
 331     Task.async_stream(1..1000, fn _ -> do_generate_non_visible_post(not_friend, users) end,
 332       max_concurrency: 10,
 333       timeout: 30_000
 334     )
 335     |> Stream.run()
 336   end
 337
 338   defp make_friends(_user, []), do: nil
 339
 340   defp make_friends(user, [friend | users]) do
 341     {:ok, _} = User.follow(user, friend)
 342     {:ok, _} = User.follow(friend, user)
 343     make_friends(user, users)
 344   end
 345
 346   defp do_generate_non_visible_post(not_friend, users) do
 347     post = %{
 348       "status" => "some non visible post",
 349       "visibility" => "private"
 350     }
 351
 352     {:ok, activity} = CommonAPI.post(not_friend, post)
 353
 354     thread_length = Enum.random([2, 3, 4, 5])
 355
 356     Enum.each(1..thread_length, fn _ ->
 357       user = Enum.random(users)
 358
 359       post = %{
 360         "status" => "@#{not_friend.nickname} reply to non visible post",
 361         "in_reply_to_status_id" => activity.id,
 362         "visibility" => "private"
 363       }
 364
 365       CommonAPI.post(user, post)
 366     end)
 367   end
 368 end