Update to 4.8.0

Signed-off-by: Isaac Bennetch <bennetch@gmail.com>

.dockerignore

@@ -4,3 +4,4 @@ docker-compose.testing.yml
 README.md
 LICENSE
 Makefile
+testing

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,4 @@
+This repository contains only Docker integration of phpMyAdmin.
+
+Please do not report bugs in phpMyAdmin itself here, use
+<https://github.com/phpmyadmin/phpmyadmin/issues> instead.

.github/stale.yml

@@ -0,0 +1,23 @@
+# Configuration for probot-stale - https://github.com/probot/stale
+
+# Number of days of inactivity before an Issue or Pull Request becomes stale
+daysUntilStale: 60
+# Number of days of inactivity before a stale Issue or Pull Request is closed
+daysUntilClose: 7
+# Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
+exemptLabels:
+  - pinned
+  - security
+# Label to use when marking as stale
+staleLabel: wontfix
+# Comment to post when marking as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when removing the stale label. Set to `false` to disable
+unmarkComment: false
+# Comment to post when closing a stale Issue or Pull Request. Set to `false` to disable
+closeComment: false
+# Limit to only `issues` or `pulls`
+only: pulls

.travis.yml

@@ -1,36 +1,45 @@
+dist: trusty
+
 sudo: required
 
 services:
   - docker
 
+language: python
+python:
+  - "2.7"
+
 env:
   matrix:
-    - DB=mysql:5.7
-    - DB=mariadb:10.0
+    - DB=mysql:latest
+    - DB=mariadb:latest
 
 before_install:
-  - docker run --name db_server -e MYSQL_ROOT_PASSWORD=my-secret-pw -d $DB
+  - export TESTSUITE_PASSWORD=`openssl rand -base64 30`
+  - docker run --name db_server -e MYSQL_ROOT_PASSWORD=$TESTSUITE_PASSWORD -d $DB
+
+install:
+  - pip install mechanize html5lib
 
 script:
   # Build image
   - docker build -t phpmyadmin/phpmyadmin .
   # Test for single database
   - docker run --name testadmin -d --link db_server:db -p 9090:80 phpmyadmin/phpmyadmin
-  - docker ps -a
-  - curl http://127.0.0.1:9090/ | grep -q input_password
-  - curl --cookie-jar /tmp/cj --location -d pma_username=root -d pma_password=my-secret-pw -d server=1 http://127.0.0.1:9090/ | grep -r 'db via TCP'
+  - ./testing/test-docker.sh testadmin 9090
   # Test for single database using env
   - docker run --name envadmin -d --link db_server:db2 -e PMA_HOST=db2 -p 6060:80 phpmyadmin/phpmyadmin
-  - docker ps -a
-  - curl http://127.0.0.1:6060/ | grep -q input_password
-  - curl --cookie-jar /tmp/cj --location -d pma_username=root -d pma_password=my-secret-pw -d server=1 http://127.0.0.1:6060/ | grep -r 'db2 via TCP'
+  - ./testing/test-docker.sh envadmin 6060
   # Test for arbitrary database
-  - docker run --name arbitraryadmin -d --link db_server:db -e PMA_ARBITRARY=1 -p 7070:80 phpmyadmin/phpmyadmin
-  - docker ps -a
-  - curl http://127.0.0.1:7070/ | grep -q input_password
-  - curl --cookie-jar /tmp/cj --location -d pma_servername=db -d pma_username=root -d pma_password=my-secret-pw -d server=1 http://127.0.0.1:7070/ | grep -r 'db via TCP'
+  - docker run --name arbitraryadmin -d --link db_server:db3 -e PMA_ARBITRARY=1 -p 7070:80 phpmyadmin/phpmyadmin
+  - ./testing/test-docker.sh arbitraryadmin 7070 db3
+  # Test for arbitrary database with user config
+  - docker run --name userconfigadmin -d --link db_server:db3 -v `readlink -f ./testing/config.test.inc.php`:/etc/phpmyadmin/config.user.inc.php -p 7080:80 phpmyadmin/phpmyadmin
+  - ./testing/test-docker.sh userconfigadmin 7080 db3
   # Test docker-compose
