No OneTemporary
Actions

Size

38 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/docs/administration/CLI_tasks/release_environments.md b/docs/administration/CLI_tasks/release_environments.md
	deleted file mode 100644
	index 36ab43864..000000000
	--- a/docs/administration/CLI_tasks/release_environments.md
	+++ /dev/null
	@@ -1,9 +0,0 @@
	-# Generate release environment file
	-
	-```sh tab="OTP"
	- ./bin/pleroma_ctl release_env gen
	-```
	-
	-```sh tab="From Source"
	-mix pleroma.release_env gen
	-```
	diff --git a/docs/installation/debian_based_en.md b/docs/installation/debian_based_en.md
	index b9fc4e112..75ceb6595 100644
	--- a/docs/installation/debian_based_en.md
	+++ b/docs/installation/debian_based_en.md
	@@ -1,206 +1,205 @@
	# Installing on Debian Based Distributions
	## Installation

	This guide will assume you are on Debian Stretch. This guide should also work with Ubuntu 16.04 and 18.04. It also assumes that you have administrative rights, either as root or a user with [sudo permissions](https://www.digitalocean.com/community/tutorials/how-to-add-delete-and-grant-sudo-privileges-to-users-on-a-debian-vps). If you want to run this guide with root, ignore the `sudo` at the beginning of the lines, unless it calls a user like `sudo -Hu pleroma`; in this case, use `su <username> -s $SHELL -c 'command'` instead.

	### Required packages

	* `postgresql` (9.6+, Ubuntu 16.04 comes with 9.5, you can get a newer version from [here](https://www.postgresql.org/download/linux/ubuntu/))
	* `postgresql-contrib` (9.6+, same situtation as above)
	* `elixir` (1.8+, Follow the guide to install from the Erlang Solutions repo or use [asdf](https://github.com/asdf-vm/asdf) as the pleroma user)
	* `erlang-dev`
	* `erlang-nox`
	* `libmagic-dev`
	* `git`
	* `build-essential`
	* `cmake`

	#### Optional packages used in this guide

	* `nginx` (preferred, example configs for other reverse proxies can be found in the repo)
	* `certbot` (or any other ACME client for Let’s Encrypt certificates)
	* `ImageMagick`
	* `ffmpeg`
	* `exiftool`

	### Prepare the system

	* First update the system, if not already done:

	```shell
	sudo apt update
	sudo apt full-upgrade
	```

	* Install some of the above mentioned programs:

	```shell
	sudo apt install git build-essential postgresql postgresql-contrib cmake libmagic-devel
	```

	### Install Elixir and Erlang

	* Download and add the Erlang repository:

	```shell
	wget -P /tmp/ https://packages.erlang-solutions.com/erlang-solutions_2.0_all.deb
	sudo dpkg -i /tmp/erlang-solutions_2.0_all.deb
	```

	* Install Elixir and Erlang:

	```shell
	sudo apt update
	sudo apt install elixir erlang-dev erlang-nox
	```

	### Optional packages: [`docs/installation/optional/media_graphics_packages.md`](docs/installation/optional/media_graphics_packages.md)

	```shell
	sudo apt install imagemagick ffmpeg libimage-exiftool-perl
	```

	### Install PleromaBE

	* Add a new system user for the Pleroma service:

	```shell
	sudo useradd -r -s /bin/false -m -d /var/lib/pleroma -U pleroma
	```

	Note: To execute a single command as the Pleroma system user, use `sudo -Hu pleroma command`. You can also switch to a shell by using `sudo -Hu pleroma $SHELL`. If you don’t have and want `sudo` on your system, you can use `su` as root user (UID 0) for a single command by using `su -l pleroma -s $SHELL -c 'command'` and `su -l pleroma -s $SHELL` for starting a shell.

	* Git clone the PleromaBE repository and make the Pleroma user the owner of the directory:

	```shell
	sudo mkdir -p /opt/pleroma
	sudo chown -R pleroma:pleroma /opt/pleroma
	sudo -Hu pleroma git clone -b stable https://git.pleroma.social/pleroma/pleroma /opt/pleroma
	```

	* Change to the new directory:

	```shell
	cd /opt/pleroma
	```

	* Install the dependencies for Pleroma and answer with `yes` if it asks you to install `Hex`:

	```shell
	sudo -Hu pleroma mix deps.get
	```

	* Generate the configuration: `sudo -Hu pleroma mix pleroma.instance gen`
	* Answer with `yes` if it asks you to install `rebar3`.
	* This may take some time, because parts of pleroma get compiled first.
	* After that it will ask you a few questions about your instance and generates a configuration file in `config/generated_config.exs`.

	* Check the configuration and if all looks right, rename it, so Pleroma will load it (`prod.secret.exs` for productive instance, `dev.secret.exs` for development instances):

	```shell
	mv config/{generated_config.exs,prod.secret.exs}
	```


	* The previous command creates also the file `config/setup_db.psql`, with which you can create the database:

	```shell
	sudo -Hu postgres psql -f config/setup_db.psql
	```

	* Now run the database migration:

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix ecto.migrate
	```

	* Now you can start Pleroma already

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix phx.server
	```

	### Finalize installation

	If you want to open your newly installed instance to the world, you should run nginx or some other webserver/proxy in front of Pleroma and you should consider to create a systemd service file for Pleroma.

	#### Nginx

	* Install nginx, if not already done:

	```shell
	sudo apt install nginx
	```

	* Setup your SSL cert, using your method of choice or certbot. If using certbot, first install it:

	```shell
	sudo apt install certbot
	```

	and then set it up:

	```shell
	sudo mkdir -p /var/lib/letsencrypt/
	sudo certbot certonly --email <your@emailaddress> -d <yourdomain> --standalone
	```

	If that doesn’t work, make sure, that nginx is not already running. If it still doesn’t work, try setting up nginx first (change ssl “on” to “off” and try again).

	---

	* Copy the example nginx configuration and activate it:

	```shell
	sudo cp /opt/pleroma/installation/pleroma.nginx /etc/nginx/sites-available/pleroma.nginx
	sudo ln -s /etc/nginx/sites-available/pleroma.nginx /etc/nginx/sites-enabled/pleroma.nginx
	```

	* Before starting nginx edit the configuration and change it to your needs (e.g. change servername, change cert paths)
	* Enable and start nginx:

	```shell
	sudo systemctl enable --now nginx.service
	```

	If you need to renew the certificate in the future, uncomment the relevant location block in the nginx config and run:

	```shell
	sudo certbot certonly --email <your@emailaddress> -d <yourdomain> --webroot -w /var/lib/letsencrypt/
	```

	#### Other webserver/proxies

	You can find example configurations for them in `/opt/pleroma/installation/`.

	#### Systemd service

	* Copy example service file

	```shell
	sudo cp /opt/pleroma/installation/pleroma.service /etc/systemd/system/pleroma.service
	```

	* Edit the service file and make sure that all paths fit your installation
	-* Check that `EnvironmentFile` contains the correct path to the env file. Or generate the env file: `sudo -Hu pleroma mix pleroma.release_env gen`
	* Enable and start `pleroma.service`:

	```shell
	sudo systemctl enable --now pleroma.service
	```

	#### Create your first user

	If your instance is up and running, you can create your first user with administrative rights with the following task:

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress> --admin
	```

	#### Further reading

	{! backend/installation/further_reading.include !}

	## Questions

	Questions about the installation or didn’t it work as it should be, ask in [#pleroma:matrix.org](https://matrix.heldscal.la/#/room/#freenode_#pleroma:matrix.org) or IRC Channel #pleroma on Freenode.
	diff --git a/docs/installation/otp_en.md b/docs/installation/otp_en.md
	index 98360bcf7..63eda63ca 100644
	--- a/docs/installation/otp_en.md
	+++ b/docs/installation/otp_en.md
	@@ -1,316 +1,313 @@
	# Installing on Linux using OTP releases

	## Pre-requisites
	* A machine running Linux with GNU (e.g. Debian, Ubuntu) or musl (e.g. Alpine) libc and `x86_64`, `aarch64` or `armv7l` CPU, you have root access to. If you are not sure if it's compatible see [Detecting flavour section](#detecting-flavour) below
	* A (sub)domain pointed to the machine

	You will be running commands as root. If you aren't root already, please elevate your priviledges by executing `sudo su`/`su`.

	While in theory OTP releases are possbile to install on any compatible machine, for the sake of simplicity this guide focuses only on Debian/Ubuntu and Alpine.

	### Detecting flavour

	Paste the following into the shell:
	```sh
	arch="$(uname -m)";if [ "$arch" = "x86_64" ];then arch="amd64";elif [ "$arch" = "armv7l" ];then arch="arm";elif [ "$arch" = "aarch64" ];then arch="arm64";else echo "Unsupported arch: $arch">&2;fi;if getconf GNU_LIBC_VERSION>/dev/null;then libc_postfix="";elif [ "$(ldd 2>&1\|head -c 9)" = "musl libc" ];then libc_postfix="-musl";elif [ "$(find /lib/libc.musl*\|wc -l)" ];then libc_postfix="-musl";else echo "Unsupported libc">&2;fi;echo "$arch$libc_postfix"
	```

	If your platform is supported the output will contain the flavour string, you will need it later. If not, this just means that we don't build releases for your platform, you can still try installing from source.

	### Installing the required packages

	Other than things bundled in the OTP release Pleroma depends on:

	* curl (to download the release build)
	* unzip (needed to unpack release builds)
	* ncurses (ERTS won't run without it)
	* PostgreSQL (also utilizes extensions in postgresql-contrib)
	* nginx (could be swapped with another reverse proxy but this guide covers only it)
	* certbot (for Let's Encrypt certificates, could be swapped with another ACME client, but this guide covers only it)
	* libmagic/file

	=== "Alpine"
	```
	echo "http://nl.alpinelinux.org/alpine/latest-stable/community" >> /etc/apk/repositories
	apk update
	apk add curl unzip ncurses postgresql postgresql-contrib nginx certbot file-dev
	```

	=== "Debian/Ubuntu"
	```
	apt install curl unzip libncurses5 postgresql postgresql-contrib nginx certbot libmagic-dev
	```

	### Installing optional packages

	Per [`docs/installation/optional/media_graphics_packages.md`](optional/media_graphics_packages.md):
	* ImageMagick
	* ffmpeg
	* exiftool

	=== "Alpine"
	```
	echo "http://nl.alpinelinux.org/alpine/latest-stable/community" >> /etc/apk/repositories
	apk update
	apk add imagemagick ffmpeg exiftool
	```

	=== "Debian/Ubuntu"
	```
	apt install imagemagick ffmpeg libimage-exiftool-perl
	```

	## Setup
	### Configuring PostgreSQL
	#### (Optional) Installing RUM indexes

	!!! warning
	It is recommended to use PostgreSQL v11 or newer. We have seen some minor issues with lower PostgreSQL versions.

	RUM indexes are an alternative indexing scheme that is not included in PostgreSQL by default. You can read more about them on the [Configuration page](../configuration/cheatsheet.md#rum-indexing-for-full-text-search). They are completely optional and most of the time are not worth it, especially if you are running a single user instance (unless you absolutely need ordered search results).

	=== "Alpine"
	```
	apk add git build-base postgresql-dev
	git clone https://github.com/postgrespro/rum /tmp/rum
	cd /tmp/rum
	make USE_PGXS=1
	make USE_PGXS=1 install
	cd
	rm -r /tmp/rum
	```

	=== "Debian/Ubuntu"
	```
	# Available only on Buster/19.04
	apt install postgresql-11-rum
	```

	#### (Optional) Performance configuration
	It is encouraged to check [Optimizing your PostgreSQL performance](../configuration/postgresql.md) document, for tips on PostgreSQL tuning.

	=== "Alpine"
	```
	rc-service postgresql restart
	```

	=== "Debian/Ubuntu"
	```
	systemctl restart postgresql
	```

	If you are using PostgreSQL 12 or higher, add this to your Ecto database configuration

	```elixir
	#
	config :pleroma, Pleroma.Repo,
	prepare: :named,
	parameters: [
	plan_cache_mode: "force_custom_plan"
	]
	```

	### Installing Pleroma
	```sh
	# Create a Pleroma user
	adduser --system --shell /bin/false --home /opt/pleroma pleroma

	# Set the flavour environment variable to the string you got in Detecting flavour section.
	# For example if the flavour is `amd64-musl` the command will be
	export FLAVOUR="amd64-musl"

	# Clone the release build into a temporary directory and unpack it
	su pleroma -s $SHELL -lc "
	curl 'https://git.pleroma.social/api/v4/projects/2/jobs/artifacts/stable/download?job=$FLAVOUR' -o /tmp/pleroma.zip
	unzip /tmp/pleroma.zip -d /tmp/
	"

	# Move the release to the home directory and delete temporary files
	su pleroma -s $SHELL -lc "
	mv /tmp/release/* /opt/pleroma
	rmdir /tmp/release
	rm /tmp/pleroma.zip
	"
	# Create uploads directory and set proper permissions (skip if planning to use a remote uploader)
	# Note: It does not have to be `/var/lib/pleroma/uploads`, the config generator will ask about the upload directory later

	mkdir -p /var/lib/pleroma/uploads
	chown -R pleroma /var/lib/pleroma

	# Create custom public files directory (custom emojis, frontend bundle overrides, robots.txt, etc.)
	# Note: It does not have to be `/var/lib/pleroma/static`, the config generator will ask about the custom public files directory later
	mkdir -p /var/lib/pleroma/static
	chown -R pleroma /var/lib/pleroma

	# Create a config directory
	mkdir -p /etc/pleroma
	chown -R pleroma /etc/pleroma

	# Run the config generator
	su pleroma -s $SHELL -lc "./bin/pleroma_ctl instance gen --output /etc/pleroma/config.exs --output-psql /tmp/setup_db.psql"

	-# Run the environment file generator.
	-su pleroma -s $SHELL -lc "./bin/pleroma_ctl release_env gen"
	-
	# Create the postgres database
	su postgres -s $SHELL -lc "psql -f /tmp/setup_db.psql"

	# Create the database schema
	su pleroma -s $SHELL -lc "./bin/pleroma_ctl migrate"

	# If you have installed RUM indexes uncommend and run
	# su pleroma -s $SHELL -lc "./bin/pleroma_ctl migrate --migrations-path priv/repo/optional_migrations/rum_indexing/"

	# Start the instance to verify that everything is working as expected
	su pleroma -s $SHELL -lc "export $(cat /opt/pleroma/config/pleroma.env); ./bin/pleroma daemon"

	# Wait for about 20 seconds and query the instance endpoint, if it shows your uri, name and email correctly, you are configured correctly
	sleep 20 && curl http://localhost:4000/api/v1/instance

	# Stop the instance
	su pleroma -s $SHELL -lc "./bin/pleroma stop"
	```

	### Setting up nginx and getting Let's Encrypt SSL certificaties

	#### Get a Let's Encrypt certificate
	```sh
	certbot certonly --standalone --preferred-challenges http -d yourinstance.tld
	```

	#### Copy Pleroma nginx configuration to the nginx folder

	The location of nginx configs is dependent on the distro

	=== "Alpine"
	```
	cp /opt/pleroma/installation/pleroma.nginx /etc/nginx/conf.d/pleroma.conf
	```

	=== "Debian/Ubuntu"
	```
	cp /opt/pleroma/installation/pleroma.nginx /etc/nginx/sites-available/pleroma.conf
	ln -s /etc/nginx/sites-available/pleroma.conf /etc/nginx/sites-enabled/pleroma.conf
	```

	If your distro does not have either of those you can append `include /etc/nginx/pleroma.conf` to the end of the http section in /etc/nginx/nginx.conf and
	```sh
	cp /opt/pleroma/installation/pleroma.nginx /etc/nginx/pleroma.conf
	```

	#### Edit the nginx config
	```sh
	# Replace example.tld with your (sub)domain
	$EDITOR path-to-nginx-config

	# Verify that the config is valid
	nginx -t
	```
	#### Start nginx

	=== "Alpine"
	```
	rc-service nginx start
	```

	=== "Debian/Ubuntu"
	```
	systemctl start nginx
	```

	At this point if you open your (sub)domain in a browser you should see a 502 error, that's because Pleroma is not started yet.

	### Setting up a system service

	=== "Alpine"
	```
	# Copy the service into a proper directory
	cp /opt/pleroma/installation/init.d/pleroma /etc/init.d/pleroma

	# Start pleroma and enable it on boot
	rc-service pleroma start
	rc-update add pleroma
	```

	=== "Debian/Ubuntu"
	```
	# Copy the service into a proper directory
	cp /opt/pleroma/installation/pleroma.service /etc/systemd/system/pleroma.service

	# Start pleroma and enable it on boot
	systemctl start pleroma
	systemctl enable pleroma
	```

	If everything worked, you should see Pleroma-FE when visiting your domain. If that didn't happen, try reviewing the installation steps, starting Pleroma in the foreground and seeing if there are any errrors.

	Still doesn't work? Feel free to contact us on [#pleroma on freenode](https://irc.pleroma.social) or via matrix at <https://matrix.heldscal.la/#/room/#freenode_#pleroma:matrix.org>, you can also [file an issue on our Gitlab](https://git.pleroma.social/pleroma/pleroma-support/issues/new)

	## Post installation

	### Setting up auto-renew of the Let's Encrypt certificate
	```sh
	# Create the directory for webroot challenges
	mkdir -p /var/lib/letsencrypt

	# Uncomment the webroot method
	$EDITOR path-to-nginx-config

	# Verify that the config is valid
	nginx -t
	```

	=== "Alpine"
	```
	# Restart nginx
	rc-service nginx restart

	# Start the cron daemon and make it start on boot
	rc-service crond start
	rc-update add crond

	# Ensure the webroot menthod and post hook is working
	certbot renew --cert-name yourinstance.tld --webroot -w /var/lib/letsencrypt/ --dry-run --post-hook 'rc-service nginx reload'

	# Add it to the daily cron
	echo '#!/bin/sh
	certbot renew --cert-name yourinstance.tld --webroot -w /var/lib/letsencrypt/ --post-hook "rc-service nginx reload"
	' > /etc/periodic/daily/renew-pleroma-cert
	chmod +x /etc/periodic/daily/renew-pleroma-cert

	# If everything worked the output should contain /etc/cron.daily/renew-pleroma-cert
	run-parts --test /etc/periodic/daily
	```

	=== "Debian/Ubuntu"
	```
	# Restart nginx
	systemctl restart nginx

	# Ensure the webroot menthod and post hook is working
	certbot renew --cert-name yourinstance.tld --webroot -w /var/lib/letsencrypt/ --dry-run --post-hook 'systemctl reload nginx'

	# Add it to the daily cron
	echo '#!/bin/sh
	certbot renew --cert-name yourinstance.tld --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"
	' > /etc/cron.daily/renew-pleroma-cert
	chmod +x /etc/cron.daily/renew-pleroma-cert

	# If everything worked the output should contain /etc/cron.daily/renew-pleroma-cert
	run-parts --test /etc/cron.daily
	```

	## Create your first user and set as admin
	```sh
	cd /opt/pleroma/bin
	su pleroma -s $SHELL -lc "./bin/pleroma_ctl user new joeuser joeuser@sld.tld --admin"
	```
	This will create an account withe the username of 'joeuser' with the email address of joeuser@sld.tld, and set that user's account as an admin. This will result in a link that you can paste into the browser, which logs you in and enables you to set the password.

	## Further reading

	{! backend/installation/further_reading.include !}

	## Questions

	Questions about the installation or didn’t it work as it should be, ask in [#pleroma:matrix.org](https://matrix.heldscal.la/#/room/#freenode_#pleroma:matrix.org) or IRC Channel #pleroma on Freenode.
	diff --git a/installation/init.d/pleroma b/installation/init.d/pleroma
	index e908cda1b..384536f7e 100755
	--- a/installation/init.d/pleroma
	+++ b/installation/init.d/pleroma
	@@ -1,46 +1,45 @@
	#!/sbin/openrc-run
	supervisor=supervise-daemon
	command_user=pleroma:pleroma
	command_background=1
	# Ask process to terminate within 30 seconds, otherwise kill it
	retry="SIGTERM/30/SIGKILL/5"
	pidfile="/var/run/pleroma.pid"
	directory=/opt/pleroma
	healthcheck_delay=60
	healthcheck_timer=30
	-export $(cat /opt/pleroma/config/pleroma.env)

	: ${pleroma_port:-4000}

	# Needs OpenRC >= 0.42
	#respawn_max=0
	#respawn_delay=5

	# put pleroma_console=YES in /etc/conf.d/pleroma if you want to be able to
	# connect to pleroma via an elixir console
	if yesno "${pleroma_console}"; then
	command=elixir
	command_args="--name pleroma@127.0.0.1 --erl '-kernel inet_dist_listen_min 9001 inet_dist_listen_max 9001 inet_dist_use_interface {127,0,0,1}' -S mix phx.server"

	start_post() {
	einfo "You can get a console by using this command as pleroma's user:"
	einfo "iex --name console@127.0.0.1 --remsh pleroma@127.0.0.1"
	}
	else
	command=/usr/bin/mix
	command_args="phx.server"
	fi

	export MIX_ENV=prod

	depend() {
	need nginx postgresql
	}

	healthcheck() {
	# put pleroma_health=YES in /etc/conf.d/pleroma if you want healthchecking
	# and make sure you have curl installed
	yesno "$pleroma_health" \|\| return 0

	curl -q "localhost:${pleroma_port}/api/pleroma/healthcheck"
	}
	diff --git a/installation/pleroma.service b/installation/pleroma.service
	index 63e83ed6e..8338228d8 100644
	--- a/installation/pleroma.service
	+++ b/installation/pleroma.service
	@@ -1,38 +1,36 @@
	[Unit]
	Description=Pleroma social network
	After=network.target postgresql.service

	[Service]
	ExecReload=/bin/kill $MAINPID
	KillMode=process
	Restart=on-failure

	; Name of the user that runs the Pleroma service.
	User=pleroma
	; Declares that Pleroma runs in production mode.
	Environment="MIX_ENV=prod"

	; Make sure that all paths fit your installation.
	; Path to the home directory of the user running the Pleroma service.
	Environment="HOME=/var/lib/pleroma"
	; Path to the folder containing the Pleroma installation.
	WorkingDirectory=/opt/pleroma
	-; Path to the environment file. the file contains RELEASE_COOKIE and etc
	-EnvironmentFile=/opt/pleroma/config/pleroma.env
	; Path to the Mix binary.
	ExecStart=/usr/bin/mix phx.server

	; Some security directives.
	; Use private /tmp and /var/tmp folders inside a new file system namespace, which are discarded after the process stops.
	PrivateTmp=true
	; The /home, /root, and /run/user folders can not be accessed by this service anymore. If your Pleroma user has its home folder in one of the restricted places, or use one of these folders as its working directory, you have to set this to false.
	ProtectHome=true
	; Mount /usr, /boot, and /etc as read-only for processes invoked by this service.
	ProtectSystem=full
	; Sets up a new /dev mount for the process and only adds API pseudo devices like /dev/null, /dev/zero or /dev/random but not physical devices. Disabled by default because it may not work on devices like the Raspberry Pi.
	PrivateDevices=false
	; Drops the sysadmin capability from the daemon.
	CapabilityBoundingSet=~CAP_SYS_ADMIN

	[Install]
	WantedBy=multi-user.target
	diff --git a/lib/mix/tasks/pleroma/instance.ex b/lib/mix/tasks/pleroma/instance.ex
	index 1915aacd9..fc21ae062 100644
	--- a/lib/mix/tasks/pleroma/instance.ex
	+++ b/lib/mix/tasks/pleroma/instance.ex
	@@ -1,330 +1,310 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Instance do
	use Mix.Task
	import Mix.Pleroma

	alias Pleroma.Config

	@shortdoc "Manages Pleroma instance"
	@moduledoc File.read!("docs/administration/CLI_tasks/instance.md")

	def run(["gen" \| rest]) do
	{options, [], []} =
	OptionParser.parse(
	rest,
	strict: [
	force: :boolean,
	output: :string,
	output_psql: :string,
	domain: :string,
	instance_name: :string,
	admin_email: :string,
	notify_email: :string,
	dbhost: :string,
	dbname: :string,
	dbuser: :string,
	dbpass: :string,
	rum: :string,
	indexable: :string,
	db_configurable: :string,
	uploads_dir: :string,
	static_dir: :string,
	listen_ip: :string,
	listen_port: :string,
	strip_uploads: :string,
	anonymize_uploads: :string,
	- dedupe_uploads: :string,
	- skip_release_env: :boolean,
	- release_env_file: :string
	+ dedupe_uploads: :string
	],
	aliases: [
	o: :output,
	f: :force
	]
	)

	paths =
	[config_path, psql_path] = [
	Keyword.get(options, :output, "config/generated_config.exs"),
	Keyword.get(options, :output_psql, "config/setup_db.psql")
	]

	will_overwrite = Enum.filter(paths, &File.exists?/1)
	proceed? = Enum.empty?(will_overwrite) or Keyword.get(options, :force, false)

	if proceed? do
	[domain, port \| _] =
	String.split(
	get_option(
	options,
	:domain,
	"What domain will your instance use? (e.g pleroma.soykaf.com)"
	),
	":"
	) ++ [443]

	name =
	get_option(
	options,
	:instance_name,
	"What is the name of your instance? (e.g. The Corndog Emporium)",
	domain
	)

	email = get_option(options, :admin_email, "What is your admin email address?")

	notify_email =
	get_option(
	options,
	:notify_email,
	"What email address do you want to use for sending email notifications?",
	email
	)

	indexable =
	get_option(
	options,
	:indexable,
	"Do you want search engines to index your site? (y/n)",
	"y"
	) === "y"

	db_configurable? =
	get_option(
	options,
	:db_configurable,
	"Do you want to store the configuration in the database (allows controlling it from admin-fe)? (y/n)",
	"n"
	) === "y"

	dbhost = get_option(options, :dbhost, "What is the hostname of your database?", "localhost")

	dbname = get_option(options, :dbname, "What is the name of your database?", "pleroma")

	dbuser =
	get_option(
	options,
	:dbuser,
	"What is the user used to connect to your database?",
	"pleroma"
	)

	dbpass =
	get_option(
	options,
	:dbpass,
	"What is the password used to connect to your database?",
	:crypto.strong_rand_bytes(64) \|> Base.encode64() \|> binary_part(0, 64),
	"autogenerated"
	)

	rum_enabled =
	get_option(
	options,
	:rum,
	"Would you like to use RUM indices?",
	"n"
	) === "y"

	listen_port =
	get_option(
	options,
	:listen_port,
	"What port will the app listen to (leave it if you are using the default setup with nginx)?",
	4000
	)

	listen_ip =
	get_option(
	options,
	:listen_ip,
	"What ip will the app listen to (leave it if you are using the default setup with nginx)?",
	"127.0.0.1"
	)

	uploads_dir =
	get_option(
	options,
	:uploads_dir,
	"What directory should media uploads go in (when using the local uploader)?",
	Config.get([Pleroma.Uploaders.Local, :uploads])
	)
	\|> Path.expand()

	static_dir =
	get_option(
	options,
	:static_dir,
	"What directory should custom public files be read from (custom emojis, frontend bundle overrides, robots.txt, etc.)?",
	Config.get([:instance, :static_dir])
	)
	\|> Path.expand()

	strip_uploads =
	get_option(
	options,
	:strip_uploads,
	"Do you want to strip location (GPS) data from uploaded images? (y/n)",
	"y"
	) === "y"

	anonymize_uploads =
	get_option(
	options,
	:anonymize_uploads,
	"Do you want to anonymize the filenames of uploads? (y/n)",
	"n"
	) === "y"

	dedupe_uploads =
	get_option(
	options,
	:dedupe_uploads,
	"Do you want to deduplicate uploaded files? (y/n)",
	"n"
	) === "y"

	Config.put([:instance, :static_dir], static_dir)

	secret = :crypto.strong_rand_bytes(64) \|> Base.encode64() \|> binary_part(0, 64)
	jwt_secret = :crypto.strong_rand_bytes(64) \|> Base.encode64() \|> binary_part(0, 64)
	signing_salt = :crypto.strong_rand_bytes(8) \|> Base.encode64() \|> binary_part(0, 8)
	{web_push_public_key, web_push_private_key} = :crypto.generate_key(:ecdh, :prime256v1)
	template_dir = Application.app_dir(:pleroma, "priv") <> "/templates"

	result_config =
	EEx.eval_file(
	template_dir <> "/sample_config.eex",
	domain: domain,
	port: port,
	email: email,
	notify_email: notify_email,
	name: name,
	dbhost: dbhost,
	dbname: dbname,
	dbuser: dbuser,
	dbpass: dbpass,
	secret: secret,
	jwt_secret: jwt_secret,
	signing_salt: signing_salt,
	web_push_public_key: Base.url_encode64(web_push_public_key, padding: false),
	web_push_private_key: Base.url_encode64(web_push_private_key, padding: false),
	db_configurable?: db_configurable?,
	static_dir: static_dir,
	uploads_dir: uploads_dir,
	rum_enabled: rum_enabled,
	listen_ip: listen_ip,
	listen_port: listen_port,
	upload_filters:
	upload_filters(%{
	strip: strip_uploads,
	anonymize: anonymize_uploads,
	dedupe: dedupe_uploads
	})
	)

	result_psql =
	EEx.eval_file(
	template_dir <> "/sample_psql.eex",
	dbname: dbname,
	dbuser: dbuser,
	dbpass: dbpass,
	rum_enabled: rum_enabled
	)

	shell_info("Writing config to #{config_path}.")

	File.write(config_path, result_config)
	shell_info("Writing the postgres script to #{psql_path}.")
	File.write(psql_path, result_psql)

	write_robots_txt(static_dir, indexable, template_dir)

	- if Keyword.get(options, :skip_release_env, false) do
	- shell_info("""
	- Release environment file is skip. Please generate the release env file before start.
	- `MIX_ENV=#{Mix.env()} mix pleroma.release_env gen`
	- """)
	- else
	- shell_info("Generation the environment file:")
	-
	- release_env_args =
	- with path when not is_nil(path) <- Keyword.get(options, :release_env_file) do
	- ["gen", "--path", path]
	- else
	- _ -> ["gen"]
	- end
	-
	- Mix.Tasks.Pleroma.ReleaseEnv.run(release_env_args)
	- end
	-
	shell_info(
	"\n All files successfully written! Refer to the installation instructions for your platform for next steps."
	)

	if db_configurable? do
	shell_info(
	" Please transfer your config to the database after running database migrations. Refer to \"Transfering the config to/from the database\" section of the docs for more information."
	)
	end
	else
	shell_error(
	"The task would have overwritten the following files:\n" <>
	(Enum.map(paths, &"- #{&1}\n") \|> Enum.join("")) <>
	"Rerun with `--force` to overwrite them."
	)
	end
	end

	defp write_robots_txt(static_dir, indexable, template_dir) do
	robots_txt =
	EEx.eval_file(
	template_dir <> "/robots_txt.eex",
	indexable: indexable
	)

	unless File.exists?(static_dir) do
	File.mkdir_p!(static_dir)
	end

	robots_txt_path = Path.join(static_dir, "robots.txt")

	if File.exists?(robots_txt_path) do
	File.cp!(robots_txt_path, "#{robots_txt_path}.bak")
	shell_info("Backing up existing robots.txt to #{robots_txt_path}.bak")
	end

	File.write(robots_txt_path, robots_txt)
	shell_info("Writing #{robots_txt_path}.")
	end

	defp upload_filters(filters) when is_map(filters) do
	enabled_filters =
	if filters.strip do
	[Pleroma.Upload.Filter.ExifTool]
	else
	[]
	end

	enabled_filters =
	if filters.anonymize do
	enabled_filters ++ [Pleroma.Upload.Filter.AnonymizeFilename]
	else
	enabled_filters
	end

	enabled_filters =
	if filters.dedupe do
	enabled_filters ++ [Pleroma.Upload.Filter.Dedupe]
	else
	enabled_filters
	end

	enabled_filters
	end

	defp upload_filters(_), do: []
	end
	diff --git a/lib/mix/tasks/pleroma/release_env.ex b/lib/mix/tasks/pleroma/release_env.ex
	deleted file mode 100644
	index 9da74ffcf..000000000
	--- a/lib/mix/tasks/pleroma/release_env.ex
	+++ /dev/null
	@@ -1,76 +0,0 @@
	-# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	-# SPDX-License-Identifier: AGPL-3.0-only
	-
	-defmodule Mix.Tasks.Pleroma.ReleaseEnv do
	- use Mix.Task
	- import Mix.Pleroma
	-
	- @shortdoc "Generate Pleroma environment file."
	- @moduledoc File.read!("docs/administration/CLI_tasks/release_environments.md")
	-
	- def run(["gen" \| rest]) do
	- {options, [], []} =
	- OptionParser.parse(
	- rest,
	- strict: [
	- force: :boolean,
	- path: :string
	- ],
	- aliases: [
	- p: :path,
	- f: :force
	- ]
	- )
	-
	- file_path =
	- get_option(
	- options,
	- :path,
	- "Environment file path",
	- "./config/pleroma.env"
	- )
	-
	- env_path = Path.expand(file_path)
	-
	- proceed? =
	- if File.exists?(env_path) do
	- get_option(
	- options,
	- :force,
	- "Environment file already exists. Do you want to overwrite the #{env_path} file? (y/n)",
	- "n"
	- ) === "y"
	- else
	- true
	- end
	-
	- if proceed? do
	- case do_generate(env_path) do
	- {:error, reason} ->
	- shell_error(
	- File.Error.message(%{action: "write to file", reason: reason, path: env_path})
	- )
	-
	- _ ->
	- shell_info("\nThe file generated: #{env_path}.\n")
	-
	- shell_info("""
	- WARNING: before start pleroma app please make sure to make the file read-only and non-modifiable.
	- Example:
	- chmod 0444 #{file_path}
	- chattr +i #{file_path}
	- """)
	- end
	- else
	- shell_info("\nThe file is exist. #{env_path}.\n")
	- end
	- end
	-
	- def do_generate(path) do
	- content = "RELEASE_COOKIE=#{Base.encode32(:crypto.strong_rand_bytes(32))}"
	-
	- File.mkdir_p!(Path.dirname(path))
	- File.write(path, content)
	- end
	-end
	diff --git a/test/mix/tasks/pleroma/instance_test.exs b/test/mix/tasks/pleroma/instance_test.exs
	index fe69a2def..8a02710ee 100644
	--- a/test/mix/tasks/pleroma/instance_test.exs
	+++ b/test/mix/tasks/pleroma/instance_test.exs
	@@ -1,108 +1,99 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.InstanceTest do
	use ExUnit.Case

	- @release_env_file "./test/pleroma.test.env"
	-
	setup do
	File.mkdir_p!(tmp_path())

	on_exit(fn ->
	File.rm_rf(tmp_path())
	static_dir = Pleroma.Config.get([:instance, :static_dir], "test/instance_static/")

	if File.exists?(static_dir) do
	File.rm_rf(Path.join(static_dir, "robots.txt"))
	end

	- if File.exists?(@release_env_file), do: File.rm_rf(@release_env_file)
	-
	Pleroma.Config.put([:instance, :static_dir], static_dir)
	end)

	:ok
	end

	defp tmp_path do
	"/tmp/generated_files/"
	end

	test "running gen" do
	mix_task = fn ->
	Mix.Tasks.Pleroma.Instance.run([
	"gen",
	"--output",
	tmp_path() <> "generated_config.exs",
	"--output-psql",
	tmp_path() <> "setup.psql",
	"--domain",
	"test.pleroma.social",
	"--instance-name",
	"Pleroma",
	"--admin-email",
	"admin@example.com",
	"--notify-email",
	"notify@example.com",
	"--dbhost",
	"dbhost",
	"--dbname",
	"dbname",
	"--dbuser",
	"dbuser",
	"--dbpass",
	"dbpass",
	"--indexable",
	"y",
	"--db-configurable",
	"y",
	"--rum",
	"y",
	"--listen-port",
	"4000",
	"--listen-ip",
	"127.0.0.1",
	"--uploads-dir",
	"test/uploads",
	"--static-dir",
	"./test/../test/instance/static/",
	"--strip-uploads",
	"y",
	"--dedupe-uploads",
	"n",
	"--anonymize-uploads",
	- "n",
	- "--release-env-file",
	- @release_env_file
	+ "n"
	])
	end

	ExUnit.CaptureIO.capture_io(fn ->
	mix_task.()
	end)

	generated_config = File.read!(tmp_path() <> "generated_config.exs")
	assert generated_config =~ "host: \"test.pleroma.social\""
	assert generated_config =~ "name: \"Pleroma\""
	assert generated_config =~ "email: \"admin@example.com\""
	assert generated_config =~ "notify_email: \"notify@example.com\""
	assert generated_config =~ "hostname: \"dbhost\""
	assert generated_config =~ "database: \"dbname\""
	assert generated_config =~ "username: \"dbuser\""
	assert generated_config =~ "password: \"dbpass\""
	assert generated_config =~ "configurable_from_database: true"
	assert generated_config =~ "http: [ip: {127, 0, 0, 1}, port: 4000]"
	assert generated_config =~ "filters: [Pleroma.Upload.Filter.ExifTool]"
	assert File.read!(tmp_path() <> "setup.psql") == generated_setup_psql()
	assert File.exists?(Path.expand("./test/instance/static/robots.txt"))
	- assert File.exists?(@release_env_file)
	-
	- assert File.read!(@release_env_file) =~ ~r/^RELEASE_COOKIE=.*/
	end

	defp generated_setup_psql do
	~s(CREATE USER dbuser WITH ENCRYPTED PASSWORD 'dbpass';\nCREATE DATABASE dbname OWNER dbuser;\n\\c dbname;\n--Extensions made by ecto.migrate that need superuser access\nCREATE EXTENSION IF NOT EXISTS citext;\nCREATE EXTENSION IF NOT EXISTS pg_trgm;\nCREATE EXTENSION IF NOT EXISTS \"uuid-ossp\";\nCREATE EXTENSION IF NOT EXISTS rum;\n)
	end
	end
	diff --git a/test/mix/tasks/pleroma/release_env_test.exs b/test/mix/tasks/pleroma/release_env_test.exs
	deleted file mode 100644
	index 519f1eba9..000000000
	--- a/test/mix/tasks/pleroma/release_env_test.exs
	+++ /dev/null
	@@ -1,30 +0,0 @@
	-# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	-# SPDX-License-Identifier: AGPL-3.0-only
	-
	-defmodule Mix.Tasks.Pleroma.ReleaseEnvTest do
	- use ExUnit.Case
	- import ExUnit.CaptureIO, only: [capture_io: 1]
	-
	- @path "config/pleroma.test.env"
	-
	- def do_clean do
	- if File.exists?(@path) do
	- File.rm_rf(@path)
	- end
	- end
	-
	- setup do
	- do_clean()
	- on_exit(fn -> do_clean() end)
	- :ok
	- end
	-
	- test "generate pleroma.env" do
	- assert capture_io(fn ->
	- Mix.Tasks.Pleroma.ReleaseEnv.run(["gen", "--path", @path, "--force"])
	- end) =~ "The file generated"
	-
	- assert File.read!(@path) =~ "RELEASE_COOKIE="
	- end
	-end

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 14, 7:38 AM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 166783
Default Alt Text: (38 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions