No OneTemporary
Actions

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/benchmarks/load_testing/activities.ex b/benchmarks/load_testing/activities.ex
	index b9f6b24da..7f262d228 100644
	--- a/benchmarks/load_testing/activities.ex
	+++ b/benchmarks/load_testing/activities.ex
	@@ -1,595 +1,595 @@
	defmodule Pleroma.LoadTesting.Activities do
	@moduledoc """
	Module for generating different activities.
	"""
	import Ecto.Query
	import Pleroma.LoadTesting.Helper, only: [to_sec: 1]

	alias Ecto.UUID
	alias Pleroma.Constants
	alias Pleroma.LoadTesting.Users
	alias Pleroma.Repo
	alias Pleroma.Web.CommonAPI

	require Constants

	@defaults [
	iterations: 170,
	friends_used: 20,
	non_friends_used: 20
	]

	@max_concurrency 10

	@visibility ~w(public private direct unlisted)
	@types [
	:simple,
	:simple_filtered,
	:emoji,
	:mentions,
	:hell_thread,
	:attachment,
	:tag,
	:like,
	:reblog,
	:simple_thread
	]
	@groups [:friends_local, :friends_remote, :non_friends_local, :non_friends_local]
	@remote_groups [:friends_remote, :non_friends_remote]
	@friends_groups [:friends_local, :friends_remote]
	@non_friends_groups [:non_friends_local, :non_friends_remote]

	@spec generate(User.t(), keyword()) :: :ok
	def generate(user, opts \\ []) do
	{:ok, _} =
	Agent.start_link(fn -> %{} end,
	name: :benchmark_state
	)

	opts = Keyword.merge(@defaults, opts)

	users = Users.prepare_users(user, opts)

	{:ok, _} = Agent.start_link(fn -> users[:non_friends_remote] end, name: :non_friends_remote)

	task_data =
	for visibility <- @visibility,
	type <- @types,
	group <- [:user \| @groups],
	do: {visibility, type, group}

	IO.puts("Starting generating #{opts[:iterations]} iterations of activities...")

	public_long_thread = fn ->
	generate_long_thread("public", users, opts)
	end

	private_long_thread = fn ->
	generate_long_thread("private", users, opts)
	end

	iterations = opts[:iterations]

	{time, _} =
	:timer.tc(fn ->
	Enum.each(
	1..iterations,
	fn
	i when i == iterations - 2 ->
	spawn(public_long_thread)
	spawn(private_long_thread)
	generate_activities(users, Enum.shuffle(task_data), opts)

	_ ->
	generate_activities(users, Enum.shuffle(task_data), opts)
	end
	)
	end)

	IO.puts("Generating iterations of activities took #{to_sec(time)} sec.\n")
	:ok
	end

	def generate_power_intervals(opts \\ []) do
	count = Keyword.get(opts, :count, 20)
	power = Keyword.get(opts, :power, 2)
	IO.puts("Generating #{count} intervals for a power #{power} series...")
	counts = Enum.map(1..count, fn n -> :math.pow(n, power) end)
	sum = Enum.sum(counts)

	densities =
	Enum.map(counts, fn c ->
	c / sum
	end)

	densities
	\|> Enum.reduce(0, fn density, acc ->
	if acc == 0 do
	[{0, density}]
	else
	[{_, lower} \| _] = acc
	[{lower, lower + density} \| acc]
	end
	end)
	\|> Enum.reverse()
	end

	def generate_tagged_activities(opts \\ []) do
	tag_count = Keyword.get(opts, :tag_count, 20)
	users = Keyword.get(opts, :users, Repo.all(Pleroma.User))
	activity_count = Keyword.get(opts, :count, 200_000)

	intervals = generate_power_intervals(count: tag_count)

	IO.puts(
	"Generating #{activity_count} activities using #{tag_count} different tags of format `tag_n`, starting at tag_0"
	)

	Enum.each(1..activity_count, fn _ ->
	random = :rand.uniform()
	i = Enum.find_index(intervals, fn {lower, upper} -> lower <= random && upper > random end)
	CommonAPI.post(Enum.random(users), %{status: "a post with the tag #tag_#{i}"})
	end)
	end

	defp generate_long_thread(visibility, users, _opts) do
	group =
	if visibility == "public",
	do: :friends_local,
	else: :user

	tasks = get_reply_tasks(visibility, group) \|> Stream.cycle() \|> Enum.take(50)

	{:ok, activity} =
	CommonAPI.post(users[:user], %{
	status: "Start of #{visibility} long thread",
	visibility: visibility
	})

	Agent.update(:benchmark_state, fn state ->
	key =
	if visibility == "public",
	do: :public_thread,
	else: :private_thread

	Map.put(state, key, activity)
	end)

	acc = {activity.id, ["@" <> users[:user].nickname, "reply to long thread"]}
	insert_replies_for_long_thread(tasks, visibility, users, acc)
	IO.puts("Generating #{visibility} long thread ended\n")
	end

	defp insert_replies_for_long_thread(tasks, visibility, users, acc) do
	Enum.reduce(tasks, acc, fn
	:user, {id, data} ->
	user = users[:user]
	insert_reply(user, List.delete(data, "@" <> user.nickname), id, visibility)

	group, {id, data} ->
	replier = Enum.random(users[group])
	insert_reply(replier, List.delete(data, "@" <> replier.nickname), id, visibility)
	end)
	end

	defp generate_activities(users, task_data, opts) do
	Task.async_stream(
	task_data,
	fn {visibility, type, group} ->
	insert_activity(type, visibility, group, users, opts)
	end,
	max_concurrency: @max_concurrency,
	timeout: 30_000
	)
	\|> Stream.run()
	end

	defp insert_local_activity(visibility, group, users, status) do
	{:ok, _} =
	group
	\|> get_actor(users)
	\|> CommonAPI.post(%{status: status, visibility: visibility})
	end

	defp insert_remote_activity(visibility, group, users, status) do
	actor = get_actor(group, users)
	{act_data, obj_data} = prepare_activity_data(actor, visibility, users[:user])
	{activity_data, object_data} = other_data(actor, status)

	activity_data
	\|> Map.merge(act_data)
	\|> Map.put("object", Map.merge(object_data, obj_data))
	\|> Pleroma.Web.ActivityPub.ActivityPub.insert(false)
	end

	defp user_mentions(users) do
	user_mentions =
	Enum.reduce(
	@groups,
	[],
	fn group, acc ->
	acc ++ get_random_mentions(users[group], Enum.random(0..2))
	end
	)

	if Enum.random([true, false]),
	do: ["@" <> users[:user].nickname \| user_mentions],
	else: user_mentions
	end

	defp hell_thread_mentions(users) do
	with {:ok, nil} <- Cachex.get(:user_cache, "hell_thread_mentions") do
	cached =
	@groups
	\|> Enum.reduce([users[:user]], fn group, acc ->
	acc ++ Enum.take(users[group], 5)
	end)
	\|> Enum.map(&"@#{&1.nickname}")
	\|> Enum.join(", ")

	Cachex.put(:user_cache, "hell_thread_mentions", cached)
	cached
	else
	{:ok, cached} -> cached
	end
	end

	defp insert_activity(:simple, visibility, group, users, _opts)
	when group in @remote_groups do
	insert_remote_activity(visibility, group, users, "Remote status")
	end

	defp insert_activity(:simple, visibility, group, users, _opts) do
	insert_local_activity(visibility, group, users, "Simple status")
	end

	defp insert_activity(:simple_filtered, visibility, group, users, _opts)
	when group in @remote_groups do
	insert_remote_activity(visibility, group, users, "Remote status which must be filtered")
	end

	defp insert_activity(:simple_filtered, visibility, group, users, _opts) do
	insert_local_activity(visibility, group, users, "Simple status which must be filtered")
	end

	defp insert_activity(:emoji, visibility, group, users, _opts)
	when group in @remote_groups do
	insert_remote_activity(visibility, group, users, "Remote status with emoji :firefox:")
	end

	defp insert_activity(:emoji, visibility, group, users, _opts) do
	insert_local_activity(visibility, group, users, "Simple status with emoji :firefox:")
	end

	defp insert_activity(:mentions, visibility, group, users, _opts)
	when group in @remote_groups do
	mentions = user_mentions(users)

	status = Enum.join(mentions, ", ") <> " remote status with mentions"

	insert_remote_activity(visibility, group, users, status)
	end

	defp insert_activity(:mentions, visibility, group, users, _opts) do
	mentions = user_mentions(users)

	status = Enum.join(mentions, ", ") <> " simple status with mentions"
	insert_remote_activity(visibility, group, users, status)
	end

	defp insert_activity(:hell_thread, visibility, group, users, _)
	when group in @remote_groups do
	mentions = hell_thread_mentions(users)
	insert_remote_activity(visibility, group, users, mentions <> " remote hell thread status")
	end

	defp insert_activity(:hell_thread, visibility, group, users, _opts) do
	mentions = hell_thread_mentions(users)

	insert_local_activity(visibility, group, users, mentions <> " hell thread status")
	end

	defp insert_activity(:attachment, visibility, group, users, _opts) do
	actor = get_actor(group, users)

	obj_data = %{
	"actor" => actor.ap_id,
	"name" => "4467-11.jpg",
	"type" => "Document",
	"url" => [
	%{
	"href" =>
	"#{Pleroma.Web.Endpoint.url()}/media/b1b873552422a07bf53af01f3c231c841db4dfc42c35efde681abaf0f2a4eab7.jpg",
	"mediaType" => "image/jpeg",
	"type" => "Link"
	}
	]
	}

	object = Repo.insert!(%Pleroma.Object{data: obj_data})

	{:ok, _activity} =
	CommonAPI.post(actor, %{
	status: "Post with attachment",
	visibility: visibility,
	media_ids: [object.id]
	})
	end

	defp insert_activity(:tag, visibility, group, users, _opts) do
	insert_local_activity(visibility, group, users, "Status with #tag")
	end

	defp insert_activity(:like, visibility, group, users, opts) do
	actor = get_actor(group, users)

	with activity_id when not is_nil(activity_id) <- get_random_create_activity_id(),
	{:ok, _activity} <- CommonAPI.favorite(actor, activity_id) do
	:ok
	else
	{:error, _} ->
	insert_activity(:like, visibility, group, users, opts)

	nil ->
	Process.sleep(15)
	insert_activity(:like, visibility, group, users, opts)
	end
	end

	defp insert_activity(:reblog, visibility, group, users, opts) do
	actor = get_actor(group, users)

	with activity_id when not is_nil(activity_id) <- get_random_create_activity_id(),
	{:ok, _activity} <- CommonAPI.repeat(activity_id, actor) do
	:ok
	else
	{:error, _} ->
	insert_activity(:reblog, visibility, group, users, opts)

	nil ->
	Process.sleep(15)
	insert_activity(:reblog, visibility, group, users, opts)
	end
	end

	defp insert_activity(:simple_thread, "direct", group, users, _opts) do
	actor = get_actor(group, users)
	tasks = get_reply_tasks("direct", group)

	list =
	case group do
	:user ->
	group = Enum.random(@friends_groups)
	Enum.take(users[group], 3)

	_ ->
	Enum.take(users[group], 3)
	end

	data = Enum.map(list, &("@" <> &1.nickname))

	{:ok, activity} =
	CommonAPI.post(actor, %{
	status: Enum.join(data, ", ") <> "simple status",
	visibility: "direct"
	})

	acc = {activity.id, ["@" <> users[:user].nickname \| data] ++ ["reply to status"]}
	insert_direct_replies(tasks, users[:user], list, acc)
	end

	defp insert_activity(:simple_thread, visibility, group, users, _opts) do
	actor = get_actor(group, users)
	tasks = get_reply_tasks(visibility, group)

	{:ok, activity} =
	CommonAPI.post(users[:user], %{status: "Simple status", visibility: visibility})

	acc = {activity.id, ["@" <> actor.nickname, "reply to status"]}
	insert_replies(tasks, visibility, users, acc)
	end

	defp get_actor(:user, %{user: user}), do: user
	defp get_actor(group, users), do: Enum.random(users[group])

	defp other_data(actor, content) do
	%{host: host} = URI.parse(actor.ap_id)
	- datetime = DateTime.utc_now()
	+ datetime = DateTime.utc_now() \|> to_string()
	context_id = "https://#{host}/contexts/#{UUID.generate()}"
	activity_id = "https://#{host}/activities/#{UUID.generate()}"
	object_id = "https://#{host}/objects/#{UUID.generate()}"

	activity_data = %{
	"actor" => actor.ap_id,
	"context" => context_id,
	"id" => activity_id,
	"published" => datetime,
	"type" => "Create",
	"directMessage" => false
	}

	object_data = %{
	"actor" => actor.ap_id,
	"attachment" => [],
	"attributedTo" => actor.ap_id,
	"bcc" => [],
	"bto" => [],
	"content" => content,
	"context" => context_id,
	"conversation" => context_id,
	"emoji" => %{},
	"id" => object_id,
	"published" => datetime,
	"sensitive" => false,
	"summary" => "",
	"tag" => [],
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"type" => "Note"
	}

	{activity_data, object_data}
	end

	defp prepare_activity_data(actor, "public", _mention) do
	obj_data = %{
	"cc" => [actor.follower_address],
	"to" => [Constants.as_public()]
	}

	act_data = %{
	"cc" => [actor.follower_address],
	"to" => [Constants.as_public()]
	}

	{act_data, obj_data}
	end

	defp prepare_activity_data(actor, "private", _mention) do
	obj_data = %{
	"cc" => [],
	"to" => [actor.follower_address]
	}

	act_data = %{
	"cc" => [],
	"to" => [actor.follower_address]
	}

	{act_data, obj_data}
	end

	defp prepare_activity_data(actor, "unlisted", _mention) do
	obj_data = %{
	"cc" => [Constants.as_public()],
	"to" => [actor.follower_address]
	}

	act_data = %{
	"cc" => [Constants.as_public()],
	"to" => [actor.follower_address]
	}

	{act_data, obj_data}
	end

	defp prepare_activity_data(_actor, "direct", mention) do
	%{host: mentioned_host} = URI.parse(mention.ap_id)

	obj_data = %{
	"cc" => [],
	"content" =>
	"<span class=\"h-card\"><a class=\"u-url mention\" href=\"#{mention.ap_id}\" rel=\"ugc\">@<span>#{
	mention.nickname
	}</span></a></span> direct message",
	"tag" => [
	%{
	"href" => mention.ap_id,
	"name" => "@#{mention.nickname}@#{mentioned_host}",
	"type" => "Mention"
	}
	],
	"to" => [mention.ap_id]
	}

	act_data = %{
	"cc" => [],
	"directMessage" => true,
	"to" => [mention.ap_id]
	}

	{act_data, obj_data}
	end

	defp get_reply_tasks("public", :user) do
	[:friends_local, :friends_remote, :non_friends_local, :non_friends_remote, :user]
	end

	defp get_reply_tasks("public", group) when group in @friends_groups do
	[:non_friends_local, :non_friends_remote, :user, :friends_local, :friends_remote]
	end

	defp get_reply_tasks("public", group) when group in @non_friends_groups do
	[:user, :friends_local, :friends_remote, :non_friends_local, :non_friends_remote]
	end

	defp get_reply_tasks(visibility, :user) when visibility in ["unlisted", "private"] do
	[:friends_local, :friends_remote, :user, :friends_local, :friends_remote]
	end

	defp get_reply_tasks(visibility, group)
	when visibility in ["unlisted", "private"] and group in @friends_groups do
	[:user, :friends_remote, :friends_local, :user]
	end

	defp get_reply_tasks(visibility, group)
	when visibility in ["unlisted", "private"] and
	group in @non_friends_groups,
	do: []

	defp get_reply_tasks("direct", :user), do: [:friends_local, :user, :friends_remote]

	defp get_reply_tasks("direct", group) when group in @friends_groups,
	do: [:user, group, :user]

	defp get_reply_tasks("direct", group) when group in @non_friends_groups do
	[:user, :non_friends_remote, :user, :non_friends_local]
	end

	defp insert_replies(tasks, visibility, users, acc) do
	Enum.reduce(tasks, acc, fn
	:user, {id, data} ->
	insert_reply(users[:user], data, id, visibility)

	group, {id, data} ->
	replier = Enum.random(users[group])
	insert_reply(replier, data, id, visibility)
	end)
	end

	defp insert_direct_replies(tasks, user, list, acc) do
	Enum.reduce(tasks, acc, fn
	:user, {id, data} ->
	{reply_id, _} = insert_reply(user, List.delete(data, "@" <> user.nickname), id, "direct")
	{reply_id, data}

	_, {id, data} ->
	actor = Enum.random(list)

	{reply_id, _} =
	insert_reply(actor, List.delete(data, "@" <> actor.nickname), id, "direct")

	{reply_id, data}
	end)
	end

	defp insert_reply(actor, data, activity_id, visibility) do
	{:ok, reply} =
	CommonAPI.post(actor, %{
	status: Enum.join(data, ", "),
	visibility: visibility,
	in_reply_to_status_id: activity_id
	})

	{reply.id, ["@" <> actor.nickname \| data]}
	end

	defp get_random_mentions(_users, count) when count == 0, do: []

	defp get_random_mentions(users, count) do
	users
	\|> Enum.shuffle()
	\|> Enum.take(count)
	\|> Enum.map(&"@#{&1.nickname}")
	end

	defp get_random_create_activity_id do
	Repo.one(
	from(a in Pleroma.Activity,
	where: fragment("(?)->>'type' = ?", a.data, ^"Create"),
	order_by: fragment("RANDOM()"),
	limit: 1,
	select: a.id
	)
	)
	end
	end
	diff --git a/config/benchmark.exs b/config/benchmark.exs
	index a4d048f1b..9a7ea5669 100644
	--- a/config/benchmark.exs
	+++ b/config/benchmark.exs
	@@ -1,88 +1,87 @@
	import Config

	# We don't run a server during test. If one is required,
	# you can enable the server option below.
	config :pleroma, Pleroma.Web.Endpoint,
	http: [port: 4001],
	- url: [port: 4001],
	- server: true
	+ url: [port: 4001]

	# Disable captha for tests
	config :pleroma, Pleroma.Captcha,
	# It should not be enabled for automatic tests
	enabled: false,
	# A fake captcha service for tests
	method: Pleroma.Captcha.Mock

	# Print only warnings and errors during test
	config :logger, level: :warn

	config :pleroma, :auth, oauth_consumer_strategies: []

	config :pleroma, Pleroma.Upload, filters: [], link_name: false

	config :pleroma, Pleroma.Uploaders.Local, uploads: "test/uploads"

	config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Test, enabled: true

	config :pleroma, :instance,
	email: "admin@example.com",
	notify_email: "noreply@example.com",
	skip_thread_containment: false,
	federating: false,
	external_user_synchronization: false

	config :pleroma, :activitypub, sign_object_fetches: false

	# Configure your database
	config :pleroma, Pleroma.Repo,
	adapter: Ecto.Adapters.Postgres,
	username: "postgres",
	password: "postgres",
	database: "pleroma_benchmark",
	hostname: System.get_env("DB_HOST") \|\| "localhost",
	pool_size: 10

	# Reduce hash rounds for testing
	-config :pbkdf2_elixir, rounds: 1
	+config :pleroma, :password, iterations: 1

	config :tesla, adapter: Tesla.Mock

	config :pleroma, :rich_media,
	enabled: false,
	ignore_hosts: [],
	ignore_tld: ["local", "localdomain", "lan"]

	config :web_push_encryption, :vapid_details,
	subject: "mailto:administrator@example.com",
	public_key:
	"BLH1qVhJItRGCfxgTtONfsOKDc9VRAraXw-3NsmjMngWSh7NxOizN6bkuRA7iLTMPS82PjwJAr3UoK9EC1IFrz4",
	private_key: "_-XZ0iebPrRfZ_o0-IatTdszYa8VCH1yLN-JauK7HHA"

	config :pleroma, Pleroma.ScheduledActivity,
	daily_user_limit: 2,
	total_user_limit: 3,
	enabled: false

	config :pleroma, :rate_limit,
	search: [{1000, 30}, {1000, 30}],
	app_account_creation: {10_000, 5},
	password_reset: {1000, 30}

	config :pleroma, :http_security, report_uri: "https://endpoint.com"

	config :pleroma, :http, send_user_agent: false

	rum_enabled = System.get_env("RUM_ENABLED") == "true"
	config :pleroma, :database, rum_enabled: rum_enabled
	IO.puts("RUM enabled: #{rum_enabled}")

	config :pleroma, Pleroma.ReverseProxy.Client, Pleroma.ReverseProxy.ClientMock

	if File.exists?("./config/benchmark.secret.exs") do
	import_config "benchmark.secret.exs"
	else
	IO.puts(
	"You may want to create benchmark.secret.exs to declare custom database connection parameters."
	)
	end
	diff --git a/mix.exs b/mix.exs
	index 9385f7cf4..e69c737dd 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,362 +1,362 @@
	defmodule Pleroma.Mixfile do
	use Mix.Project

	def project do
	[
	app: :pleroma,
	version: version("2.4.51"),
	elixir: "~> 1.9",
	elixirc_paths: elixirc_paths(Mix.env()),
	compilers: [:phoenix, :gettext] ++ Mix.compilers(),
	elixirc_options: [warnings_as_errors: warnings_as_errors(Mix.env())],
	xref: [exclude: [:eldap]],
	start_permanent: Mix.env() == :prod,
	aliases: aliases(),
	deps: deps(),
	test_coverage: [tool: ExCoveralls],
	preferred_cli_env: ["coveralls.html": :test],
	# Docs
	name: "Pleroma",
	homepage_url: "https://pleroma.social/",
	source_url: "https://git.pleroma.social/pleroma/pleroma",
	docs: [
	source_url_pattern:
	"https://git.pleroma.social/pleroma/pleroma/blob/develop/%{path}#L%{line}",
	logo: "priv/static/images/logo.png",
	extras: ["README.md", "CHANGELOG.md"] ++ Path.wildcard("docs/*/.md"),
	groups_for_extras: [
	"Installation manuals": Path.wildcard("docs/installation/*.md"),
	Configuration: Path.wildcard("docs/config/*.md"),
	Administration: Path.wildcard("docs/admin/*.md"),
	"Pleroma's APIs and Mastodon API extensions": Path.wildcard("docs/api/*.md")
	],
	main: "readme",
	output: "priv/static/doc"
	],
	releases: [
	pleroma: [
	include_executables_for: [:unix],
	applications: [ex_syslogger: :load, syslog: :load, eldap: :transient],
	steps: [:assemble, &put_otp_version/1, &copy_files/1, &copy_nginx_config/1],
	config_providers: [{Pleroma.Config.ReleaseRuntimeProvider, []}]
	]
	]
	]
	end

	def put_otp_version(%{path: target_path} = release) do
	File.write!(
	Path.join([target_path, "OTP_VERSION"]),
	Pleroma.OTPVersion.version()
	)

	release
	end

	def copy_files(%{path: target_path} = release) do
	File.cp_r!("./rel/files", target_path)
	release
	end

	def copy_nginx_config(%{path: target_path} = release) do
	File.cp!(
	"./installation/pleroma.nginx",
	Path.join([target_path, "installation", "pleroma.nginx"])
	)

	release
	end

	# Configuration for the OTP application.
	#
	# Type `mix help compile.app` for more information.
	def application do
	[
	mod: {Pleroma.Application, []},
	extra_applications: [
	:logger,
	:runtime_tools,
	:comeonin,
	:quack,
	:fast_sanitize,
	:ssl
	],
	included_applications: [:ex_syslogger]
	]
	end

	# Specifies which paths to compile per environment.
	- defp elixirc_paths(:benchmark), do: ["lib", "benchmarks"]
	+ defp elixirc_paths(:benchmark), do: ["lib", "benchmarks", "priv/scrubbers"]
	defp elixirc_paths(:test), do: ["lib", "test/support"]
	defp elixirc_paths(_), do: ["lib"]

	defp warnings_as_errors(:prod), do: false
	defp warnings_as_errors(_), do: true

	# Specifies OAuth dependencies.
	defp oauth_deps do
	oauth_strategy_packages =
	System.get_env("OAUTH_CONSUMER_STRATEGIES")
	\|> to_string()
	\|> String.split()
	\|> Enum.map(fn strategy_entry ->
	with [_strategy, dependency] <- String.split(strategy_entry, ":") do
	dependency
	else
	[strategy] -> "ueberauth_#{strategy}"
	end
	end)

	for s <- oauth_strategy_packages, do: {String.to_atom(s), ">= 0.0.0"}
	end

	# Specifies your project dependencies.
	#
	# Type `mix help deps` for examples and options.
	defp deps do
	[
	{:phoenix, "~> 1.5.5"},
	{:tzdata, "~> 1.0.3"},
	{:plug_cowboy, "~> 2.3"},
	{:phoenix_pubsub, "~> 2.0"},
	{:phoenix_ecto, "~> 4.0"},
	{:ecto_enum, "~> 1.4"},
	{:ecto_sql, "~> 3.6.2"},
	{:postgrex, ">= 0.15.5"},
	{:oban, "~> 2.3.4"},
	{:gettext, "~> 0.18"},
	{:bcrypt_elixir, "~> 2.2"},
	{:trailing_format_plug, "~> 0.0.7"},
	{:fast_sanitize, "~> 0.2.0"},
	{:html_entities, "~> 0.5", override: true},
	{:phoenix_html, "~> 2.14"},
	{:calendar, "~> 1.0"},
	{:cachex, "~> 3.2"},
	{:poison, "~> 3.0", override: true},
	{:tesla, "~> 1.4.0", override: true},
	{:castore, "~> 0.1"},
	{:cowlib, "~> 2.9", override: true},
	{:gun, "~> 2.0.0-rc.1", override: true},
	{:jason, "~> 1.2"},
	{:mogrify, "~> 0.9.1"},
	{:ex_aws, "~> 2.1.6"},
	{:ex_aws_s3, "~> 2.0"},
	{:sweet_xml, "~> 0.6.6"},
	{:earmark, "~> 1.4.15"},
	{:bbcode_pleroma, "~> 0.2.0"},
	{:crypt,
	git: "https://github.com/msantos/crypt.git",
	ref: "f75cd55325e33cbea198fb41fe41871392f8fb76"},
	{:cors_plug, "~> 2.0"},
	{:web_push_encryption,
	git: "https://github.com/lanodan/elixir-web-push-encryption.git", branch: "bugfix/otp-24"},
	{:swoosh, "~> 1.0"},
	{:phoenix_swoosh, "~> 0.3"},
	{:gen_smtp, "~> 0.13"},
	{:ex_syslogger, "~> 1.4"},
	{:floki, "~> 0.27"},
	{:timex, "~> 3.6"},
	{:ueberauth, "~> 0.4"},
	{:linkify, "~> 0.5.1"},
	{:http_signatures, "~> 0.1.1"},
	{:telemetry, "~> 0.3"},
	{:poolboy, "~> 1.5"},
	{:prometheus, "~> 4.6"},
	{:prometheus_ex,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/prometheus.ex.git",
	ref: "a4e9beb3c1c479d14b352fd9d6dd7b1f6d7deee5",
	override: true},
	{:prometheus_plugs, "~> 1.1"},
	{:prometheus_phoenix, "~> 1.3"},
	# Note: once `prometheus_phx` is integrated into `prometheus_phoenix`, remove the former:
	{:prometheus_phx,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/prometheus-phx.git",
	branch: "no-logging"},
	{:prometheus_ecto, "~> 1.4"},
	{:recon, "~> 2.5"},
	{:quack, "~> 0.1.1"},
	{:joken, "~> 2.0"},
	{:benchee, "~> 1.0"},
	{:pot, "~> 1.0"},
	{:esshd, "~> 0.1.0", runtime: Application.get_env(:esshd, :enabled, false)},
	{:ex_const, "~> 0.2"},
	{:plug_static_index_html, "~> 1.0.0"},
	{:flake_id, "~> 0.1.0"},
	{:concurrent_limiter,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/concurrent_limiter.git",
	ref: "d81be41024569330f296fc472e24198d7499ba78"},
	{:remote_ip,
	git: "https://git.pleroma.social/pleroma/remote_ip.git",
	ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"},
	{:captcha,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/elixir-captcha.git",
	ref: "e0f16822d578866e186a0974d65ad58cddc1e2ab"},
	{:restarter, path: "./restarter"},
	{:majic,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/majic.git",
	ref: "289cda1b6d0d70ccb2ba508a2b0bd24638db2880"},
	{:eblurhash, "~> 1.1.0"},
	{:open_api_spex, "~> 3.10"},

	# indirect dependency version override
	{:plug, "~> 1.10.4", override: true},

	## dev & test
	{:ex_doc, "~> 0.22", only: :dev, runtime: false},
	{:ex_machina, "~> 2.4", only: :test},
	{:credo, "~> 1.4", only: [:dev, :test], runtime: false},
	{:mock, "~> 0.3.5", only: :test},
	# temporary downgrade for excoveralls, hackney until hackney max_connections bug will be fixed
	{:excoveralls, "0.12.3", only: :test},
	{:hackney, "~> 1.18.0", override: true},
	{:mox, "~> 1.0", only: :test},
	{:websocket_client, git: "https://github.com/jeremyong/websocket_client.git", only: :test}
	] ++ oauth_deps()
	end

	# Aliases are shortcuts or tasks specific to the current project.
	# For example, to create, migrate and run the seeds file at once:
	#
	# $ mix ecto.setup
	#
	# See the documentation for `Mix` for more info on aliases.
	defp aliases do
	[
	"ecto.migrate": ["pleroma.ecto.migrate"],
	"ecto.rollback": ["pleroma.ecto.rollback"],
	"ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
	"ecto.reset": ["ecto.drop", "ecto.setup"],
	test: ["ecto.create --quiet", "ecto.migrate", "test"],
	docs: ["pleroma.docs", "docs"],
	analyze: ["credo --strict --only=warnings,todo,fixme,consistency,readability"],
	copyright: &add_copyright/1,
	"copyright.bump": &bump_copyright/1
	]
	end

	# Builds a version string made of:
	# * the application version
	# * a pre-release if ahead of the tag: the describe string (-count-commithash)
	# * branch name
	# * build metadata:
	# * a build name if `PLEROMA_BUILD_NAME` or `:pleroma, :build_name` is defined
	# * the mix environment if different than prod
	defp version(version) do
	identifier_filter = ~r/[^0-9a-z\-]+/i

	git_available? = match?({_output, 0}, System.cmd("sh", ["-c", "command -v git"]))

	git_pre_release =
	if git_available? do
	{tag, tag_err} =
	System.cmd("git", ["describe", "--tags", "--abbrev=0"], stderr_to_stdout: true)

	{describe, describe_err} = System.cmd("git", ["describe", "--tags", "--abbrev=8"])
	{commit_hash, commit_hash_err} = System.cmd("git", ["rev-parse", "--short", "HEAD"])

	# Pre-release version, denoted from patch version with a hyphen
	cond do
	tag_err == 0 and describe_err == 0 ->
	describe
	\|> String.trim()
	\|> String.replace(String.trim(tag), "")
	\|> String.trim_leading("-")
	\|> String.trim()

	commit_hash_err == 0 ->
	"0-g" <> String.trim(commit_hash)

	true ->
	nil
	end
	end

	# Branch name as pre-release version component, denoted with a dot
	branch_name =
	with true <- git_available?,
	{branch_name, 0} <- System.cmd("git", ["rev-parse", "--abbrev-ref", "HEAD"]),
	branch_name <- String.trim(branch_name),
	branch_name <- System.get_env("PLEROMA_BUILD_BRANCH") \|\| branch_name,
	true <-
	!Enum.any?(["master", "HEAD", "release/", "stable"], fn name ->
	String.starts_with?(name, branch_name)
	end) do
	branch_name =
	branch_name
	\|> String.trim()
	\|> String.replace(identifier_filter, "-")

	branch_name
	else
	_ -> ""
	end

	build_name =
	cond do
	name = Application.get_env(:pleroma, :build_name) -> name
	name = System.get_env("PLEROMA_BUILD_NAME") -> name
	true -> nil
	end

	env_name = if Mix.env() != :prod, do: to_string(Mix.env())
	env_override = System.get_env("PLEROMA_BUILD_ENV")

	env_name =
	case env_override do
	nil -> env_name
	env_override when env_override in ["", "prod"] -> nil
	env_override -> env_override
	end

	# Pre-release version, denoted by appending a hyphen
	# and a series of dot separated identifiers
	pre_release =
	[git_pre_release, branch_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "-" <> String.replace(string, identifier_filter, "-")
	end).()

	# Build metadata, denoted with a plus sign
	build_metadata =
	[build_name, env_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "+" <> String.replace(string, identifier_filter, "-")
	end).()

	[version, pre_release, build_metadata]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join()
	end

	defp add_copyright(_) do
	year = NaiveDateTime.utc_now().year
	template = ~s[\
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-#{year} Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	] \|> String.replace("\n", "\\n")

	find = "find lib test priv -type f \$ -name '.ex' -or -name '.exs' \$ -exec "
	grep = "grep -L '# Copyright © [0-9\-]* Pleroma' {} \\;"
	xargs = "xargs -n1 sed -i'' '1s;^;#{template};'"

	:os.cmd(String.to_charlist("#{find}#{grep} \| #{xargs}"))
	end

	defp bump_copyright(_) do
	year = NaiveDateTime.utc_now().year
	find = "find lib test priv -type f \$ -name '.ex' -or -name '.exs' \$"

	xargs =
	"xargs sed -i'' 's;# Copyright © [0-9\-]* Pleroma.*$;# Copyright © 2017-#{year} Pleroma Authors <https://pleroma.social/>;'"

	:os.cmd(String.to_charlist("#{find} \| #{xargs}"))
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 12:27 PM (1 d, 21 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1769471
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions