Merge pull request #365 from wallabag/nicosomb-patch-1

Update Dockerfile for 2.6.4

.github/dependabot.yml

@@ -0,0 +1,14 @@
+version: 2
+updates:
+- package-ecosystem: docker
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "04:00"
+    timezone: Europe/Paris
+  open-pull-requests-limit: 10
+  ignore:
+  - dependency-name: alpine
+    versions:
+    - ">= 3.11.a"
+    - "< 3.12"

.github/workflows/publish.yml

@@ -0,0 +1,57 @@
+name: Publish Docker image
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  push_to_registries:
+    name: Push Docker image to multiple registries
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v3
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+          
+       # Documentation: https://github.com/docker/setup-qemu-action
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+        
+      # Documentation: https://github.com/docker/setup-buildx-action
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            wallabag/wallabag
+            ghcr.io/${{ github.repository }}
+
+      - name: Build and push Docker images
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          # Support for different platforms, see here: 
+          # https://github.com/docker/buildx/blob/master/docs/reference/buildx_build.md#-set-the-target-platforms-for-the-build---platform
+          platforms: linux/amd64,linux/arm64,linux/arm/v7

.github/workflows/test.yml

@@ -0,0 +1,51 @@
+name: "CI"
+
+on:
+  pull_request:
+    branches:
+      - "master"
+  push:
+    branches:
+      - "master"
+
+jobs:
+  test:
+    name: "Testing with database: ${{ matrix.database }}"
+    runs-on: "ubuntu-latest"
+
+    strategy:
+      fail-fast: false
+      matrix:
+        database:
+          - "default"
+          - "sqlite"
+          - "mariadb"
+          - "postgresql"
+
+    steps:
+      - name: "Checkout"
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 2
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.11
+
+      - name: "Build image"
+        run: docker-compose -f tests/docker-compose.${{ matrix.database }}.yml build
+
+      - name: "Install dependencies"
+        run: pip install pytest pytest-docker requests
+
+      - name: "Run tests"
+        run: py.test --database=${{ matrix.database }} tests/
+
+      - name: "Get docker logs"
+        if: ${{ always() }}
+        run: docker-compose -p "wallabag_${{ matrix.database }}" -f tests/docker-compose.${{ matrix.database }}.yml logs wallabag
+
+      - name: "Cleanup environment"
+        if: ${{ always() }}
+        run: docker-compose -p "wallabag_${{ matrix.database }}" -f tests/docker-compose.${{ matrix.database }}.yml down -v

.travis.yml

@@ -1,26 +0,0 @@
-language: python
-
-python:
-  - 3.5
-
-services:
-  - docker
-
-env:
-  - DB_TYPE=default
-  - DB_TYPE=sqlite
-  - DB_TYPE=mariadb
-  - DB_TYPE=postgresql
-
-install:
-  - docker-compose -f tests/docker-compose.$DB_TYPE.yml build
-  - docker-compose -f tests/docker-compose.$DB_TYPE.yml up -d
-
-before_script:
-  - pip install pytest
-  - pip install requests
-
-script:
-  - docker ps | grep -q wallabag
-  - sleep 60
-  - py.test tests/

Dockerfile

@@ -1,62 +1,86 @@
-FROM alpine:edge
-MAINTAINER Marvin Steadfast <marvin@xsteadfastx.org>
+ARG COMPOSER_VERSION=2.5.8
 
-ENV WALLABAG_VERSION=2.1.4 \
-    POSTGRES_USER=postgres
+FROM composer:$COMPOSER_VERSION as composer
 
-RUN echo "@testing http://dl-4.alpinelinux.org/alpine/edge/testing" >> /etc/apk/repositories \
- && apk add --update \
-      ansible \
+FROM golang:alpine as builder
+
+# envsubst from gettext can not replace env vars with default values
+# this package is not available for ARM32 and we have to build it from source code
+# flag -ldflags "-s -w" produces a smaller executable
+RUN go install -ldflags "-s -w" -v github.com/a8m/envsubst/cmd/envsubst@v1.3.0
+
+FROM alpine:3.18
+
+COPY --from=builder /go/bin/envsubst /usr/bin/envsubst
+
+ARG WALLABAG_VERSION=2.6.4
+
+RUN set -ex \
+ && apk add --no-cache \
       curl \
-      git \
-      libwebp@testing \
-      mariadb-client \
+      libwebp \
       nginx \
       pcre \
-      php7 \
-      php7-amqp@testing \
-      php7-bcmath \
-      php7-ctype@testing \
-      php7-curl@testing \
-      php7-dom@testing \
-      php7-fpm@testing \
-      php7-gd@testing \
-      php7-gettext@testing \
-      php7-iconv@testing \
-      php7-json@testing \
-      php7-mbstring@testing \
-      php7-openssl@testing \
-      php7-pdo_mysql@testing \
-      php7-pdo_pgsql@testing \
-      php7-pdo_sqlite@testing \
-      php7-phar@testing \
-      php7-session@testing \
-      php7-xml@testing \
-      php7@testing\
-      py-mysqldb \
-      py-psycopg2 \
-      py-simplejson \
+      php81 \
+      php81-bcmath \
+      php81-ctype \
+      php81-curl \
+      php81-dom \
+      php81-fpm \
+      php81-gd \
+      php81-gettext \
+      php81-iconv \
+      php81-json \
+      php81-mbstring \
+      php81-openssl \
+      php81-pecl-amqp \
+      php81-pdo_mysql \
+      php81-pdo_pgsql \
+      php81-pdo_sqlite \
+      php81-phar \
+      php81-session \
+      php81-simplexml \
+      php81-tokenizer \
+      php81-xml \
+      php81-zlib \
+      php81-sockets \
+      php81-xmlreader \
+      php81-tidy \
+      php81-intl \
+      php81-sodium \
+      mariadb-client \
+      postgresql14-client \
+      rabbitmq-c \
       s6 \
       tar \