-  - docker-compose up -d
-  - docker ps -a
-  - curl http://127.0.0.1:8080/ | grep -q input_password
+  - docker-compose -f docker-compose.yml -f docker-compose.db.yml up -d
+  - ./testing/test-docker.sh phpmyadmin 8080 db_server
   - docker-compose stop
+  # Run tests in testing container
+  - docker-compose -f docker-compose.testing.yml up -d phpmyadmin
+  - ./testing/wait-for-testing.sh

Dockerfile

@@ -1,18 +1,67 @@
-FROM alpine
+FROM php:7.2-fpm-alpine
 
-RUN apk add --no-cache php-cli php-mysqli php-ctype php-xml php-gd php-zlib php-openssl php-curl php-opcache php-json php-mcrypt curl
+# Install dependencies
+RUN apk add --no-cache --virtual .build-deps \
+        bzip2-dev \
+        freetype-dev \
+        libjpeg-turbo-dev \
+        libpng-dev \
+        libwebp-dev \
+        libxpm-dev \
+    ; \
+    \
+    docker-php-ext-configure gd --with-freetype-dir=/usr --with-jpeg-dir=/usr --with-webp-dir=/usr --with-png-dir=/usr --with-xpm-dir=/usr; \
+    docker-php-ext-install bz2 gd mysqli opcache zip; \
+    \
+    runDeps="$( \
+        scanelf --needed --nobanner --format '%n#p' --recursive /usr/local/lib/php/extensions \
+            | tr ',' '\n' \
+            | sort -u \
+            | awk 'system("[ -e /usr/local/lib/" $1 " ]") == 0 { next } { print "so:" $1 }' \
+    )"; \
+    apk add --virtual .phpmyadmin-phpexts-rundeps $runDeps; \
+    apk del .build-deps; \
+    apk add --no-cache nginx supervisor
 
-RUN curl --location https://www.phpmyadmin.net/downloads/phpMyAdmin-latest-all-languages.tar.gz | tar xzf - \
- && mv phpMyAdmin* /www \
- && rm -rf /www/js/jquery/src/ /www/examples /www/po/
+# Include keyring to verify download
+COPY phpmyadmin.keyring /
 
-COPY config.inc.php /www/
+# Copy configuration
+COPY etc /etc/
+
+# Copy main script
 COPY run.sh /run.sh
 RUN chmod u+rwx /run.sh
 
+# Calculate download URL
+ENV VERSION 4.8.0
+ENV URL https://files.phpmyadmin.net/phpMyAdmin/${VERSION}/phpMyAdmin-${VERSION}-all-languages.tar.gz
+LABEL version=$VERSION
+
+# Download tarball, verify it using gpg and extract
+RUN set -x \
+    && GNUPGHOME="$(mktemp -d)" \
+    && export GNUPGHOME \
+    && apk add --no-cache curl gnupg \
+    && curl --output phpMyAdmin.tar.gz --location $URL \
+    && curl --output phpMyAdmin.tar.gz.asc --location $URL.asc \
+    && gpgv --keyring /phpmyadmin.keyring phpMyAdmin.tar.gz.asc phpMyAdmin.tar.gz \
+    && apk del --no-cache curl gnupg \
+    && rm -rf "$GNUPGHOME" \
+    && tar xzf phpMyAdmin.tar.gz \
+    && rm -f phpMyAdmin.tar.gz phpMyAdmin.tar.gz.asc \
+    && mv phpMyAdmin-$VERSION-all-languages /www \
+    && rm -rf /www/setup/ /www/examples/ /www/test/ /www/po/ /www/composer.json /www/RELEASE-DATE-$VERSION \
+    && sed -i "s@define('CONFIG_DIR'.*@define('CONFIG_DIR', '/etc/phpmyadmin/');@" /www/libraries/vendor_config.php \
+    && chown -R root:nobody /www \
+    && find /www -type d -exec chmod 750 {} \; \
+    && find /www -type f -exec chmod 640 {} \;
+
+# Add directory for sessions to allow session persistence
+RUN mkdir /sessions
+
+# We expose phpMyAdmin on port 80
 EXPOSE 80
 
-ENV PHP_UPLOAD_MAX_FILESIZE=64M \
-    PHP_MAX_INPUT_VARS=2000
-
 ENTRYPOINT [ "/run.sh" ]
+CMD ["phpmyadmin"]

README.md

@@ -1,12 +1,37 @@
 # Official phpMyAdmin Docker image
 
