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