- && rm -rf /var/cache/apk/*
-
-RUN ln -s /usr/bin/php7 /usr/bin/php \
+      tzdata \
+ && ln -sf /usr/bin/php81 /usr/bin/php \
+ && ln -sf /usr/sbin/php-fpm81 /usr/sbin/php-fpm \
+ && rm -rf /var/cache/apk/* \
  && ln -sf /dev/stdout /var/log/nginx/access.log \
  && ln -sf /dev/stderr /var/log/nginx/error.log
 
-RUN curl -s http://getcomposer.org/installer | php \
- && mv composer.phar /usr/local/bin/composer
-
-RUN git clone --branch $WALLABAG_VERSION --depth 1 https://github.com/wallabag/wallabag.git /var/www/wallabag
+COPY --from=composer /usr/bin/composer /usr/local/bin/composer
 
 COPY root /
 
-RUN cd /var/www/wallabag \
- && SYMFONY_ENV=prod composer install --no-dev -o --prefer-dist
+RUN set -ex \
+ && curl -L -o /tmp/wallabag.tar.gz https://github.com/wallabag/wallabag/archive/$WALLABAG_VERSION.tar.gz \
+ && tar xvf /tmp/wallabag.tar.gz -C /tmp \
+ && mkdir /var/www/wallabag \
+ && mv /tmp/wallabag-*/* /var/www/wallabag/ \
+ && rm -rf /tmp/wallabag* \
+ && cd /var/www/wallabag \
+ && mkdir data/assets \
+ && envsubst < /etc/wallabag/parameters.template.yml > app/config/parameters.yml \
+ && SYMFONY_ENV=prod composer install --no-dev -o --prefer-dist --no-progress \
+ && rm -rf /root/.composer/* /var/www/wallabag/var/cache/* /var/www/wallabag/var/logs/* /var/www/wallabag/var/sessions/* \
+ && chown -R nobody:nobody /var/www/wallabag
 
-RUN chown -R nobody:nobody /var/www/wallabag
+ENV PATH="${PATH}:/var/www/wallabag/bin"
 
-RUN chmod +x /entrypoint.sh
+# Set console entry path
+WORKDIR /var/www/wallabag
 
 EXPOSE 80
 ENTRYPOINT ["/entrypoint.sh"]

README.md

@@ -1,6 +1,6 @@
 # What is wallabag?
 
-[![Build Status](https://travis-ci.org/wallabag/docker.svg?branch=master)](https://travis-ci.org/wallabag/docker)
+![CI](https://github.com/wallabag/docker/workflows/CI/badge.svg)
 [![Docker Stars](https://img.shields.io/docker/stars/wallabag/wallabag.svg?maxAge=2592000)](https://hub.docker.com/r/wallabag/wallabag/)
 [![Docker Pulls](https://img.shields.io/docker/pulls/wallabag/wallabag.svg?maxAge=2592000)](https://hub.docker.com/r/wallabag/wallabag/)
 
@@ -15,7 +15,7 @@ Default login is `wallabag:wallabag`.
 ## Environment variables
 
 - `-e MYSQL_ROOT_PASSWORD=...` (needed for the mariadb container to initialise and for the entrypoint in the wallabag container to create a database and user if its not there)
-- `-e POSTGRES_PASSWORD=...` (needed for the posgres container to initialise and for the entrypoint in the wallabag container to create a database and user if not there)
+- `-e POSTGRES_PASSWORD=...` (needed for the postgres container to initialise and for the entrypoint in the wallabag container to create a database and user if not there)
 - `-e POSTGRES_USER=...` (needed for the posgres container to initialise and for the entrypoint in the wallabag container to create a database and user if not there)
 - `-e SYMFONY__ENV__DATABASE_DRIVER=...` (defaults to "pdo_sqlite", this sets the database driver to use)
 - `-e SYMFONY__ENV__DATABASE_HOST=...` (defaults to "127.0.0.1", if use mysql this should be the name of the mariadb container)
@@ -23,25 +23,37 @@ Default login is `wallabag:wallabag`.
 - `-e SYMFONY__ENV__DATABASE_NAME=...`(defaults to "symfony", this is the name of the database to use)
 - `-e SYMFONY__ENV__DATABASE_USER=...` (defaults to "root", this is the name of the database user to use)
 - `-e SYMFONY__ENV__DATABASE_PASSWORD=...` (defaults to "~", this is the password of the database user to use)
+- `-e SYMFONY__ENV__DATABASE_CHARSET=...` (defaults to utf8, this is the database charset to use)
+- `-e SYMFONY__ENV__DATABASE_TABLE_PREFIX=...` (defaults to "wallabag_". Specifies the prefix for each database table)
 - `-e SYMFONY__ENV__SECRET=...` (defaults to "ovmpmAWXRCabNlMgzlzFXDYmCFfzGv")
-- `-e SYMFONY__ENV__MAILER_HOST=...`  defaults to "127.0.0.1", the SMTP host)
-- `-e SYMFONY__ENV__MAILER_USER=...` (defaults to "~", the SMTP user)
-- `-e SYMFONY__ENV__MAILER_PASSWORD=...`(defaults to "~", the SMTP password)
-- `-e SYMFONY__ENV__FROM_EMAIL=...`(defaults to "wallabag@example.com", the address wallabag uses for outgoing emails)
+- `-e SYMFONY__ENV__LOCALE=...` (default to en)
+- `-e SYMFONY__ENV__MAILER_DSN=...`  (defaults to "smtp://127.0.0.1")
+- `-e SYMFONY__ENV__FROM_EMAIL=...`(defaults to "`wallabag@example.com`", the address wallabag uses for outgoing emails)
+- `-e SYMFONY__ENV__TWOFACTOR_SENDER=...` (defaults to "`no-reply@wallabag.org`", the address wallabag uses for two-factor emails)
 - `-e SYMFONY__ENV__FOSUSER_REGISTRATION=...`(defaults to "true", enable or disable public user registration)
+- `-e SYMFONY__ENV__FOSUSER_CONFIRMATION=...`(defaults to "true", enable or disable registration confirmation)
+- `-e SYMFONY__ENV__DOMAIN_NAME=...`  defaults to "`https://your-wallabag-instance.wallabag.org`", the URL of your wallabag instance)
+- `-e SYMFONY__ENV__REDIS_SCHEME=...` (defaults to "tcp", protocol to use to communicate with the target server (tcp, unix, or http))
+- `-e SYMFONY__ENV__REDIS_HOST=...` (defaults to "redis", IP or hostname of the target server)
+- `-e SYMFONY__ENV__REDIS_PORT=...` (defaults to "6379", port of the target host)
+- `-e SYMFONY__ENV__REDIS_PATH=...`(defaults to "~", path of the unix socket file)
+- `-e SYMFONY__ENV__REDIS_PASSWORD=...` (defaults to "~", this is the password defined in the Redis server configuration)
+- `-e SYMFONY__ENV__SENTRY_DSN=...` (defaults to "~", this is the data source name for sentry)
+- `-e POPULATE_DATABASE=...`(defaults to "True". Does the DB has to be populated or is it an existing one)
+- `-e SYMFONY__ENV__SERVER_NAME=...` (defaults to "Your wallabag instance". Specifies a user-friendly name for the 2FA issuer)
 
 ## SQLite
 
 The easiest way to start wallabag is to use the SQLite backend. You can spin that up with
 
 ```
-$ docker run -p 80:80 wallabag/wallabag
+$ docker run -p 80:80 -e "SYMFONY__ENV__DOMAIN_NAME=http://localhost" wallabag/wallabag
 ```
 
-and point your browser to `http://localhost:80`. For persistent storage you should start the container with a volume:
+and point your browser to `http://localhost`. For persistent storage you should start the container with a volume:
 
 ```
-$ docker run -v /opt/wallabag:/var/www/wallabag/data -p 80:80 wallabag/wallabag
+$ docker run -v /opt/wallabag/data:/var/www/wallabag/data -v /opt/wallabag/images:/var/www/wallabag/web/assets/images -p 80:80 -e "SYMFONY__ENV__DOMAIN_NAME=http://localhost" wallabag/wallabag
 ```
 
 ## MariaDB / MySQL
@@ -50,7 +62,7 @@ For using MariaDB or MySQL you have to define some environment variables with th
 
 ```
 $ docker run --name wallabag-db -e "MYSQL_ROOT_PASSWORD=my-secret-pw" -d mariadb
-$ docker run --name wallabag --link wallabag-db:wallabag-db -e "MYSQL_ROOT_PASSWORD=my-secret-pw" -e "SYMFONY__ENV__DATABASE_DRIVER=pdo_mysql" -e "SYMFONY__ENV__DATABASE_HOST=wallabag-db" -e "SYMFONY__ENV__DATABASE_PORT=3306" -e "SYMFONY__ENV__DATABASE_NAME=wallabag" -e "SYMFONY__ENV__DATABASE_USER=wallabag" -e "SYMFONY__ENV__DATABASE_PASSWORD=wallapass" -p 80:80 wallabag/wallabag
+$ docker run --name wallabag --link wallabag-db:wallabag-db -e "MYSQL_ROOT_PASSWORD=my-secret-pw" -e "SYMFONY__ENV__DATABASE_DRIVER=pdo_mysql" -e "SYMFONY__ENV__DATABASE_HOST=wallabag-db" -e "SYMFONY__ENV__DATABASE_PORT=3306" -e "SYMFONY__ENV__DATABASE_NAME=wallabag" -e "SYMFONY__ENV__DATABASE_USER=wallabag" -e "SYMFONY__ENV__DATABASE_PASSWORD=wallapass" -e "SYMFONY__ENV__DATABASE_CHARSET=utf8mb4" -e "SYMFONY__ENV__DOMAIN_NAME=http://localhost" -p 80:80 wallabag/wallabag
 ```
 
 ## PostgreSQL
@@ -58,33 +70,45 @@ $ docker run --name wallabag --link wallabag-db:wallabag-db -e "MYSQL_ROOT_PASSW
 For using PostgreSQL you have to define some environment variables with the container. Example:
 
 ```
-$ docker run --name wallabag-db -e "POSTGRES_PASSWORD=my-secret-pw" -e "POSTGRES_USER=my-super-user" -d postgres
-$ docker run --name wallabag --link wallabag-db:wallabag-db -e "POSTGRES_PASSWORD=my-secret-pw" -e "POSTGRES_USER=my-super-user" -e "SYMFONY__ENV__DATABASE_DRIVER=pdo_pgsql" -e "SYMFONY__ENV__DATABASE_HOST=wallabag-db" -e "SYMFONY__ENV__DATABASE_PORT=5432" -e "SYMFONY__ENV__DATABASE_NAME=wallabag" -e "SYMFONY__ENV__DATABASE_USER=wallabag" -e "SYMFONY__ENV__DATABASE_PASSWORD=wallapass" -p 80:80 wallabag/wallabag
+$ docker run --name wallabag-db -e "POSTGRES_PASSWORD=my-secret-pw" -e "POSTGRES_USER=my-super-user" -d postgres:9.6
+$ docker run --name wallabag --link wallabag-db:wallabag-db -e "POSTGRES_PASSWORD=my-secret-pw" -e "POSTGRES_USER=my-super-user" -e "SYMFONY__ENV__DATABASE_DRIVER=pdo_pgsql" -e "SYMFONY__ENV__DATABASE_HOST=wallabag-db" -e "SYMFONY__ENV__DATABASE_PORT=5432" -e "SYMFONY__ENV__DATABASE_NAME=wallabag" -e "SYMFONY__ENV__DATABASE_USER=wallabag" -e "SYMFONY__ENV__DATABASE_PASSWORD=wallapass" -e "SYMFONY__ENV__DOMAIN_NAME=http://localhost" -p 80:80 wallabag/wallabag
 ```
 
 ## Redis
 
-To use redis support a linked redis container with the name `redis` is needed.
+To use redis with a Docker link, a redis container with the name `redis` is needed and none of the `REDIS` environmental variables are needed:
 
  ```
 $ docker run -p 6379:6379 --name redis redis:alpine
-$ docker run -p 80:80 --link redis:redis wallabag/wallabag
+$ docker run -p 80:80 -e "SYMFONY__ENV__DOMAIN_NAME=http://localhost" --link redis:redis wallabag/wallabag
 ```
 
-## DB migration
-
-If there is a version upgrade that needs a database migration, you should start the container with the new image and run the migration command.
+To use redis with an external redis host, set the appropriate environmental variables. Example:
 
 ```
-$ docker exec -t wallabag /var/www/wallabag/bin/console doctrine:migrations:migrate --env=prod --no-interaction
+$ docker run -p 80:80 -e "SYMFONY__ENV__REDIS_HOST=my.server.hostname" -e "SYMFONY__ENV__REDIS_PASSWORD=my-secret-pw" -e "SYMFONY__ENV__DOMAIN_NAME=http://localhost" wallabag/wallabag
+```
+
+## Upgrading
+
+If there is a version upgrade that needs a database migration. The most easy way to do is running the `migrate` command:
+
+```
+$ docker run --link wallabag-db:wallabag-db -e <... your config variables here ...>  wallabag/wallabag migrate
+```
+
+Or you can start the container with the new image and run the migration command manually:
+
+```
+$ docker exec -t NAME_OR_ID_OF_YOUR_WALLABAG_CONTAINER /var/www/wallabag/bin/console doctrine:migrations:migrate --env=prod --no-interaction
 ```
 
 ## docker-compose
 
-It's a good way to use [docker-compose](https://docs.docker.com/compose/). Example:
+An example [docker-compose](https://docs.docker.com/compose/) file can be seen below:
 
 ```
-version: '2'
+version: '3'
 services:
   wallabag:
     image: wallabag/wallabag
@@ -96,20 +120,39 @@ services:
       - SYMFONY__ENV__DATABASE_NAME=wallabag
       - SYMFONY__ENV__DATABASE_USER=wallabag
       - SYMFONY__ENV__DATABASE_PASSWORD=wallapass
-      - SYMFONY__ENV__MAILER_HOST=127.0.0.1
-      - SYMFONY__ENV__MAILER_USER=~
-      - SYMFONY__ENV__MAILER_PASSWORD=~
+      - SYMFONY__ENV__DATABASE_CHARSET=utf8mb4
+      - SYMFONY__ENV__DATABASE_TABLE_PREFIX="wallabag_"
+      - SYMFONY__ENV__MAILER_DSN=smtp://127.0.0.1
       - SYMFONY__ENV__FROM_EMAIL=wallabag@example.com
+      - SYMFONY__ENV__DOMAIN_NAME=https://your-wallabag-instance.wallabag.org
+      - SYMFONY__ENV__SERVER_NAME="Your wallabag instance"
     ports:
       - "80"
+    volumes:
+      - /opt/wallabag/images:/var/www/wallabag/web/assets/images
+    healthcheck:
+      test: ["CMD", "wget" ,"--no-verbose", "--tries=1", "--spider", "http://localhost"]
+      interval: 1m
+      timeout: 3s
+    depends_on:
+      - db
+      - redis
   db:
     image: mariadb
     environment:
       - MYSQL_ROOT_PASSWORD=wallaroot
     volumes:
-      - /opt/wallabag:/var/lib/mysql
+      - /opt/wallabag/data:/var/lib/mysql
+    healthcheck:
+      test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost"]
+      interval: 20s
+      timeout: 3s
   redis:
     image: redis:alpine
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 20s
+      timeout: 3s
 ```
 
 Note that you must fill out the mail related variables according to your mail config.
@@ -136,3 +179,11 @@ server {
 
 }
 ```
+
+## Import worker
+
+To run the [async redis import worker](https://doc.wallabag.org/en/admin/asynchronous.html#install-redis-for-asynchronous-tasks) use the following command:
+```
+$ docker run --name wallabag --link wallabag-db:wallabag-db --link redis:redis -e <... your config variables here ...>  wallabag/wallabag import <type>
+```
+Where `<type>` is one of pocket, readability, instapaper, wallabag_v1, wallabag_v2, firefox or chrome.

conftest.py

@@ -0,0 +1,4 @@
+import pytest
+
+def pytest_addoption(parser):
+    parser.addoption("--database", action="store", default="default")

root/entrypoint.sh

@@ -1,8 +1,107 @@
 #!/bin/sh
+# Exit when any command fails
+set -e
 
-if [ "$1" = "wallabag" ];then
-    ansible-playbook -i /etc/ansible/hosts /etc/ansible/entrypoint.yml -c local
+COMMAND_ARG1="$1"
+COMMAND_ARG2="$2"
+
+cd /var/www/wallabag || exit
+
+wait_for_database() {
+    timeout 60s /bin/sh -c "$(cat << EOF
+        until echo 'Waiting for database ...' \
+            && nc -z ${SYMFONY__ENV__DATABASE_HOST} ${SYMFONY__ENV__DATABASE_PORT} < /dev/null > /dev/null 2>&1 ; \
+        do sleep 1 ; done
+EOF
+)"
+}
+
+install_wallabag() {
+    su -c "php bin/console wallabag:install --env=prod -n" -s /bin/sh nobody
+}
+
+provisioner() {
+    SYMFONY__ENV__DATABASE_DRIVER=${SYMFONY__ENV__DATABASE_DRIVER:-pdo_sqlite}
+    POPULATE_DATABASE=${POPULATE_DATABASE:-True}
+
+    # Replace environment variables
+    envsubst < /etc/wallabag/parameters.template.yml > app/config/parameters.yml
+
+    # Wait for external database
+    if [ "$SYMFONY__ENV__DATABASE_DRIVER" = "pdo_mysql" ] || [ "$SYMFONY__ENV__DATABASE_DRIVER" = "pdo_pgsql" ] ; then
+        wait_for_database
+    fi
+
+    # Configure SQLite database
+    SQLITE_FILE_SIZE=$(wc -c "/var/www/wallabag/data/db/wallabag.sqlite" | awk '{print $1}')
+    if [ "$SYMFONY__ENV__DATABASE_DRIVER" = "pdo_sqlite" ] && ([ ! -f "/var/www/wallabag/data/db/wallabag.sqlite" ] || [ "$SQLITE_FILE_SIZE" = 0 ]) ; then
+        echo "Configuring the SQLite database ..."
+        install_wallabag
+    fi
+
+    # Configure MySQL / MariaDB database
+    if [ "$SYMFONY__ENV__DATABASE_DRIVER" = "pdo_mysql" ] && [ "$POPULATE_DATABASE" = "True" ] && [ "$MYSQL_ROOT_PASSWORD" != "" ] ; then
+        DATABASE_EXISTS="$(mysql -h "${SYMFONY__ENV__DATABASE_HOST}" --port "${SYMFONY__ENV__DATABASE_PORT}" -uroot -p"${MYSQL_ROOT_PASSWORD}" \
+            -sse "SELECT EXISTS(SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '$SYMFONY__ENV__DATABASE_NAME')")"
+        if [ "$DATABASE_EXISTS" != "1" ]; then
+            echo "Configuring the MySQL database ..."
+            mysql -h "${SYMFONY__ENV__DATABASE_HOST}" --port "${SYMFONY__ENV__DATABASE_PORT}" -uroot -p"${MYSQL_ROOT_PASSWORD}" \
+                -e "CREATE DATABASE IF NOT EXISTS ${SYMFONY__ENV__DATABASE_NAME} CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"
+            USER_EXISTS="$(mysql -h "${SYMFONY__ENV__DATABASE_HOST}" --port "${SYMFONY__ENV__DATABASE_PORT}" -uroot -p"${MYSQL_ROOT_PASSWORD}" \
+                -sse "SELECT EXISTS(SELECT 1 FROM mysql.user WHERE user = '$SYMFONY__ENV__DATABASE_USER')")"
+            if [ "$USER_EXISTS" != "1" ]; then
+                mysql -h "${SYMFONY__ENV__DATABASE_HOST}" --port "${SYMFONY__ENV__DATABASE_PORT}" -uroot -p"${MYSQL_ROOT_PASSWORD}" \
+                    -e "CREATE USER IF NOT EXISTS '${SYMFONY__ENV__DATABASE_USER}'@'%' IDENTIFIED BY '${SYMFONY__ENV__DATABASE_PASSWORD}';"
+                mysql -h "${SYMFONY__ENV__DATABASE_HOST}" --port "${SYMFONY__ENV__DATABASE_PORT}" -uroot -p"${MYSQL_ROOT_PASSWORD}" \
+                    -e "GRANT ALL PRIVILEGES ON ${SYMFONY__ENV__DATABASE_NAME}.* TO '${SYMFONY__ENV__DATABASE_USER}'@'%';"
+            fi
+            install_wallabag
+        else
+            echo "WARN: MySQL database is already configured. Remove the environment variable with root password."
+        fi
+    fi
+
+    # Configure Postgres database
+    if [ "$SYMFONY__ENV__DATABASE_DRIVER" = "pdo_pgsql" ] && [ "$POPULATE_DATABASE" = "True" ] && [ "$POSTGRES_PASSWORD" != "" ] ; then
+        export PGPASSWORD="${POSTGRES_PASSWORD}"
+        DATABASE_EXISTS="$(psql -qAt -h "${SYMFONY__ENV__DATABASE_HOST}" -p "${SYMFONY__ENV__DATABASE_PORT}" -U "${POSTGRES_USER}" \
+            -c "SELECT 1 FROM pg_catalog.pg_database WHERE datname = '${SYMFONY__ENV__DATABASE_NAME}';")"
+        if [ "$DATABASE_EXISTS" != "1" ]; then
+            echo "Configuring the Postgres database ..."
+            psql -q -h "${SYMFONY__ENV__DATABASE_HOST}" -p "${SYMFONY__ENV__DATABASE_PORT}" -U "${POSTGRES_USER}" \
+                -c "CREATE DATABASE ${SYMFONY__ENV__DATABASE_NAME};"
+            USER_EXISTS="$(psql -qAt -h "${SYMFONY__ENV__DATABASE_HOST}" -p "${SYMFONY__ENV__DATABASE_PORT}" -U "${POSTGRES_USER}" \
+                -c "SELECT 1 FROM pg_roles WHERE rolname = '${SYMFONY__ENV__DATABASE_USER}';")"
+            if [ "$USER_EXISTS" != "1" ]; then
+                psql -q -h "${SYMFONY__ENV__DATABASE_HOST}" -p "${SYMFONY__ENV__DATABASE_PORT}" -U "${POSTGRES_USER}" \
+                    -c "CREATE ROLE ${SYMFONY__ENV__DATABASE_USER} with PASSWORD '${SYMFONY__ENV__DATABASE_PASSWORD}' LOGIN;"
+            fi
+            install_wallabag
+        else
+            echo "WARN: Postgres database is already configured. Remove the environment variable with root password."
+        fi
+    fi
+
+    # Remove cache and install Wallabag
+    rm -f -r /var/www/wallabag/var/cache
+    su -c "SYMFONY_ENV=prod composer install --no-dev -o --prefer-dist" -s /bin/sh nobody
+}
+
+if [ "$COMMAND_ARG1" = "wallabag" ]; then
+    echo "Starting wallabag ..."
+    provisioner
+    echo "wallabag is ready!"
     exec s6-svscan /etc/s6/
 fi
 
+if [ "$COMMAND_ARG1" = "import" ]; then
+    provisioner
+    exec su -c "bin/console wallabag:import:redis-worker --env=prod $COMMAND_ARG2 -vv" -s /bin/sh nobody
+fi
+
+if [ "$COMMAND_ARG1" = "migrate" ]; then
+    provisioner
+    exec su -c "bin/console doctrine:migrations:migrate --env=prod --no-interaction" -s /bin/sh nobody
+fi
+
 exec "$@"

root/etc/ansible/entrypoint.yml

@@ -1,136 +0,0 @@
----
-- hosts: localhost
-  remote_user: root
-
-  vars:
-
-    database_driver: "{{ lookup('env', 'SYMFONY__ENV__DATABASE_DRIVER')|default('pdo_sqlite', true) }}"
-    database_host: "{{ lookup('env', 'SYMFONY__ENV__DATABASE_HOST')|default('127.0.0.1', true) }}"
-    database_name: "{{ lookup('env', 'SYMFONY__ENV__DATABASE_NAME')|default('symfony', true) }}"
-    database_password: "{{ lookup('env', 'SYMFONY__ENV__DATABASE_PASSWORD')|default('~', true) }}"
-    database_port: "{{ lookup('env', 'SYMFONY__ENV__DATABASE_PORT')|default('~', true) }}"
-    database_root_password_mariadb: "{{ lookup('env', 'MYSQL_ROOT_PASSWORD') }}"
-    database_root_user_postgres: "{{ lookup('env', 'POSTGRES_USER') }}"
-    database_root_password_postgres: "{{ lookup('env', 'POSTGRES_PASSWORD') }}"
-    database_user: "{{ lookup('env', 'SYMFONY__ENV__DATABASE_USER')|default('root', true) }}"
-    secret: "{{ lookup('env', 'SYMFONY__ENV__SECRET')|default('ovmpmAWXRCabNlMgzlzFXDYmCFfzGv', true) }}"
-    mailer_host: "{{ lookup('env', 'SYMFONY__ENV__MAILER_HOST')|default('127.0.0.1', true) }}"
-    mailer_user: "{{ lookup('env', 'SYMFONY__ENV__MAILER_USER')|default('~', true) }}"
-    mailer_password: "{{ lookup('env', 'SYMFONY__ENV__MAILER_PASSWORD')|default('~', true) }}"
-    from_email: "{{ lookup('env', 'SYMFONY__ENV__FROM_EMAIL')|default('wallabag@example.com', true) }}"
-    registration: "{{ lookup('env', 'SYMFONY__ENV__FOSUSER_REGISTRATION')|default('true', true) }}"
-
-  tasks:
-
-    - name: needed dirs
-      file:
-        path={{ item }}
-        state=directory
-      with_items:
-        - /var/www/wallabag/app
-        - /var/www/wallabag/app/config
-        - /var/www/wallabag/data
-        - /var/www/wallabag/data/assets
-        - /var/www/wallabag/data/db
-      notify: chown dir
-
-    - name: write parameters.yml
-      template:
-        src=templates/parameters.yml.j2
-        dest=/var/www/wallabag/app/config/parameters.yml
-
-    - stat:
-        path=/var/www/wallabag/data/db/wallabag.sqlite
-      register: wallabag_sqlite_db
-      when: database_driver == 'pdo_sqlite'
-
-    - name: notify install for sqlite
-      debug:
-        msg='notify installation script if sqlite db does not exist'
-      changed_when: true
-      notify: run install
-      when: (database_driver == 'pdo_sqlite') and
-            (wallabag_sqlite_db.stat.exists == False)
-
-    - name: wait for db container
-      wait_for:
-        host="{{ database_host }}"
-        port="{{ database_port }}"
-      when: (database_driver == 'pdo_mysql') or
-            (database_driver == 'pdo_pgsql')
-
-    - name: add mariadb db
-      mysql_db:
-        name="{{ database_name }}"
-        state=present
-        login_host="{{ database_host }}"
-        login_port={{ database_port }}
-        login_user=root
-        login_password="{{ database_root_password_mariadb }}"
-      notify: run install
-      when: database_driver == 'pdo_mysql'
-
-    - name: add mariadb user
-      mysql_user:
-        name="{{ database_user }}"
-        host=%
-        password="{{ database_password }}"
-        priv={{ database_name }}.*:ALL
-        login_host="{{ database_host }}"
-        login_port={{ database_port }}
-        login_user=root
-        login_password="{{ database_root_password_mariadb }}"
-        state=present
-      when: (database_driver == 'pdo_mysql') and
-            (database_user != 'root')
-
-    - name: postgresql db
-      postgresql_db:
-        name="{{ database_name }}"
-        state=present
-        login_host="{{ database_host }}"
-        port={{ database_port }}
-        login_user="{{ database_root_user_postgres }}"
-        login_password="{{ database_root_password_postgres }}"
-      notify: run install
-      when: database_driver == 'pdo_pgsql'
-
-    - name: add postgresql user
-      postgresql_user:
-        name="{{ database_user }}"
-        password="{{ database_password }}"
-        db={{ database_name }}
-        priv=ALL
-        login_host="{{ database_host }}"
-        port={{ database_port }}
-        login_user="{{ database_root_user_postgres }}"
-        login_password="{{ database_root_password_postgres }}"
-        state=present
-      when: (database_driver == 'pdo_pgsql') and
-            (database_user != 'postgres')
-
-    - name: remove cache
-      file:
-        path=/var/www/wallabag/var/cache
-        state=absent
-
-    - name: run composer
-      shell: SYMFONY_ENV=prod composer install --no-dev -o --prefer-dist
-      args:
-        chdir: /var/www/wallabag
-      notify: chown dir
-
-  handlers:
-
-    - name: run install
-      shell: php bin/console wallabag:install --env=prod -n
-      args:
-        chdir: /var/www/wallabag
-      notify: chown dir
-
-    - name: chown dir
-      file:
-        path=/var/www/wallabag
-        recurse=yes
-        owner=nobody
-        group=nobody

root/etc/ansible/hosts

@@ -1,2 +0,0 @@
-[localhost]
-localhost

root/etc/ansible/templates/parameters.yml.j2

@@ -1,44 +0,0 @@
-parameters:
-    database_driver: {{ database_driver }}
-    database_host: {{ database_host }}
-    database_port: {{ database_port }}
-    database_name: {{ database_name }}
-    database_user: {{ database_user }}
-    database_password: {{ database_password }}
-    database_path: "%kernel.root_dir%/../data/db/wallabag.sqlite"
-    database_table_prefix: wallabag_
-    database_socket: null
-
-    mailer_transport:  smtp
-    mailer_host:       {{ mailer_host }}
-    mailer_user:       {{ mailer_user }}
-    mailer_password:   {{ mailer_password }}
-
-    locale:            en
-
-    # A secret key that's used to generate certain security-related tokens
-    secret: {{ secret }}
-
-    # two factor stuff
-    twofactor_auth: true
-    twofactor_sender: no-reply@wallabag.org
-
-    # fosuser stuff
-    fosuser_registration: {{ registration }}
-    fosuser_confirmation: true
-
-    from_email: {{ from_email }}
-
-    rss_limit: 50
-
-    # RabbitMQ processing
-    rabbitmq_host: localhost
-    rabbitmq_port: 5672
-    rabbitmq_user: guest
-    rabbitmq_password: guest
-
-    # Redis processing
-    redis_scheme: tcp
-    redis_host: redis
-    redis_port: 6379
-    redis_path: null

root/etc/nginx/fastcgi_params

@@ -10,7 +10,7 @@ fastcgi_param  DOCUMENT_URI       $document_uri;
 fastcgi_param  DOCUMENT_ROOT      $document_root;
 fastcgi_param  SERVER_PROTOCOL    $server_protocol;
 fastcgi_param  REQUEST_SCHEME     $scheme;
-fastcgi_param  HTTPS              $https if_not_empty;
+fastcgi_param  HTTPS              $fe_https;
 
 fastcgi_param  GATEWAY_INTERFACE  CGI/1.1;
 fastcgi_param  SERVER_SOFTWARE    nginx/$nginx_version;

root/etc/nginx/nginx.conf

@@ -25,12 +25,17 @@ http {
     open_file_cache max=100;
     client_max_body_size 100M;
 
+    map $http_x_forwarded_proto $fe_https {
+        default $https;
+        https on;
+    }
 
     upstream php-upstream {
         server 127.0.0.1:9000;
     }
 
     server {
+        listen 80;
         server_name _;
         root /var/www/wallabag/web;
 

root/etc/php81/php.ini

@@ -268,7 +268,7 @@ output_buffering = 4096
 ; Note: You need to use zlib.output_handler instead of the standard
 ;   output_handler, or otherwise the output will be corrupted.
 ; http://php.net/zlib.output-compression
-zlib.output_compression = Off
+zlib.output_compression = On
 
 ; http://php.net/zlib.output-compression-level
 ;zlib.output_compression_level = -1
@@ -373,7 +373,7 @@ zend.enable_gc = On
 ; threat in any way, but it makes it possible to determine whether you use PHP
 ; on your server or not.
 ; http://php.net/expose-php
-expose_php = On
+expose_php = Off
 
 ;;;;;;;;;;;;;;;;;;;
 ; Resource Limits ;

root/etc/s6/.s6-svscan/finish

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec /bin/true

root/etc/s6/php-fpm/run

@@ -1,3 +1,3 @@
 #!/bin/sh
 
-exec php-fpm7 -F
+exec php-fpm -F

root/etc/wallabag/parameters.template.yml

@@ -0,0 +1,56 @@
+parameters:
+    database_driver: ${SYMFONY__ENV__DATABASE_DRIVER:-pdo_sqlite}
+    database_host: ${SYMFONY__ENV__DATABASE_HOST:-127.0.0.1}
+    database_port: ${SYMFONY__ENV__DATABASE_PORT:-~}
+    database_name: ${SYMFONY__ENV__DATABASE_NAME:-symfony}
+    database_user: ${SYMFONY__ENV__DATABASE_USER:-root}
+    database_password: ${SYMFONY__ENV__DATABASE_PASSWORD:-~}
+    database_path: "%kernel.project_dir%/data/db/wallabag.sqlite"
+    database_table_prefix: ${SYMFONY__ENV__DATABASE_TABLE_PREFIX:-wallabag_}
+    database_socket: null
+    database_charset: ${SYMFONY__ENV__DATABASE_CHARSET:-utf8}
+
+    domain_name: ${SYMFONY__ENV__DOMAIN_NAME:-https://your-wallabag-instance.wallabag.org}
+
+    mailer_dsn: ${SYMFONY__ENV__MAILER_DSN:-smtp://127.0.0.1}
+
+    locale: ${SYMFONY__ENV__LOCALE:-en}
+
+    # A secret key that's used to generate certain security-related tokens
+    secret: ${SYMFONY__ENV__SECRET:-ovmpmAWXRCabNlMgzlzFXDYmCFfzGv}
+
+    # two factor stuff
+    twofactor_sender: ${SYMFONY__ENV__TWOFACTOR_SENDER:-no-reply@wallabag.org}
+
+    # fosuser stuff
+    fosuser_registration: ${SYMFONY__ENV__FOSUSER_REGISTRATION:-true}
+    fosuser_confirmation: ${SYMFONY__ENV__FOSUSER_CONFIRMATION:-true}
+
+    # how long the access token should live in seconds for the API
+    fos_oauth_server_access_token_lifetime: 3600
+    # how long the refresh token should life in seconds for the API
+    fos_oauth_server_refresh_token_lifetime: 1209600
+
+    from_email: ${SYMFONY__ENV__FROM_EMAIL:-no-reply@wallabag.org}
+
+    rss_limit: 50
+
+    # RabbitMQ processing
+    rabbitmq_host: localhost
+    rabbitmq_port: 5672
+    rabbitmq_user: guest
+    rabbitmq_password: guest
+    rabbitmq_prefetch_count: 10
+
+    # Redis processing
+    redis_scheme: ${SYMFONY__ENV__REDIS_SCHEME:-tcp}
+    redis_host: ${SYMFONY__ENV__REDIS_HOST:-redis}
+    redis_port: ${SYMFONY__ENV__REDIS_PORT:-6379}
+    redis_path: ${SYMFONY__ENV__REDIS_PATH:-~}
+    redis_password: ${SYMFONY__ENV__REDIS_PASSWORD:-~}
+
+    # Sentry
+    sentry_dsn: ${SYMFONY__ENV__SENTRY_DSN:-~}
+
+    # User-friendly name of your instance for 2FA issuer
+    server_name: ${SYMFONY__ENV__SERVER_NAME:-"Your wallabag instance"}

root/var/www/wallabag/app/config/parameters.yml

@@ -1,52 +0,0 @@
-parameters:
-    database_driver: pdo_sqlite
-    database_host: 127.0.0.1
-    database_port: ~
-    database_name: symfony
-    database_user: root
-    database_password: ~
-    database_path: "%kernel.root_dir%/../data/db/wallabag.sqlite"
-    database_table_prefix: wallabag_
-    database_socket: null
-
-    test_database_driver: pdo_sqlite
-    test_database_host: 127.0.0.1
-    test_database_port: ~
-    test_database_name: ~
-    test_database_user: ~
-    test_database_password: ~
-    test_database_path: "%kernel.root_dir%/../data/db/wallabag_test.sqlite"
-
-    mailer_transport:  smtp
-    mailer_host:       127.0.0.1
-    mailer_user:       ~
-    mailer_password:   ~
-
-    locale:            en
-
-    # A secret key that's used to generate certain security-related tokens
-    secret: ovmpmAWXRCabNlMgzlzFXDYmCFfzGv
-
-    # two factor stuff
-    twofactor_auth: true
-    twofactor_sender: no-reply@wallabag.org
-
-    # fosuser stuff
-    fosuser_registration: true
-    fosuser_confirmation: true
-
-    from_email: no-reply@wallabag.org
-
-    rss_limit: 50
-
-    # RabbitMQ processing
-    rabbitmq_host: localhost
-    rabbitmq_port: 5672
-    rabbitmq_user: guest
-    rabbitmq_password: guest
-
-    # Redis processing
-    redis_scheme: tcp
-    redis_host: localhost
-    redis_port: 6379
-    redis_path: null

tests/docker-compose.mariadb.yml

@@ -18,5 +18,6 @@ services:
       - "127.0.0.1:80:80"
   db:
     image: mariadb
+    command: mariadbd --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci --character-set-client-handshake=FALSE
     environment:
       - MYSQL_ROOT_PASSWORD=wallaroot

tests/docker-compose.postgresql.yml

@@ -18,7 +18,7 @@ services:
     ports:
       - "127.0.0.1:80:80"
   db:
-    image: postgres
+    image: postgres:10.3
     environment:
       - POSTGRES_PASSWORD=my-secret-pw
       - POSTGRES_USER=my-super-user

tests/docker-compose.sqlite.yml

@@ -11,7 +11,7 @@ services:
       - SYMFONY__ENV__DATABASE_PORT=~
       - SYMFONY__ENV__DATABASE_NAME=symfony
       - SYMFONY__ENV__DATABASE_USER=root
-      - SYMFONY__ENV_DATABASE_PASSWORD=~
+      - SYMFONY__ENV__DATABASE_PASSWORD=~
       - SYMFONY__ENV__SECRET=F00B4R
     ports:
       - "127.0.0.1:80:80"

tests/test_login.py

@@ -1,24 +1,64 @@
 import pytest
 import re
 import requests
+import os
 
+from requests.exceptions import ConnectionError
 
-URL = 'http://127.0.0.1:80'
+@pytest.fixture(scope="session")
+def database(pytestconfig):
+    return pytestconfig.getoption("database")
 
+def is_responsive(url):
+    try:
+        response = requests.get(url)
+        if response.status_code == 200:
+            return True
+    except ConnectionError:
+        return False
 
-def test_accessing_login_page():
-    r = requests.get(URL, allow_redirects=True)
+@pytest.fixture(scope="session")
+def docker_compose_project_name(database):
+    return "wallabag_{}".format(database)
+
+@pytest.fixture(scope="session")
+def docker_cleanup():
+    """Disable docker cleanup at the end of tests to get logs outside of pytest"""
+    return False
+
+@pytest.fixture(scope="session")
+def docker_compose_command() -> str:
+    return "docker-compose"
+
+@pytest.fixture(scope="session")
+def docker_compose_file(pytestconfig, database):
+    return os.path.join(str(pytestconfig.rootdir), "tests/", "docker-compose.{}.yml".format(database))
+
+@pytest.fixture(scope="session")
+def wallabag_service(docker_ip, docker_services):
+    """Ensure that wallabag service is up and responsive"""
+
+    # `port_for` takes a container port and returns the corresponding host port
+    port = docker_services.port_for("wallabag", 80)
+    url = "http://{}:{}".format(docker_ip, port)
+    docker_services.wait_until_responsive(
+            timeout=60.0, pause=0.5, check=lambda: is_responsive(url)
+    )
+    return url
+
+def test_accessing_login_page(wallabag_service):
+    r = requests.get(wallabag_service, allow_redirects=True)
 
     assert r.status_code == 200
-    assert 'Login' in r.text
+    assert 'Log in' in r.text
     assert 'Password' in r.text
     assert 'Register' in r.text
     assert 'Username' in r.text
 
 
-def test_logging_in():
+def test_logging_in(wallabag_service):
     client = requests.session()
-    r = client.get(URL, allow_redirects=True)
+    r = client.get(wallabag_service, allow_redirects=True)
     jar = r.cookies
 
     # get csrf token
@@ -39,7 +79,7 @@ def test_logging_in():
         '_csrf_token': csrf
     }
 
-    r = client.post(URL + '/login_check', cookies=jar, data=data)
+    r = client.post(wallabag_service + '/login_check', cookies=jar, data=data)
     assert r.status_code == 200
     assert '/unread/list' in r.text
     assert '/starred/list' in r.text