-Run phpMyAdmin with Alpine and PHP built in web server.
+Run phpMyAdmin with Alpine, supervisor, nginx and PHP FPM.
 
 [![Build Status](https://travis-ci.org/phpmyadmin/docker.svg?branch=master)](https://travis-ci.org/phpmyadmin/docker)
+[![Docker Pulls](https://img.shields.io/docker/pulls/phpmyadmin/phpmyadmin.svg)][hub]
+[![Docker Stars](https://img.shields.io/docker/stars/phpmyadmin/phpmyadmin.svg)][hub]
+[![Docker Layers](https://images.microbadger.com/badges/image/phpmyadmin/phpmyadmin.svg)](https://microbadger.com/images/phpmyadmin/phpmyadmin "Get your own image badge on microbadger.com")
+[![Docker Version](https://images.microbadger.com/badges/version/phpmyadmin/phpmyadmin.svg)](https://microbadger.com/images/phpmyadmin/phpmyadmin "Get your own version badge on microbadger.com")
+
 
 All following examples will bring you phpMyAdmin on `http://localhost:8080`
 where you can enjoy your happy MySQL administration.
 
+## Credentials
+
+phpMyAdmin does use MySQL server credential, please check the corresponding
+server image for information how it is setup.
+
+The official MySQL and MariaDB use following environment variables to define these:
+
+* `MYSQL_ROOT_PASSWORD` - This variable is mandatory and specifies the password that will be set for the `root` superuser account.
+* `MYSQL_USER`, `MYSQL_PASSWORD` - These variables are optional, used in conjunction to create a new user and to set that user's password.
+
+## Docker hub tags
+
+You can use following tags on Docker hub:
+
+* `latest` - latest stable release
+* `4.6` - latest stable release from the 4.6 branch
+* `4.7` - latest stable release from the 4.7 branch
+* `edge` - bleeding edge docker image (contains stable phpMyAdmin, but the Docker image changes might not yet be fully tested)
+* `edge-4.7` - bleeding edge docker image + latest snapshots from 4.7 branch
+* `edge-4.8` - bleeding edge docker image + latest snapshots from 4.8 branch (currently master)
 
 ## Usage with linked server
 
@@ -31,7 +56,7 @@ docker run --name myadmin -d -e PMA_HOST=dbhost -p 8080:80 phpmyadmin/phpmyadmin
 You can use arbitrary servers by adding ENV variable `PMA_ARBITRARY=1` to the startup command:
 
 ```
-docker run --name myadmin -d --link mysql_db_server:db -p 8080:80 -e PMA_ARBITRARY=1 phpmyadmin/phpmyadmin
+docker run --name myadmin -d -e PMA_ARBITRARY=1 -p 8080:80 phpmyadmin/phpmyadmin
 ```
 
 ## Usage with docker-compose and arbitrary server
@@ -45,18 +70,52 @@ Using the docker-compose.yml from https://github.com/phpmyadmin/docker
 docker-compose up -d
 ```
 
+## Run the E2E tests with docker-compose
+
+You can run the E2E tests with the local test environment by running MariaDB/MySQL databases. Adding ENV variable `PHPMYADMIN_RUN_TEST=true` already added on docker-compose file. Simply run:
+
+Using the docker-compose.testing.yml from https://github.com/phpmyadmin/docker
+
+```
+docker-compose -f docker-compose.testing.yml up phpmyadmin
+```
+
+## Adding Custom Configuration
+
+You can add your own custom config.inc.php settings (such as Configuration Storage setup) 
+by creating a file named "config.user.inc.php" with the various user defined settings
+in it, and then linking it into the container using:
+
+```
+-v /some/local/directory/config.user.inc.php:/etc/phpmyadmin/config.user.inc.php
+```
+On the "docker run" line like this:
+``` 
+docker run --name myadmin -d --link mysql_db_server:db -p 8080:80 -v /some/local/directory/config.user.inc.php:/etc/phpmyadmin/config.user.inc.php phpmyadmin/phpmyadmin
+```
+
+See the following links for config file information.
+https://docs.phpmyadmin.net/en/latest/config.html#config
+https://docs.phpmyadmin.net/en/latest/setup.html
+
 ## Usage behind reverse proxys
+
 Set the variable ``PMA_ABSOLUTE_URI`` to the fully-qualified path (``https://pma.example.net/``) where the reverse proxy makes phpMyAdmin available.
 
 ## Environment variables summary
 
 * ``PMA_ARBITRARY`` - when set to 1 connection to the arbitrary server will be allowed
 * ``PMA_HOST`` - define address/host name of the MySQL server
+* ``PMA_VERBOSE`` - define verbose name of the MySQL server
 * ``PMA_PORT`` - define port of the MySQL server
 * ``PMA_HOSTS`` - define comma separated list of address/host names of the MySQL servers
+* ``PMA_VERBOSES`` - define comma separated list of verbose names of the MySQL servers
+* ``PMA_PORTS`` -  define comma separated list of ports of the MySQL servers
 * ``PMA_USER`` and ``PMA_PASSWORD`` - define username to use for config authentication method
 * ``PMA_ABSOLUTE_URI`` - define user-facing URI
-* ``PHP_UPLOAD_MAX_FILESIZE`` - define upload_max_filesize and post_max_size PHP settings
-* ``PHP_MAX_INPUT_VARS`` - define max_input_vars PHP setting 
 
-For more detailed documentation see http://docs.phpmyadmin.net/en/latest/setup.html#installing-using-docker
+For more detailed documentation see https://docs.phpmyadmin.net/en/latest/setup.html#installing-using-docker
+
+[hub]: https://hub.docker.com/r/phpmyadmin/phpmyadmin/
+
+Please report any issues with the Docker container to https://github.com/phpmyadmin/docker/issues

docker-compose.db.yml

@@ -0,0 +1,3 @@
+phpmyadmin:
+    external_links:
+        - db_server:db

docker-compose.testing.yml

@@ -1,8 +1,29 @@
-phpmyadmin:
-    image: phpmyadmin/phpmyadmin:testing
-    container_name: myadmin
+version: '2'
+
+services:
+  mariadb:
+    image: mariadb:latest
+    container_name: phpmyadmin_testing_mariadb
     environment:
-     - PMA_ARBITRARY=1
-    restart: always
+      - MYSQL_ROOT_PASSWORD=test123
+
+  mysql:
+    image: mysql:latest
+    container_name: phpmyadmin_testing_mysql
+    environment:
+      - MYSQL_ROOT_PASSWORD=test123
+
+  phpmyadmin:
+    build:
+      context: testing/
+    container_name: phpmyadmin_testing
+    volumes:
+      - /sessions
     ports:
-     - 8090:80
+      - 8090:80
+    environment:
+      - PMA_ARBITRARY=1
+      - TESTSUITE_PASSWORD=test123
+    depends_on:
+      - mariadb
+      - mysql

docker-compose.yml

@@ -1,8 +1,10 @@
 phpmyadmin:
     image: phpmyadmin/phpmyadmin
-    container_name: myadmin
+    container_name: phpmyadmin
     environment:
      - PMA_ARBITRARY=1
     restart: always
     ports:
      - 8080:80
+    volumes:
+     - /sessions

etc/nginx.conf

@@ -0,0 +1,132 @@
+user nobody;
+worker_processes 4;
+
+daemon off;
+
+pid /nginx.pid;
+
+error_log /var/log/nginx-error.log;
+
+events {
+    worker_connections 1024;
+}
+
+http {
+    types {
+        text/html                             html htm shtml;
+        text/css                              css;
+        text/xml                              xml;
+        image/gif                             gif;
+        image/jpeg                            jpeg jpg;
+        application/javascript                js;
+        application/atom+xml                  atom;
+        application/rss+xml                   rss;
+    }
+
+    default_type application/octet-stream;
+
+    sendfile on;
+    tcp_nopush on;
+    tcp_nodelay on;
+
+    client_body_timeout 12;
+    client_header_timeout 12;
+    keepalive_timeout 15;
+    send_timeout 10;
+    server_tokens off;
+
+    client_body_buffer_size 512K;
+    client_body_temp_path /var/nginx/client_body_temp;
+    client_header_buffer_size 16k;
+    client_max_body_size 512M;
+    large_client_header_buffers 4 8k;
+
+    gzip on;
+    gzip_comp_level 2;
+    gzip_min_length 1000;
+    gzip_proxied expired no-cache no-store private auth;
+    gzip_types text/plain application/x-javascript text/xml text/css application/xml;
+
+    access_log off;
+
+    server {
+        listen 80 default_server;
+        server_name _;
+
+        root /www;
+
+        index index.php index.html index.htm;
+
+        charset utf-8;
+
+        if ($request_method !~ ^(GET|HEAD|POST)$ ) {
+           return 405;
+        }
+
+        location / {
+            try_files $uri $uri/ =404;
+        }
+
+        location ~* .(jpg|jpeg|png|gif|ico|css|js)$ {
+            expires 365d;
+        }
+
+        location ~ \.php$ {
+            fastcgi_intercept_errors on;
+            fastcgi_pass unix:/var/run/php/php-fpm.sock;
+
+            # regex to split $uri to $fastcgi_script_name and $fastcgi_path
+            fastcgi_split_path_info ^(.+\.php)(/.+)$;
+
+            # Check that the PHP script exists before passing it
+            try_files $fastcgi_script_name =404;
+
+            # Bypass the fact that try_files resets $fastcgi_path_info
+            # see: https://trac.nginx.org/nginx/ticket/321
+            set $path_info $fastcgi_path_info;
+            fastcgi_param PATH_INFO $path_info;
+
+            fastcgi_read_timeout 1200;
+            fastcgi_buffering off;
+            fastcgi_buffers 16 16k;
+            fastcgi_buffer_size 32k;
+
+            fastcgi_index index.php;
+
+            fastcgi_param  SCRIPT_FILENAME    $document_root$fastcgi_script_name;
+            fastcgi_param  QUERY_STRING       $query_string;
+            fastcgi_param  REQUEST_METHOD     $request_method;
+            fastcgi_param  CONTENT_TYPE       $content_type;
+            fastcgi_param  CONTENT_LENGTH     $content_length;
+
+            fastcgi_param  SCRIPT_NAME        $fastcgi_script_name;
+            fastcgi_param  REQUEST_URI        $request_uri;
+            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  GATEWAY_INTERFACE  CGI/1.1;
+            fastcgi_param  SERVER_SOFTWARE    nginx;
+
+            fastcgi_param  REMOTE_ADDR        $remote_addr;
+            fastcgi_param  REMOTE_PORT        $remote_port;
+            fastcgi_param  SERVER_ADDR        $server_addr;
+            fastcgi_param  SERVER_PORT        $server_port;
+            fastcgi_param  SERVER_NAME        $server_name;
+
+            # PHP only, required if PHP was built with --enable-force-cgi-redirect
+            fastcgi_param  REDIRECT_STATUS    200;
+        }
+
+        location ~ /\. {
+            deny  all;
+        }
+
+        location ~ /(libraries|templates) {
+            deny all;
+        }
+
+    }
+}

etc/php-fpm.conf

@@ -0,0 +1,17 @@
+[global]
+error_log = /var/log/php-fpm.log
+log_level = warning
+
+[www]
+user = nobody
+group = nobody
+listen = /var/run/php/php-fpm.sock
+listen.mode = 0660
+chdir = /www
+pm = dynamic
+pm.max_children = 5
+pm.start_servers = 2
+pm.min_spare_servers = 1
+pm.max_spare_servers = 3
+catch_workers_output = Yes
+clear_env = No

etc/phpmyadmin/config.inc.php

@@ -1,20 +1,24 @@
 <?php
 
-require('./config.secret.inc.php');
+require('/etc/phpmyadmin/config.secret.inc.php');
 
 /* Ensure we got the environment */
 $vars = array(
     'PMA_ARBITRARY',
     'PMA_HOST',
     'PMA_HOSTS',
+    'PMA_VERBOSE',
+    'PMA_VERBOSES',
     'PMA_PORT',
+    'PMA_PORTS',
     'PMA_USER',
     'PMA_PASSWORD',
     'PMA_ABSOLUTE_URI'
 );
 foreach ($vars as $var) {
-    if (!isset($_ENV[$var]) && getenv($var)) {
-        $_ENV[$var] = getenv($var);
+    $env = getenv($var);
+    if (!isset($_ENV[$var]) && $env !== false) {
+        $_ENV[$var] = $env;
     }
 }
 
@@ -36,28 +40,44 @@ $hosts = array('db');
 /* Set by environment */
 if (!empty($_ENV['PMA_HOST'])) {
     $hosts = array($_ENV['PMA_HOST']);
+    $verbose = array($_ENV['PMA_VERBOSE']);
+    $ports = array($_ENV['PMA_PORT']);
 } elseif (!empty($_ENV['PMA_HOSTS'])) {
     $hosts = explode(',', $_ENV['PMA_HOSTS']);
+    $verbose = explode(',', $_ENV['PMA_VERBOSES']);
+    $ports = explode(',', $_ENV['PMA_PORTS']);
 }
 
 /* Server settings */
 for ($i = 1; isset($hosts[$i - 1]); $i++) {
     $cfg['Servers'][$i]['host'] = $hosts[$i - 1];
-    if (isset($_ENV['PMA_PORT'])) {
-        $cfg['Servers'][$i]['port'] = $_ENV['PMA_PORT'];
+    if (isset($verbose[$i - 1])) {
+        $cfg['Servers'][$i]['verbose'] = $verbose[$i - 1];
     }
-    if (isset($_ENV['PMA_USER'])) {                                
+    if (isset($ports[$i - 1])) {
+        $cfg['Servers'][$i]['port'] = $ports[$i - 1];
+    }
+    if (isset($_ENV['PMA_USER'])) {
         $cfg['Servers'][$i]['auth_type'] = 'config';
         $cfg['Servers'][$i]['user'] = $_ENV['PMA_USER'];
-        $cfg['Servers'][$i]['password'] = isset($_ENV['PMA_PASSWORD']) ? $_ENV['PMA_PASSWORD'] : null;
+        $cfg['Servers'][$i]['password'] = isset($_ENV['PMA_PASSWORD']) ? $_ENV['PMA_PASSWORD'] : '';
     } else {
         $cfg['Servers'][$i]['auth_type'] = 'cookie';
     }
-    $cfg['Servers'][$i]['connect_type'] = 'tcp';
     $cfg['Servers'][$i]['compress'] = false;
     $cfg['Servers'][$i]['AllowNoPassword'] = true;
 }
+/*
+ * Revert back to last configured server to make
+ * it easier in config.user.inc.php
+ */
+$i--;
 
 /* Uploads setup */
 $cfg['UploadDir'] = '';
 $cfg['SaveDir'] = '';
+
+/* Include User Defined Settings Hook */
+if (file_exists('/etc/phpmyadmin/config.user.inc.php')) {
+    include('/etc/phpmyadmin/config.user.inc.php');
+}

etc/supervisor.d/nginx.ini

@@ -0,0 +1,12 @@
+[program:nginx]
+command=nginx -c /etc/nginx.conf
+autostart=true
+autorestart=true
+priority=2
+startretries=3
+stopwaitsecs=10
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+

etc/supervisor.d/php.ini

@@ -0,0 +1,13 @@
+[program:php-fpm]
+command=php-fpm --nodaemonize --fpm-config /etc/php-fpm.conf -c /etc/php.ini
+user=nobody
+autostart=true
+autorestart=true
+priority=1
+startretries=3
+stopwaitsecs=10
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+

run.sh

@@ -1,14 +1,22 @@
 #!/bin/sh
-set -x
-
-if [ ! -f /www/config.secret.inc.php ] ; then
-    cat > /www/config.secret.inc.php <<EOT
+if [ ! -f /etc/phpmyadmin/config.secret.inc.php ] ; then
+    cat > /etc/phpmyadmin/config.secret.inc.php <<EOT
 <?php
-\$cfg['blowfish_secret'] = '`cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1`';
+\$cfg['blowfish_secret'] = '$(tr -dc 'a-zA-Z0-9~!@#$%^&*_()+}{?></";.,[]=-' < /dev/urandom | fold -w 32 | head -n 1)';
 EOT
 fi
 
-exec php -S 0.0.0.0:80 -t /www/ \
-    -d upload_max_filesize=$PHP_UPLOAD_MAX_FILESIZE \
-    -d post_max_size=$PHP_UPLOAD_MAX_FILESIZE \
-    -d max_input_vars=$PHP_MAX_INPUT_VARS
+if [ ! -f /etc/phpmyadmin/config.user.inc.php ] ; then
+  touch /etc/phpmyadmin/config.user.inc.php
+fi
+
+mkdir -p /var/nginx/client_body_temp
+chown nobody:nobody /sessions /var/nginx/client_body_temp
+mkdir -p /var/run/php/
+chown nobody:nobody /var/run/php/
+touch /var/log/php-fpm.log
+chown nobody:nobody /var/log/php-fpm.log
+
+if [ "$1" = 'phpmyadmin' ]; then
+    exec supervisord --nodaemon --configuration="/etc/supervisord.conf" --loglevel=info
+fi

testing/Dockerfile

@@ -0,0 +1,10 @@
+# Testing image for phpMyAdmin
+
+FROM phpmyadmin/phpmyadmin
+
+# Install test dependencies
+RUN apk add --no-cache curl py2-pip
+RUN pip install mechanize html5lib
+
+COPY test-mariadb.ini test-mysql.ini /etc/supervisor.d/
+COPY phpmyadmin_test.py test-docker.sh world.sql /

testing/config.test.inc.php

@@ -0,0 +1,2 @@
+<?php
+$cfg['AllowArbitraryServer'] = true;

testing/phpmyadmin_test.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+import argparse
+import os
+import re
+import sys
+
+import mechanize
+
+
+def test_content(match, content):
+    if not match in content:
+        print(content)
+        raise Exception('{0} not found in content!'.format(match))
+
+
+def test_phpmyadmin(url, username, password, server=None, sqlfile=None):
+    if sqlfile is None:
+        if os.path.exists('/world.sql'):
+            sqlfile = '/world.sql'
+        elif os.path.exists('./world.sql'):
+            sqlfile = './world.sql'
+        else:
+            sqlfile = './testing/world.sql'
+    br = mechanize.Browser()
+
+    # Ignore robots.txt
+    br.set_handle_robots(False)
+
+    # Login page
+    br.open(url)
+
+    # Fill login form
+    br.select_form('login_form')
+    br['pma_username'] = username
+    br['pma_password'] = password
+    if server is not None:
+        br['pma_servername'] = server
+
+    # Login and check if loggged in
+    response = br.submit()
+    test_content('Server version', response.read())
+
+    # Open server import
+    response = br.follow_link(text_regex=re.compile('Import'))
+    test_content('OpenDocument Spreadsheet', response.read())
+
+    # Upload SQL file
+    br.select_form('import')
+    br.form.add_file(open(sqlfile), 'text/plain', sqlfile)
+    response = br.submit()
+    test_content('5326 queries executed', response.read())
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--url', required=True)
+    parser.add_argument('--username', required=True)
+    parser.add_argument('--password', required=True)
+    parser.add_argument('--server')
+    parser.add_argument('--sqlfile', default=None)
+    args = parser.parse_args()
+
+    test_phpmyadmin(
+        args.url,
+        args.username,
+        args.password,
+        args.server,
+        args.sqlfile
+    )
+
+
+if __name__ == '__main__':
+    main()

testing/test-docker.sh

@@ -0,0 +1,94 @@
+#!/bin/sh
+
+NAME="$1"
+
+if [ -n "$2" ] ; then
+    PORT="$2"
+    TESTSUITE_PORT=$2
+fi
+
+if [ -n "$3" ] ; then
+    SERVER="--server $3"
+    PMA_HOST=$3
+else
+    SERVER=''
+fi
+
+# Set PHPMyAdmin environment
+PHPMYADMIN_HOSTNAME=${TESTSUITE_HOSTNAME:=localhost}
+PHPMYADMIN_PORT=${TESTSUITE_PORT:=80}
+PHPMYADMIN_URL=http://$PHPMYADMIN_HOSTNAME:$PORT/
+
+# Color text output
+GREEN="\033[0;32m"
+RED="\033[0;31m"
+NC="\033[0m" # No Color
+
+ret=0
+# Check if script is running inside container
+if [ -f /.dockerenv ] ; then
+    echo "Tests running inside container..."
+
+    # Set database environment
+    PHPMYADMIN_DB_HOSTNAME=${PMA_HOST:=localhost}
+    PHPMYADMIN_DB_PORT=${PMA_PORT:=3306}
+    PHPMYADMIN_DB_URL=http://$PHPMYADMIN_DB_HOSTNAME:$PHPMYADMIN_DB_PORT/
+
+    # Wait for database to start
+    TIMEOUT=0
+    while ! curl "$PHPMYADMIN_DB_URL" &>/dev/null; do
+        echo "Waiting for ${PHPMYADMIN_DB_HOSTNAME} database start..."
+        sleep 10
+        TIMEOUT=$((TIMEOUT + 1))
+        if [ $TIMEOUT -gt 3 ] ; then
+            echo "Failed to connect ${PHPMYADMIN_DB_HOSTNAME} database!"
+            echo "Result of ${PHPMYADMIN_DB_HOSTNAME} tests: ${RED}FAILED${NC}"
+            ret=1
+            exit 1
+        fi
+    done
+else
+    echo "Tests running outside container..."
+    docker ps -a
+    COMMAND_HOST="docker exec ${NAME}"
+fi
+
+# Wait for container to start
+TIMEOUT=0
+while ! $COMMAND_HOST ps aux | grep -q nginx ; do
+    echo "Waiting for PHPMyAdmin start..."
+    sleep 1
+    TIMEOUT=$((TIMEOUT + 1))
+    if [ $TIMEOUT -gt 10 ] ; then
+        echo "Failed to connect PHPMyAdmin!"
+        echo "Result of ${PHPMYADMIN_DB_HOSTNAME} tests: ${RED}FAILED${NC}"
+        ret=1
+        exit 1
+    fi
+done
+
+# Perform tests
+if [ $ret -eq 0 ] ; then
+    if [ -f /phpmyadmin_test.py ] ; then
+        FILENAME=/phpmyadmin_test.py
+    elif [ -f ./phpmyadmin_test.py ] ; then
+        FILENAME=./phpmyadmin_test.py
+    else
+        FILENAME=./testing/phpmyadmin_test.py
+    fi
+    python $FILENAME --url "$PHPMYADMIN_URL" --username root --password $TESTSUITE_PASSWORD $SERVER
+    ret=$?
+fi
+
+# Show debug output in case of failure
+if [ $ret -ne 0 ] ; then
+    curl "$PHPMYADMIN_URL"
+    $COMMAND_HOST ps faux
+    $COMMAND_HOST cat /var/log/php-fpm.log
+    $COMMAND_HOST cat /var/log/nginx-error.log
+    $COMMAND_HOST cat /var/log/supervisord.log
+    echo "Result of ${PHPMYADMIN_DB_HOSTNAME} tests: ${RED}FAILED${NC}"
+    exit $ret
+fi
+
+echo "Result of ${PHPMYADMIN_DB_HOSTNAME} tests: ${GREEN}SUCCESS${NC}"

testing/test-mariadb.ini

@@ -0,0 +1,11 @@
+[program:test-mariadb]
+command=/test-docker.sh test 80 mariadb
+autostart=true
+autorestart=false
+priority=3
+startretries=1
+stopwaitsecs=20
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0

testing/test-mysql.ini

@@ -0,0 +1,11 @@
+[program:test-mysql]
+command=/test-docker.sh test 80 mysql
+autostart=true
+autorestart=false
+priority=3
+startretries=1
+stopwaitsecs=20
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0

testing/wait-for-testing.sh

@@ -0,0 +1,32 @@
+#!/bin/sh
+
+# Helper script to wait for testing inside container completes
+# Needs running docker-compose container based on docker-compose.testing.yml
+
+GREEN="\033[0;32m"
+RED="\033[0;31m"
+NC="\033[0m" # No Color
+
+TIMEOUT=0
+
+sleep 5
+
+while [ `docker-compose -f docker-compose.testing.yml logs phpmyadmin | grep -c 'Result of \(mysql\|mariadb\) tests'` -lt 2 ] ; do
+    sleep 1
+    TIMEOUT=$(($TIMEOUT + 1))
+    if [ $TIMEOUT -gt 20 ] ; then
+        docker-compose -f docker-compose.testing.yml logs phpmyadmin
+        echo "${RED}Timeout!${NC}"
+        exit 1
+    fi
+done
+
+if [ `docker-compose -f docker-compose.testing.yml logs phpmyadmin | grep -c 'Result of \(mysql\|mariadb\) tests.*SUCCESS'` -lt 2 ] ; then
+    docker-compose -f docker-compose.testing.yml logs phpmyadmin
+    echo "${RED}Failed${NC}"
+    exit 2
+fi
+
+docker-compose -f docker-compose.testing.yml logs phpmyadmin
+echo "${GREEN}Success${NC}"
+exit 0