Release 1.11.1

tests: drop travisci usage
tests: store test results for usage in circleci
2020-04-04 21:50:29 -04:00 · 2020-04-04 21:43:59 -04:00 · 2020-04-04 21:41:43 -04:00 · 2020-04-04 21:27:53 -04:00 · 2020-04-04 21:27:43 -04:00 · 2020-04-04 16:47:36 -04:00
50 changed files with 1481 additions and 451 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -0,0 +1,68 @@
+version: 2
+jobs:
+  build-master:
+    environment:
+      DOKKU_VERSION: master
+    machine:
+      docker_layer_caching: false
+      image: ubuntu-1604:201903-01
+    steps:
+      - checkout
+      - run: pyenv global 3.7.0
+      - run: make setup
+      - run: sudo sysctl -w vm.max_map_count=262144
+      - run:
+          command: |
+            make generate;
+            if [[ $(git diff) ]]; then
+              echo "Please run `make generate`";
+              git status --short;
+              git diff;
+              exit 1;
+            fi
+      - run: make test
+      - store_artifacts:
+          path: build
+          destination: build
+      - store_artifacts:
+          path: tmp/test-results
+          destination: test-results
+      - store_test_results:
+          path: test-results
+
+  build-version:
+    environment:
+      DOKKU_VERSION: v0.19.0
+    machine:
+      docker_layer_caching: false
+      image: ubuntu-1604:201903-01
+    steps:
+      - checkout
+      - run: pyenv global 3.7.0
+      - run: make setup
+      - run: sudo sysctl -w vm.max_map_count=262144
+      - run:
+          command: |
+            make generate;
+            if [[ $(git diff) ]]; then
+              echo "Please run `make generate`";
+              git status --short;
+              git diff;
+              exit 1;
+            fi
+      - run: make test
+      - store_artifacts:
+          path: build
+          destination: build
+      - store_artifacts:
+          path: tmp/test-results
+          destination: test-results
+      - store_test_results:
+          path: test-results
+
+workflows:
+  version: 2
+  build:
+    jobs:
+      - "build-master"
+      - "build-version"
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,9 +0,0 @@
-dist: trusty
-language: bash
-env:
-  - DOKKU_VERSION=master
-  - DOKKU_VERSION=v0.14.0
-  - DOKKU_VERSION=v0.12.0
-install: make setup
-script: make test
-after_failure: make report
--- a/29
+++ b/29
@@ -1,5 +1,9 @@
 HARDWARE = $(shell uname -m)
 SYSTEM_NAME  = $(shell uname -s | tr '[:upper:]' '[:lower:]')
+SHFMT_VERSION = 3.0.2
+XUNIT_TO_GITHUB_VERSION = 0.3.0
+XUNIT_READER_VERSION = 0.1.0
+

 bats:
 ifeq ($(SYSTEM_NAME),darwin)
@@ -28,7 +32,7 @@ ifneq ($(shell shfmt --version >/dev/null 2>&1 ; echo $$?),0)
 ifeq ($(shfmt),Darwin)
 	brew install shfmt
 else
-	wget -qO /tmp/shfmt https://github.com/mvdan/sh/releases/download/v2.6.2/shfmt_v2.6.2_linux_amd64
+	wget -qO /tmp/shfmt https://github.com/mvdan/sh/releases/download/v$(SHFMT_VERSION)/shfmt_v$(SHFMT_VERSION)_linux_amd64
 	chmod +x /tmp/shfmt
 	sudo mv /tmp/shfmt /usr/local/bin/shfmt
 endif
@@ -61,9 +65,15 @@ unit-tests:
 	@cd tests && echo "executing tests: $(shell cd tests ; ls *.bats | xargs)"
 	cd tests && bats --formatter bats-format-junit -e -T -o ../tmp/test-results/bats *.bats

+tmp/xunit-reader:
+	mkdir -p tmp
+	curl -o tmp/xunit-reader.tgz -sL https://github.com/josegonzalez/go-xunit-reader/releases/download/v$(XUNIT_READER_VERSION)/xunit-reader_$(XUNIT_READER_VERSION)_$(SYSTEM_NAME)_$(HARDWARE).tgz
+	tar xf tmp/xunit-reader.tgz -C tmp
+	chmod +x tmp/xunit-reader
+
 tmp/xunit-to-github:
 	mkdir -p tmp
-	curl -o tmp/xunit-to-github.tgz -sL https://github.com/josegonzalez/go-xunit-to-github/releases/download/v0.3.0/xunit-to-github_0.3.0_$(SYSTEM_NAME)_$(HARDWARE).tgz
+	curl -o tmp/xunit-to-github.tgz -sL https://github.com/josegonzalez/go-xunit-to-github/releases/download/v$(XUNIT_TO_GITHUB_VERSION)/xunit-to-github_$(XUNIT_TO_GITHUB_VERSION)_$(SYSTEM_NAME)_$(HARDWARE).tgz
 	tar xf tmp/xunit-to-github.tgz -C tmp
 	chmod +x tmp/xunit-to-github

@@ -73,7 +83,9 @@ setup:

 test: lint unit-tests

-report: tmp/xunit-to-github
+report: tmp/xunit-reader tmp/xunit-to-github
+	tmp/xunit-reader -p 'tmp/test-results/bats/*.xml'
+	tmp/xunit-reader -p 'tmp/test-results/shellcheck/*.xml'
 ifdef TRAVIS_REPO_SLUG
 ifdef GITHUB_ACCESS_TOKEN
 ifneq ($(TRAVIS_PULL_REQUEST),false)
@@ -81,3 +93,14 @@ ifneq ($(TRAVIS_PULL_REQUEST),false)
 endif
 endif
 endif
+
+.PHONY: clean
+clean:
+	rm -f README.md
+
+.PHONY: generate
+generate: clean README.md
+
+.PHONY: README.md
+README.md:
+	bin/generate
--- a/README.md
+++ b/README.md
@@ -1,78 +1,105 @@
 # dokku mysql [![Build Status](https://img.shields.io/travis/dokku/dokku-mysql.svg?branch=master "Build Status")](https://travis-ci.org/dokku/dokku-mysql) [![IRC Network](https://img.shields.io/badge/irc-freenode-blue.svg "IRC Freenode")](https://webchat.freenode.net/?channels=dokku)

-Official mysql plugin for dokku. Currently defaults to installing [mysql 5.7.25](https://hub.docker.com/_/mysql/).
+Official mysql plugin for dokku. Currently defaults to installing [mysql 5.7.28](https://hub.docker.com/_/mysql/).

-## requirements
+## Requirements

 - dokku 0.12.x+
 - docker 1.8.x

-## installation
+## Installation

 ```shell
 # on 0.12.x+
 sudo dokku plugin:install https://github.com/dokku/dokku-mysql.git mysql
 ```

-## commands
+## Commands

 ```
-mysql:app-links <app>          List all mysql service links for a given app
-mysql:backup <name> <bucket> (--use-iam) Create a backup of the mysql service to an existing s3 bucket
-mysql:backup-auth <name> <aws_access_key_id> <aws_secret_access_key> (<aws_default_region>) (<aws_signature_version>) (<endpoint_url>) Sets up authentication for backups on the mysql service
-mysql:backup-deauth <name>     Removes backup authentication for the mysql service
-mysql:backup-schedule <name> <schedule> <bucket> Schedules a backup of the mysql service
-mysql:backup-schedule-cat <name> Cat the contents of the configured backup cronfile for the service
-mysql:backup-set-encryption <name> <passphrase> Set a GPG passphrase for backups
-mysql:backup-unschedule <name> Unschedules the backup of the mysql service
-mysql:backup-unset-encryption <name> Removes backup encryption for future backups of the mysql service
-mysql:clone <name> <new-name>  Create container <new-name> then copy data from <name> into <new-name>
-mysql:connect <name>           Connect via mysql to a mysql service
-mysql:create <name>            Create a mysql service with environment variables
-mysql:destroy <name>           Delete the service, delete the data and stop its container if there are no links left
-mysql:enter <name> [command]   Enter or run a command in a running mysql service container
-mysql:exists <service>         Check if the mysql service exists
-mysql:export <name> > <file>   Export a dump of the mysql service database
-mysql:expose <name> [port]     Expose a mysql service on custom port if provided (random port otherwise)
-mysql:import <name> < <file>   Import a dump into the mysql service database
-mysql:info <name>              Print the connection information
-mysql:link <name> <app>        Link the mysql service to the app
-mysql:linked <name> <app>      Check if the mysql service is linked to an app
-mysql:list                     List all mysql services
-mysql:logs <name> [-t]         Print the most recent log(s) for this service
-mysql:promote <name> <app>     Promote service <name> as DATABASE_URL in <app>
-mysql:restart <name>           Graceful shutdown and restart of the mysql service container
-mysql:start <name>             Start a previously stopped mysql service
-mysql:stop <name>              Stop a running mysql service
-mysql:unexpose <name>          Unexpose a previously exposed mysql service
-mysql:unlink <name> <app>      Unlink the mysql service from the app
-mysql:upgrade <name>           Upgrade service <service> to the specified version
+mysql:app-links <app>                              # list all mysql service links for a given app
+mysql:backup <service> <bucket-name> [--use-iam]   # creates a backup of the mysql service to an existing s3 bucket
+mysql:backup-auth <service> <aws-access-key-id> <aws-secret-access-key> <aws-default-region> <aws-signature-version> <endpoint-url> # sets up authentication for backups on the mysql service
+mysql:backup-deauth <service>                      # removes backup authentication for the mysql service
+mysql:backup-schedule <service> <schedule> <bucket-name> [--use-iam] # schedules a backup of the mysql service
+mysql:backup-schedule-cat <service>                # cat the contents of the configured backup cronfile for the service
+mysql:backup-set-encryption <service> <passphrase> # sets encryption for all future backups of mysql service
+mysql:backup-unschedule <service>                  # unschedules the backup of the mysql service
+mysql:backup-unset-encryption <service>            # unsets encryption for future backups of the mysql service
+mysql:clone <service> <new-service> [--clone-flags...] # create container <new-name> then copy data from <name> into <new-name>
+mysql:connect <service>                            # connect to the service via the mysql connection tool
+mysql:create <service> [--create-flags...]         # create a mysql service
+mysql:destroy <service> [-f|--force]               # delete the mysql service/data/container if there are no links left
+mysql:enter <service>                              # enter or run a command in a running mysql service container
+mysql:exists <service>                             # check if the mysql service exists
+mysql:export <service>                             # export a dump of the mysql service database
+mysql:expose <service> <ports...>                  # expose a mysql service on custom port if provided (random port otherwise)
+mysql:import <service>                             # import a dump into the mysql service database
+mysql:info <service> [--single-info-flag]          # print the service information
+mysql:link <service> <app> [--link-flags...]       # link the mysql service to the app
+mysql:linked <service> <app>                       # check if the mysql service is linked to an app
+mysql:links <service>                              # list all apps linked to the mysql service
+mysql:list                                         # list all mysql services
+mysql:logs <service> [-t|--tail]                   # print the most recent log(s) for this service
+mysql:promote <service> <app>                      # promote service <service> as DATABASE_URL in <app>
+mysql:restart <service>                            # graceful shutdown and restart of the mysql service container
+mysql:start <service>                              # start a previously stopped mysql service
+mysql:stop <service>                               # stop a running mysql service
+mysql:unexpose <service>                           # unexpose a previously exposed mysql service
+mysql:unlink <service> <app>                       # unlink the mysql service from the app
+mysql:upgrade <service> [--upgrade-flags...]       # upgrade service <service> to the specified versions
 ```

-## usage
+## Usage
+
+Help for any commands can be displayed by specifying the command as an argument to mysql:help. Please consult the `mysql:help` command for any undocumented commands.
+
+### Basic Usage
+
+### create a mysql service

 ```shell
-# create a mysql service named lolipop
-dokku mysql:create lolipop
+# usage
+dokku mysql:create <service> [--create-flags...]
+```

-# you can also specify the image and image
-# version to use for the service
-# it *must* be compatible with the
-# official mysql image
-export MYSQL_IMAGE="mysql"
-export MYSQL_IMAGE_VERSION="5.5"
-dokku mysql:create lolipop
+Create a mysql service named lolipop:

-# you can also specify custom environment
-# variables to start the mysql service
-# in semi-colon separated form
-export MYSQL_CUSTOM_ENV="USER=alpha;HOST=beta"
+```shell
 dokku mysql:create lolipop
+```

-# get connection information as follows
+You can also specify the image and image version to use for the service. It *must* be compatible with the ${plugin_image} image.
+
+```shell
+export DATABASE_IMAGE="${PLUGIN_IMAGE}"
+export DATABASE_IMAGE_VERSION="${PLUGIN_IMAGE_VERSION}"
+dokku mysql:create lolipop
+```
+
+You can also specify custom environment variables to start the mysql service in semi-colon separated form.
+
+```shell
+export DATABASE_CUSTOM_ENV="USER=alpha;HOST=beta"
+dokku mysql:create lolipop
+```
+
+### print the service information
+
+```shell
+# usage
+dokku mysql:info <service> [--single-info-flag]
+```
+
+Get connection information as follows:
+
+```shell
 dokku mysql:info lolipop
+```

-# you can also retrieve a specific piece of service info via flags
+You can also retrieve a specific piece of service info via flags:
+
+```shell
 dokku mysql:info lolipop --config-dir
 dokku mysql:info lolipop --data-dir
 dokku mysql:info lolipop --dsn
@@ -83,165 +110,494 @@ dokku mysql:info lolipop --links
 dokku mysql:info lolipop --service-root
 dokku mysql:info lolipop --status
 dokku mysql:info lolipop --version
+```

-# a bash prompt can be opened against a running service
-# filesystem changes will not be saved to disk
-dokku mysql:enter lolipop
+### list all mysql services

-# you may also run a command directly against the service
-# filesystem changes will not be saved to disk
-dokku mysql:enter lolipop ls -lah /
+```shell
+# usage
+dokku mysql:list 
+```

-# a mysql service can be linked to a
-# container this will use native docker
-# links via the docker-options plugin
-# here we link it to our 'playground' app
-# NOTE: this will restart your app
-dokku mysql:link lolipop playground
+List all services:

-# the following environment variables will be set automatically by docker (not
-# on the app itself, so they won’t be listed when calling dokku config)
-#
-#   DOKKU_MYSQL_LOLIPOP_NAME=/lolipop/DATABASE
-#   DOKKU_MYSQL_LOLIPOP_PORT=tcp://172.17.0.1:3306
-#   DOKKU_MYSQL_LOLIPOP_PORT_3306_TCP=tcp://172.17.0.1:3306
-#   DOKKU_MYSQL_LOLIPOP_PORT_3306_TCP_PROTO=tcp
-#   DOKKU_MYSQL_LOLIPOP_PORT_3306_TCP_PORT=3306
-#   DOKKU_MYSQL_LOLIPOP_PORT_3306_TCP_ADDR=172.17.0.1
-#
-# and the following will be set on the linked application by default
-#
-#   DATABASE_URL=mysql://mysql:SOME_PASSWORD@dokku-mysql-lolipop:3306/lolipop
-#
-# NOTE: the host exposed here only works internally in docker containers. If
-# you want your container to be reachable from outside, you should use `expose`.
+```shell
+dokku mysql:list
+```

-# another service can be linked to your app
-dokku mysql:link other_service playground
+### print the most recent log(s) for this service

-# since DATABASE_URL is already in use, another environment variable will be
-# generated automatically
-#
-#   DOKKU_MYSQL_BLUE_URL=mysql://mysql:ANOTHER_PASSWORD@dokku-mysql-other-service:3306/other_service
+```shell
+# usage
+dokku mysql:logs <service> [-t|--tail]
+```

-# you can then promote the new service to be the primary one
-# NOTE: this will restart your app
-dokku mysql:promote other_service playground
+You can tail logs for a particular service:

-# this will replace DATABASE_URL with the url from other_service and generate
-# another environment variable to hold the previous value if necessary.
-# you could end up with the following for example:
-#
-#   DATABASE_URL=mysql://mysql:ANOTHER_PASSWORD@dokku-mysql-other_service:3306/other_service
-#   DOKKU_MYSQL_BLUE_URL=mysql://mysql:ANOTHER_PASSWORD@dokku-mysql-other-service:3306/other_service
-#   DOKKU_MYSQL_SILVER_URL=mysql://mysql:SOME_PASSWORD@dokku-mysql-lolipop:3306/lolipop
-
-# you can also unlink a mysql service
-# NOTE: this will restart your app and unset related environment variables
-dokku mysql:unlink lolipop playground
-
-# you can tail logs for a particular service
+```shell
 dokku mysql:logs lolipop
-dokku mysql:logs lolipop -t # to tail
-
-# you can dump the database
-dokku mysql:export lolipop > lolipop.sql
-
-# you can import a dump
-dokku mysql:import lolipop < database.sql
-
-# you can clone an existing database to a new one
-dokku mysql:clone lolipop new_database
-
-# finally, you can destroy the container
-dokku mysql:destroy lolipop
 ```

-## Changing database adapter
-
-It's possible to change the protocol for DATABASE_URL by setting
-the environment variable MYSQL_DATABASE_SCHEME on the app:
+By default, logs will not be tailed, but you can do this with the --tail flag:

+```shell
+dokku mysql:logs lolipop --tail
 ```
-dokku config:set playground MYSQL_DATABASE_SCHEME=mysql2
+
+### link the mysql service to the app
+
+```shell
+# usage
+dokku mysql:link <service> <app> [--link-flags...]
+```
+
+A mysql service can be linked to a container. This will use native docker links via the docker-options plugin. Here we link it to our 'playground' app.
+
+> NOTE: this will restart your app
+
+```shell
 dokku mysql:link lolipop playground
 ```

-Will cause DATABASE_URL to be set as
-mysql2://mysql:SOME_PASSWORD@dokku-mysql-lolipop:3306/lolipop
+The following environment variables will be set automatically by docker (not on the app itself, so they won’t be listed when calling dokku config):

-CAUTION: Changing MYSQL_DATABASE_SCHEME after linking will cause dokku to
-believe the service is not linked when attempting to use `dokku mysql:unlink`
-or `dokku mysql:promote`.
-You should be able to fix this by
+```
+DOKKU_DATABASE_LOLIPOP_NAME=/lolipop/DATABASE
+DOKKU_DATABASE_LOLIPOP_PORT=tcp://172.17.0.1:3306
+DOKKU_DATABASE_LOLIPOP_PORT_3306_TCP=tcp://172.17.0.1:3306
+DOKKU_DATABASE_LOLIPOP_PORT_3306_TCP_PROTO=tcp
+DOKKU_DATABASE_LOLIPOP_PORT_3306_TCP_PORT=3306
+DOKKU_DATABASE_LOLIPOP_PORT_3306_TCP_ADDR=172.17.0.1
+```

- Changing DATABASE_URL manually to the new value.
+The following will be set on the linked application by default:

-OR
+```
+DATABASE_URL=mysql://lolipop:SOME_PASSWORD@dokku-mysql-lolipop:3306/lolipop
+```

- Set MYSQL_DATABASE_SCHEME back to its original setting
- Unlink the service
- Change MYSQL_DATABASE_SCHEME to the desired setting
- Relink the service
+The host exposed here only works internally in docker containers. If you want your container to be reachable from outside, you should use the 'expose' subcommand. Another service can be linked to your app:

-## Configuration
+```shell
+dokku mysql:link other_service playground
+```

-It is possible to add custom configuration settings.
-`/etc/mysql/conf.d` is mapped to the output of `dokku mysql:info SERVICE --config-dir`
+It is possible to change the protocol for database_url by setting the environment variable database_database_scheme on the app. Doing so will after linking will cause the plugin to think the service is not linked, and we advise you to unlink before proceeding.

-Any files placed in this folder will be loaded. If a file is changed you will need
-to reload your database for the changes to take effect.
+```shell
+dokku config:set playground DATABASE_DATABASE_SCHEME=mysql2
+dokku mysql:link lolipop playground
+```

-For more information on configuration options see https://dev.mysql.com/doc/refman/5.7/en/option-files.html
+This will cause database_url to be set as:

-> Note: This plugin mounts a host directory into the container under `/etc/mysql/conf.d`. Custom images that have files in this directory will have those files overwritten by the mount.
+```
+mysql2://lolipop:SOME_PASSWORD@dokku-mysql-lolipop:3306/lolipop
+```
+
+### unlink the mysql service from the app
+
+```shell
+# usage
+dokku mysql:unlink <service> <app>
+```
+
+You can unlink a mysql service:
+
+> NOTE: this will restart your app and unset related environment variables
+
+```shell
+dokku mysql:unlink lolipop playground
+```
+
+### Service Lifecycle
+
+The lifecycle of each service can be managed through the following commands:
+
+### connect to the service via the mysql connection tool
+
+```shell
+# usage
+dokku mysql:connect <service>
+```
+
+Connect to the service via the mysql connection tool:
+
+```shell
+dokku mysql:connect lolipop
+```
+
+### enter or run a command in a running mysql service container
+
+```shell
+# usage
+dokku mysql:enter <service>
+```
+
+A bash prompt can be opened against a running service. Filesystem changes will not be saved to disk.
+
+```shell
+dokku mysql:enter lolipop
+```
+
+You may also run a command directly against the service. Filesystem changes will not be saved to disk.
+
+```shell
+dokku mysql:enter lolipop touch /tmp/test
+```
+
+### expose a mysql service on custom port if provided (random port otherwise)
+
+```shell
+# usage
+dokku mysql:expose <service> <ports...>
+```
+
+Expose the service on the service's normal ports, allowing access to it from the public interface (0. 0. 0. 0):
+
+```shell
+dokku mysql:expose lolipop ${PLUGIN_DATASTORE_PORTS[@]}
+```
+
+### unexpose a previously exposed mysql service
+
+```shell
+# usage
+dokku mysql:unexpose <service>
+```
+
+Unexpose the service, removing access to it from the public interface (0. 0. 0. 0):
+
+```shell
+dokku mysql:unexpose lolipop
+```
+
+### promote service <service> as DATABASE_URL in <app>
+
+```shell
+# usage
+dokku mysql:promote <service> <app>
+```
+
+If you have a mysql service linked to an app and try to link another mysql service another link environment variable will be generated automatically:
+
+```
+DOKKU_DATABASE_BLUE_URL=mysql://other_service:ANOTHER_PASSWORD@dokku-mysql-other-service:3306/other_service
+```
+
+You can promote the new service to be the primary one:
+
+> NOTE: this will restart your app
+
+```shell
+dokku mysql:promote other_service playground
+```
+
+This will replace database_url with the url from other_service and generate another environment variable to hold the previous value if necessary. You could end up with the following for example:
+
+```
+DATABASE_URL=mysql://other_service:ANOTHER_PASSWORD@dokku-mysql-other-service:3306/other_service
+DOKKU_DATABASE_BLUE_URL=mysql://other_service:ANOTHER_PASSWORD@dokku-mysql-other-service:3306/other_service
+DOKKU_DATABASE_SILVER_URL=mysql://lolipop:SOME_PASSWORD@dokku-mysql-lolipop:3306/lolipop
+```
+
+### start a previously stopped mysql service
+
+```shell
+# usage
+dokku mysql:start <service>
+```
+
+Start the service:
+
+```shell
+dokku mysql:start lolipop
+```
+
+### stop a running mysql service
+
+```shell
+# usage
+dokku mysql:stop <service>
+```
+
+Stop the service and the running container:
+
+```shell
+dokku mysql:stop lolipop
+```
+
+### graceful shutdown and restart of the mysql service container
+
+```shell
+# usage
+dokku mysql:restart <service>
+```
+
+Restart the service:
+
+```shell
+dokku mysql:restart lolipop
+```
+
+### upgrade service <service> to the specified versions
+
+```shell
+# usage
+dokku mysql:upgrade <service> [--upgrade-flags...]
+```
+
+You can upgrade an existing service to a new image or image-version:
+
+```shell
+dokku mysql:upgrade lolipop
+```
+
+### Service Automation
+
+Service scripting can be executed using the following commands:
+
+### list all mysql service links for a given app
+
+```shell
+# usage
+dokku mysql:app-links <app>
+```
+
+List all mysql services that are linked to the 'playground' app.
+
+```shell
+dokku mysql:app-links playground
+```
+
+### create container <new-name> then copy data from <name> into <new-name>
+
+```shell
+# usage
+dokku mysql:clone <service> <new-service> [--clone-flags...]
+```
+
+You can clone an existing service to a new one:
+
+```shell
+dokku mysql:clone lolipop lolipop-2
+```
+
+### check if the mysql service exists
+
+```shell
+# usage
+dokku mysql:exists <service>
+```
+
+Here we check if the lolipop mysql service exists.
+
+```shell
+dokku mysql:exists lolipop
+```
+
+### check if the mysql service is linked to an app
+
+```shell
+# usage
+dokku mysql:linked <service> <app>
+```
+
+Here we check if the lolipop mysql service is linked to the 'playground' app.
+
+```shell
+dokku mysql:linked lolipop playground
+```
+
+### list all apps linked to the mysql service
+
+```shell
+# usage
+dokku mysql:links <service>
+```
+
+List all apps linked to the 'lolipop' mysql service.
+
+```shell
+dokku mysql:links lolipop
+```
+
+### Data Management
+
+The underlying service data can be imported and exported with the following commands:
+
+### import a dump into the mysql service database
+
+```shell
+# usage
+dokku mysql:import <service>
+```
+
+Import a datastore dump:
+
+```shell
+dokku mysql:import lolipop < database.dump
+```
+
+### export a dump of the mysql service database
+
+```shell
+# usage
+dokku mysql:export <service>
+```
+
+By default, datastore output is exported to stdout:
+
+```shell
+dokku mysql:export lolipop
+```
+
+You can redirect this output to a file:
+
+```shell
+dokku mysql:export lolipop > lolipop.dump
+```

 ### Backups

 Datastore backups are supported via AWS S3 and S3 compatible services like [minio](https://github.com/minio/minio).

-You may skip the `backup-auth` step if your dokku install is running within EC2
-and has access to the bucket via an IAM profile. In that case, use the `--use-iam`
-option with the `backup` command.
+You may skip the `backup-auth` step if your dokku install is running within EC2 and has access to the bucket via an IAM profile. In that case, use the `--use-iam` option with the `backup` command.

 Backups can be performed using the backup commands:

+### sets up authentication for backups on the mysql service
+
+```shell
+# usage
+dokku mysql:backup-auth <service> <aws-access-key-id> <aws-secret-access-key> <aws-default-region> <aws-signature-version> <endpoint-url>
 ```
-# setup s3 backup authentication
+
+Setup s3 backup authentication:
+
+```shell
 dokku mysql:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY
-
-# remove s3 authentication
-dokku mysql:backup-deauth lolipop
-
-# backup the `lolipop` service to the `BUCKET_NAME` bucket on AWS
-dokku mysql:backup lolipop BUCKET_NAME
-
-# schedule a backup
-# CRON_SCHEDULE is a crontab expression, eg. "0 3 * * *" for each day at 3am
-dokku mysql:backup-schedule lolipop CRON_SCHEDULE BUCKET_NAME
-
-# cat the contents of the configured backup cronfile for the service
-dokku mysql:backup-schedule-cat lolipop
-
-# remove the scheduled backup from cron
-dokku mysql:backup-unschedule lolipop
 ```

-Backup auth can also be set up for different regions, signature versions and endpoints (e.g. for minio):
- 
-```
-# setup s3 backup authentication with different region
+Setup s3 backup authentication with different region:
+
+```shell
 dokku mysql:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION
- 
-# setup s3 backup authentication with different signature version and endpoint
+```
+
+Setup s3 backup authentication with different signature version and endpoint:
+
+```shell
 dokku mysql:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION AWS_SIGNATURE_VERSION ENDPOINT_URL
- 
-# more specific example for minio auth
+```
+
+More specific example for minio auth:
+
+```shell
 dokku mysql:backup-auth lolipop MINIO_ACCESS_KEY_ID MINIO_SECRET_ACCESS_KEY us-east-1 s3v4 https://YOURMINIOSERVICE
 ```

-## Disabling `docker pull` calls
+### removes backup authentication for the mysql service
+
+```shell
+# usage
+dokku mysql:backup-deauth <service>
+```
+
+Remove s3 authentication:
+
+```shell
+dokku mysql:backup-deauth lolipop
+```
+
+### creates a backup of the mysql service to an existing s3 bucket
+
+```shell
+# usage
+dokku mysql:backup <service> <bucket-name> [--use-iam]
+```
+
+Backup the 'lolipop' service to the 'my-s3-bucket' bucket on aws:
+
+```shell
+dokku mysql:backup lolipop my-s3-bucket --use-iam
+```
+
+### sets encryption for all future backups of mysql service
+
+```shell
+# usage
+dokku mysql:backup-set-encryption <service> <passphrase>
+```
+
+Set a gpg passphrase for backups:
+
+```shell
+dokku mysql:backup-set-encryption lolipop
+```
+
+### unsets encryption for future backups of the mysql service
+
+```shell
+# usage
+dokku mysql:backup-unset-encryption <service>
+```
+
+Unset a gpg encryption key for backups:
+
+```shell
+dokku mysql:backup-unset-encryption lolipop
+```
+
+### schedules a backup of the mysql service
+
+```shell
+# usage
+dokku mysql:backup-schedule <service> <schedule> <bucket-name> [--use-iam]
+```
+
+Schedule a backup:
+
+> 'schedule' is a crontab expression, eg. "0 3 * * *" for each day at 3am
+
+```shell
+dokku mysql:backup-schedule lolipop "0 3 * * *" my-s3-bucket
+```
+
+Schedule a backup and authenticate via iam:
+
+```shell
+dokku mysql:backup-schedule lolipop "0 3 * * *" my-s3-bucket --use-iam
+```
+
+### cat the contents of the configured backup cronfile for the service
+
+```shell
+# usage
+dokku mysql:backup-schedule-cat <service>
+```
+
+Cat the contents of the configured backup cronfile for the service:
+
+```shell
+dokku mysql:backup-schedule-cat lolipop
+```
+
+### unschedules the backup of the mysql service
+
+```shell
+# usage
+dokku mysql:backup-unschedule <service>
+```
+
+Remove the scheduled backup from cron:
+
+```shell
+dokku mysql:backup-unschedule lolipop
+```
+
+### Disabling `docker pull` calls

 If you wish to disable the `docker pull` calls that the plugin triggers, you may set the `MYSQL_DISABLE_PULL` environment variable to `true`. Once disabled, you will need to pull the service image you wish to deploy as shown in the `stderr` output.

-Please ensure the proper images are in place when `docker pull` is disabled.
+Please ensure the proper images are in place when `docker pull` is disabled.
--- a/bin/generate
+++ b/bin/generate
@@ -0,0 +1,404 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import print_function
+import os
+import re
+
+
+def compile(service, version, alias, scheme, ports, unimplemented, dokku_version):
+    return "\n\n".join([
+        header(service),
+        description(service, version),
+        requirements_section(dokku_version),
+        installation_section(service, dokku_version),
+        commands_section(service, alias, scheme, ports, unimplemented),
+        usage_section(service, alias, scheme, ports, unimplemented),
+    ]).replace("\n\n\n\n\n", "\n").replace("\n\n\n\n", "\n").replace("\n\n\n", "\n\n")
+
+
+def header(service):
+    return " ".join([
+        f"# dokku {service}",
+        f"[![Build Status](https://img.shields.io/travis/dokku/dokku-{service}.svg?branch=master \"Build Status\")](https://travis-ci.org/dokku/dokku-{service})",
+        f"[![IRC Network](https://img.shields.io/badge/irc-freenode-blue.svg \"IRC Freenode\")](https://webchat.freenode.net/?channels=dokku)",
+    ])
+
+
+def description(service, version):
+    return f"Official {service} plugin for dokku. Currently defaults to installing [{service} {version}](https://hub.docker.com/_/{service}/)."
+
+
+def requirements_section(dokku_version):
+    return "\n".join([
+        "## Requirements",
+        "",
+        f"- dokku {dokku_version}",
+        "- docker 1.8.x",
+    ])
+
+
+def installation_section(service, dokku_version):
+    return "\n".join([
+        "## Installation",
+        "",
+        "```shell",
+        f"# on {dokku_version}",
+        f"sudo dokku plugin:install https://github.com/dokku/dokku-{service}.git {service}",
+        "```",
+    ])
+
+
+def commands_section(service, alias, scheme, ports, unimplemented):
+    content = [
+        "## Commands",
+        "",
+        "```",
+    ]
+
+    subcommands = os.listdir("subcommands")
+    subcommands.sort()
+
+    command_list = []
+    descriptions = []
+    for filename in subcommands:
+        if filename in unimplemented:
+            continue
+        data = command_data(filename, service, alias, scheme, ports)
+        description = data["description"]
+        arguments = data["arguments_string"]
+
+        command_list.append(f"{service}:{filename} {arguments}")
+        descriptions.append(description)
+
+    maxlen = max(map(len, command_list))
+    if maxlen > 50:
+        maxlen = 50
+    for command, description in zip(command_list, descriptions):
+        space_count = maxlen - len(command)
+        content.append("{0}{1} # {2}".format(command, " " * space_count, description))
+
+    content.append("```")
+    return "\n".join(content)
+
+
+def usage_section(service, alias, scheme, ports, unimplemented):
+    return "\n\n".join([
+        "## Usage",
+        f"Help for any commands can be displayed by specifying the command as an argument to {service}:help. Please consult the `{service}:help` command for any undocumented commands.",
+        usage_intro(service, alias, scheme, ports, unimplemented),
+        usage_lifecycle(service, alias, scheme, ports, unimplemented),
+        usage_automation(service, alias, scheme, ports, unimplemented),
+        usage_data_management(service, alias, scheme, ports, unimplemented),
+        usage_backup(service, alias, scheme, ports, unimplemented),
+        usage_docker_pull(service, alias, scheme, ports, unimplemented),
+    ])
+
+
+def usage_intro(service, alias, scheme, ports, unimplemented):
+    commands = ["create", "info", "list", "logs", "link", "unlink"]
+    content = ["### Basic Usage"]
+
+    return fetch_commands_content(service, alias, scheme, ports, unimplemented, commands, content)
+
+
+def usage_lifecycle(service, alias, scheme, ports, unimplemented):
+    commands = ["connect", "enter", "expose", "unexpose", "promote", "start", "stop", "restart", "upgrade"]
+    content = [
+        "### Service Lifecycle",
+        "",
+        "The lifecycle of each service can be managed through the following commands:",
+        "",
+    ]
+
+    return fetch_commands_content(service, alias, scheme, ports, unimplemented, commands, content)
+
+
+def usage_automation(service, alias, scheme, ports, unimplemented):
+    commands = ["app-links", "clone", "exists", "linked", "links"]
+    content = [
+        "### Service Automation",
+        "",
+        "Service scripting can be executed using the following commands:",
+        "",
+    ]
+
+    return fetch_commands_content(service, alias, scheme, ports, unimplemented, commands, content)
+
+
+def usage_data_management(service, alias, scheme, ports, unimplemented):
+    commands = ["import", "export"]
+    content = [
+        "### Data Management",
+        "",
+        "The underlying service data can be imported and exported with the following commands:",
+        "",
+    ]
+
+    return fetch_commands_content(service, alias, scheme, ports, unimplemented, commands, content)
+
+
+def usage_backup(service, alias, scheme, ports, unimplemented):
+    commands = ["backup-auth", "backup-deauth", "backup", "backup-set-encryption", "backup-unset-encryption", "backup-schedule", "backup-schedule-cat", "backup-unschedule",]
+    content = [
+        "### Backups",
+        "",
+        "Datastore backups are supported via AWS S3 and S3 compatible services like [minio](https://github.com/minio/minio).",
+        "",
+        "You may skip the `backup-auth` step if your dokku install is running within EC2 and has access to the bucket via an IAM profile. In that case, use the `--use-iam` option with the `backup` command.",
+        "",
+        "Backups can be performed using the backup commands:",
+        "",
+    ]
+
+    return fetch_commands_content(service, alias, scheme, ports, unimplemented, commands, content)
+
+
+def usage_docker_pull(service, alias, scheme, ports, unimplemented):
+    service_prefix = service.upper()
+    return "\n".join([
+        "### Disabling `docker pull` calls",
+        "",
+        f"If you wish to disable the `docker pull` calls that the plugin triggers, you may set the `{service_prefix}_DISABLE_PULL` environment variable to `true`. Once disabled, you will need to pull the service image you wish to deploy as shown in the `stderr` output.",
+        "",
+        "Please ensure the proper images are in place when `docker pull` is disabled.",
+    ])
+
+
+def fetch_commands_content(service, alias, scheme, ports, unimplemented, commands, content):
+    i = 0
+    for command in commands:
+        output = command_help(command, service, alias, scheme, ports, unimplemented)
+        if output == "":
+            continue
+        content.append(output)
+        i += 1
+
+    if i == 0:
+        return ""
+
+    return "\n".join(content)
+
+
+def parse_args(line):
+    line = line.strip()
+    arguments = []
+    for arg in re.findall("([A-Z_]+)", line):
+        arg = arg.replace("_", "-").lower()
+        if arg.endswith("optional-flag"):
+            arg = arg.replace("-optional-flag", "")
+            arguments.append(f"[--{arg}]")
+        elif arg.endswith("-flag"):
+            if arg == "info-flag":
+                arguments.append(f"[--single-info-flag]")
+            else:
+                arg = arg.replace("-flag", "")
+                first_letter = arg[0]
+                arguments.append(f"[-{first_letter}|--{arg}]")
+        elif arg.endswith("-flags-list"):
+            arg = arg.replace("-list", "")
+            arguments.append(f"[--{arg}...]")
+        elif arg.endswith("list"):
+            arg = arg.replace("-list", "")
+            arguments.append(f"<{arg}...>")
+        else:
+            arguments.append(f"<{arg}>")
+    return " ".join(arguments)
+
+
+def command_help(command, service, alias, scheme, ports, unimplemented):
+    if command in unimplemented:
+        return ""
+
+    data = command_data(command, service, alias, scheme, ports)
+    content = [
+        f"### {data['description']}",
+        "",
+        "```shell",
+        "# usage",
+        f"dokku {service}:{command} {data['arguments_string']}",
+        "```",
+    ]
+
+    # if len(data["arguments"]) > 0:
+    #     content.append("")
+    #     content.append("arguments:")
+    #     content.append("")
+    # for argument in data["arguments"]:
+    #     content.append(f"- {argument}")
+
+    # if len(data["flags"]) > 0:
+    #     content.append("")
+    #     content.append("flags:")
+    #     content.append("")
+    # for flag in data["flags"]:
+    #     content.append(f"- {flag}")
+
+    if len(data["examples"]) > 0:
+        content.append("")
+        content.append(data["examples"])
+
+    return "\n" + "\n".join(content)
+
+
+def command_data(command, service, alias, scheme, ports):
+    description = None
+    arguments = []
+    arguments_string = ""
+    example_lines = []
+    flags = []
+    with open(os.path.join("subcommands", command)) as f:
+        for line in f.readlines():
+            line = line.strip()
+            line = line.replace("$PLUGIN_SERVICE", service)
+            line = line.replace("$PLUGIN_COMMAND_PREFIX", service)
+            line = line.replace("${PLUGIN_COMMAND_PREFIX}", service)
+            line = line.replace("${PLUGIN_DEFAULT_ALIAS}", alias)
+            line = line.replace("${PLUGIN_SCHEME}", scheme)
+            line = line.replace("${PLUGIN_DATASTORE_PORTS[0]}", ports[0])
+
+            if "declare desc" in line:
+                description = re.search('"(.+)"', line).group(1)
+            elif "$1" in line:
+                arguments_string = parse_args(line)
+            elif line.startswith("#A "):
+                argument = line.replace("#A ", "")
+                parts = [a.strip() for a in argument.split(",", 1)]
+                arguments.append(f"`{parts[0]}`: {parts[1]}")
+            elif line.startswith("#F "):
+                flag = line.replace("#F ", "")
+                parts = [a.strip() for a in flag.split(",", 1)]
+                flags.append(f"`{parts[0]}`: {parts[1]}")
+            elif line.startswith("#E "):
+                example_lines.append(line.replace("#E ", ""))
+
+    examples = []
+    sentence_lines = []
+    command_lines = []
+    codeblock_lines = []
+    blockquote_lines = []
+    for line in example_lines:
+        if line.startswith("export") or line.startswith("dokku"):
+            if len(blockquote_lines) > 0:
+                examples.append("\n" + process_blockquote(blockquote_lines))
+                blockquote_lines = []
+            if len(codeblock_lines) > 0:
+                examples.append("\n" + process_codeblock(codeblock_lines))
+                codeblock_lines = []
+            if len(sentence_lines) > 0:
+                examples.append("\n" + process_sentence(sentence_lines))
+                sentence_lines = []
+
+            command_lines.append(line)
+        elif line.startswith("    "):
+            if len(blockquote_lines) > 0:
+                examples.append("\n" + process_blockquote(blockquote_lines))
+                blockquote_lines = []
+            if len(command_lines) > 0:
+                examples.append("\n" + process_command(command_lines))
+                command_lines = []
+            if len(sentence_lines) > 0:
+                examples.append("\n" + process_sentence(sentence_lines))
+                sentence_lines = []
+
+            codeblock_lines.append(line.strip())
+        elif line.startswith(">"):
+            if len(codeblock_lines) > 0:
+                examples.append("\n" + process_codeblock(codeblock_lines))
+                codeblock_lines = []
+            if len(command_lines) > 0:
+                examples.append("\n" + process_command(command_lines))
+                command_lines = []
+            if len(sentence_lines) > 0:
+                examples.append("\n" + process_sentence(sentence_lines))
+                sentence_lines = []
+
+            blockquote_lines.append(line)
+        else:
+            if len(blockquote_lines) > 0:
+                examples.append("\n" + process_blockquote(blockquote_lines))
+                blockquote_lines = []
+            if len(codeblock_lines) > 0:
+                examples.append("\n" + process_codeblock(codeblock_lines))
+                codeblock_lines = []
+            if len(command_lines) > 0:
+                examples.append("\n" + process_command(command_lines))
+                command_lines = []
+
+            sentence_lines.append(line)
+
+    if len(blockquote_lines) > 0:
+        examples.append("\n" + process_blockquote(blockquote_lines))
+        blockquote_lines = []
+    if len(codeblock_lines) > 0:
+        examples.append("\n" + process_codeblock(codeblock_lines))
+        codeblock_lines = []
+    if len(command_lines) > 0:
+        examples.append("\n" + process_command(command_lines))
+        command_lines = []
+    if len(sentence_lines) > 0:
+        examples.append("\n" + process_sentence(sentence_lines))
+        sentence_lines = []
+
+    return {
+        "description": description,
+        "arguments_string": arguments_string,
+        "arguments": arguments,
+        "flags": flags,
+        "examples": "\n".join(examples).strip(),
+    }
+
+
+def process_sentence(sentence_lines):
+    sentence_lines = " ".join(sentence_lines)
+    sentences = ". ".join(i.strip().capitalize() for i in sentence_lines.split(".")).strip()
+    if not sentences.endswith(".") and not sentences.endswith(":"):
+        sentences += ":"
+    return sentences
+
+
+def process_blockquote(blockquote_lines):
+    return "\n".join(blockquote_lines)
+
+
+def process_command(command_lines):
+    command_lines = "\n".join(command_lines)
+    return f"```shell\n{command_lines}\n```"
+
+
+def process_codeblock(codeblock_lines):
+    codeblock_lines = "\n".join(codeblock_lines)
+    return f"```\n{codeblock_lines}\n```"
+
+
+def main():
+    service = None
+    version = None
+    alias = None
+    unimplemented = []
+    with open("config") as f:
+        for line in f.readlines():
+            if "IMAGE_VERSION=${" in line:
+                version = re.search('"(.+)"', line).group(1)
+            if "PLUGIN_COMMAND_PREFIX=" in line:
+                service = re.search('"(.+)"', line).group(1)
+            if "PLUGIN_DEFAULT_ALIAS=" in line:
+                alias = re.search('"(.+)"', line).group(1)
+            if "PLUGIN_SCHEME=" in line:
+                scheme = re.search('"(.+)"', line).group(1)
+            if "PLUGIN_DATASTORE_PORTS=" in line:
+                ports = re.search('\((.+)\)', line).group(1).split(" ")
+            if "PLUGIN_UNIMPLEMENTED_SUBCOMMANDS=" in line:
+                match = re.search('\((.+)\)', line)
+                if match is not None:
+                    unimplemented = [s.strip('"') for s in match.group(1).split(" ")]
+
+    text = compile(service, version, alias, scheme, ports, unimplemented, "0.12.x+")
+
+    base_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+    readme_file = os.path.join(base_path, 'README.md')
+    with open(readme_file, 'w') as f:
+        f.write(text)
+
+
+if __name__ == "__main__":
+    main()
--- a/3
+++ b/3
@@ -2,7 +2,8 @@
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
 [[ " help $PLUGIN_COMMAND_PREFIX:help $PLUGIN_COMMAND_PREFIX $PLUGIN_COMMAND_PREFIX:default " == *" $1 "* ]] || [[ "$1" == "$PLUGIN_COMMAND_PREFIX:"* ]] || exit "$DOKKU_NOT_IMPLEMENTED_EXIT"
 source "$PLUGIN_BASE_PATH/common/functions"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x

 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/help-functions"

--- a/318
+++ b/318
@@ -1,11 +1,13 @@
 #!/usr/bin/env bash
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_AVAILABLE_PATH/config/functions"

 docker_ports_options() {
  declare desc="Exports a list of exposed ports"
  declare PORTS=("$@")
-  for (( i=0; i < ${#PLUGIN_DATASTORE_PORTS[@]}; i++ )); do
+  for ((i = 0; i < ${#PLUGIN_DATASTORE_PORTS[@]}; i++)); do
    echo -n "-p ${PORTS[i]}:${PLUGIN_DATASTORE_PORTS[i]} "
  done
 }
@@ -13,25 +15,29 @@ docker_ports_options() {
 get_container_ip() {
  declare desc="Retrieves the ip address of a container"
  declare CONTAINER_ID="$1"
-  docker inspect --format '{{ .NetworkSettings.IPAddress }}' "$CONTAINER_ID"
+  docker inspect --format '{{ .NetworkSettings.IPAddress }}' "$CONTAINER_ID" 2>/dev/null
 }

 get_database_name() {
  declare desc="Retrieves a sanitized database name"
-  declare DATABASE="$1"
-  # some datastores do not like special characters in database names
-  # so we need to normalize them out
-  echo "$DATABASE" | tr .- _
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+
+  if [[ ! -f "$SERVICE_ROOT/DATABASE_NAME" ]]; then
+    echo "$SERVICE" > "$SERVICE_ROOT/DATABASE_NAME"
+  fi
+
+  cat "$SERVICE_ROOT/DATABASE_NAME"
 }

 get_random_ports() {
  declare desc="Retrieves N random ports"
  declare iterations="${1:-1}"
-  for (( i=0; i < iterations; i++ )); do
+  for ((i = 0; i < iterations; i++)); do
    local port=$RANDOM
    local quit=0
    while [ "$quit" -ne 1 ]; do
-      netstat -an | grep $port > /dev/null
+      netstat -an | grep $port >/dev/null
      # shellcheck disable=SC2181
      if [ $? -gt 0 ]; then
        quit=1
@@ -59,7 +65,7 @@ is_container_status() {
  declare desc="Returns 0 or 1 depending upon whether a given container has a certain status"
  declare CID="$1" STATUS="$2"
  local TEMPLATE="{{.State.$STATUS}}"
-  local CONTAINER_STATUS=$(docker inspect -f "$TEMPLATE" "$CID" 2> /dev/null || true)
+  local CONTAINER_STATUS=$(docker inspect -f "$TEMPLATE" "$CID" 2>/dev/null || true)

  if [[ "$CONTAINER_STATUS" == "true" ]]; then
    return 0
@@ -83,6 +89,18 @@ is_implemented_command() {
  return 0
 }

+is_valid_service_name() {
+  declare desc="Validates a service name"
+  declare SERVICE="$1"
+  [[ -z "$SERVICE" ]] && return 1
+
+  if [[ "$SERVICE" =~ ^[A-Za-z0-9_-]+$ ]]; then
+    return 0
+  fi
+
+  return 1
+}
+
 remove_from_links_file() {
  declare desc="Removes an app from the service link file"
  declare SERVICE="$1" APP="$2"
@@ -97,18 +115,32 @@ remove_from_links_file() {
  sort "$LINKS_FILE" -u -o "$LINKS_FILE"
 }

-service_dns_hostname() {
-  declare desc="Retrieves the alias of a service"
-  declare SERVICE="$1"
-  local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  echo "$SERVICE_NAME" | tr ._ -
+retry-docker-command() {
+  local ID="$1" COMMAND="$2"
+  local i=0 success=false
+  until [ $i -ge 100 ]; do
+    set +e
+    docker exec -it "$ID" sh -c "$COMMAND" 2>/dev/null
+    exit_code=$?
+    set -e
+    if [[ "$exit_code" == 0 ]]; then
+      success=true
+      break
+    fi
+    i=$((i + 1))
+    sleep 1
+  done
+  if [[ $i -gt 0 ]]; then
+    dokku_log_verbose "Container command retried ${i} time(s): ${COMMAND}"
+  fi
+  [[ "$success" == "true" ]] || dokku_log_fail "Failed to run command: ${COMMAND}"
 }

 service_alternative_alias() {
  declare desc="Retrieves an alternative alias for a service"
  declare EXISTING_CONFIG="$1"
  local COLORS=(AQUA BLACK BLUE FUCHSIA GRAY GREEN LIME MAROON NAVY OLIVE PURPLE RED SILVER TEAL WHITE YELLOW)
-  local ALIAS;
+  local ALIAS

  for COLOR in "${COLORS[@]}"; do
    ALIAS="${PLUGIN_ALT_ALIAS}_${COLOR}"
@@ -126,11 +158,11 @@ service_app_links() {
  declare APP="$1"
  local SERVICE LINKED_APP

-  pushd "$PLUGIN_DATA_ROOT" > /dev/null
+  pushd "$PLUGIN_DATA_ROOT" >/dev/null
  for SERVICE in *; do
    [[ -f "$SERVICE/LINKS" ]] || continue
    for LINKED_APP in $(<"$SERVICE/LINKS"); do
-      if [[ "$LINKED_APP" == "$APP" ]] ; then
+      if [[ "$LINKED_APP" == "$APP" ]]; then
        echo "$SERVICE"
      fi
    done
@@ -159,10 +191,10 @@ service_backup() {
  TMPDIR=$(mktemp -d)
  trap 'rm -rf "$TMPDIR" > /dev/null' RETURN INT TERM EXIT

-  docker inspect "$ID" &> /dev/null || dokku_log_fail "Service container does not exist"
+  docker inspect "$ID" &>/dev/null || dokku_log_fail "Service container does not exist"
  is_container_status "$ID" "Running" || dokku_log_fail "Service container is not running"

-  (service_export "$SERVICE" > "${TMPDIR}/export")
+  (service_export "$SERVICE" >"${TMPDIR}/export")

  # Build parameter list for s3backup tool
  BACKUP_PARAMETERS="$BACKUP_PARAMETERS -e BUCKET_NAME=$BUCKET_NAME"
@@ -186,7 +218,7 @@ service_backup() {
  fi

  # shellcheck disable=SC2086
-  docker run --rm $BACKUP_PARAMETERS dokku/s3backup:0.9.4
+  docker run --rm $BACKUP_PARAMETERS "$PLUGIN_S3BACKUP_IMAGE"
 }

 service_backup_auth() {
@@ -195,19 +227,19 @@ service_backup_auth() {
  local SERVICE_BACKUP_ROOT="$PLUGIN_DATA_ROOT/$SERVICE/backup"

  mkdir "$SERVICE_BACKUP_ROOT"
-  echo "$AWS_ACCESS_KEY_ID" > "$SERVICE_BACKUP_ROOT/AWS_ACCESS_KEY_ID"
-  echo "$AWS_SECRET_ACCESS_KEY" > "$SERVICE_BACKUP_ROOT/AWS_SECRET_ACCESS_KEY"
+  echo "$AWS_ACCESS_KEY_ID" >"$SERVICE_BACKUP_ROOT/AWS_ACCESS_KEY_ID"
+  echo "$AWS_SECRET_ACCESS_KEY" >"$SERVICE_BACKUP_ROOT/AWS_SECRET_ACCESS_KEY"

  if [[ -n "$AWS_DEFAULT_REGION" ]]; then
-    echo "$AWS_DEFAULT_REGION" > "$SERVICE_BACKUP_ROOT/AWS_DEFAULT_REGION"
+    echo "$AWS_DEFAULT_REGION" >"$SERVICE_BACKUP_ROOT/AWS_DEFAULT_REGION"
  fi

  if [[ -n "$AWS_SIGNATURE_VERSION" ]]; then
-    echo "$AWS_SIGNATURE_VERSION" > "$SERVICE_BACKUP_ROOT/AWS_SIGNATURE_VERSION"
+    echo "$AWS_SIGNATURE_VERSION" >"$SERVICE_BACKUP_ROOT/AWS_SIGNATURE_VERSION"
  fi

  if [[ -n "$ENDPOINT_URL" ]]; then
-    echo "$ENDPOINT_URL" > "$SERVICE_BACKUP_ROOT/ENDPOINT_URL"
+    echo "$ENDPOINT_URL" >"$SERVICE_BACKUP_ROOT/ENDPOINT_URL"
  fi
 }

@@ -231,7 +263,7 @@ service_backup_schedule() {
    dokku_log_fail "Invalid flag provided, only '--use-iam' allowed"
  fi

-  echo "${SCHEDULE} dokku ${DOKKU_BIN} ${PLUGIN_COMMAND_PREFIX}:backup ${SERVICE} ${BUCKET_NAME} ${USE_IAM_OPTIONAL_FLAG}" > "$TMP_CRON_FILE"
+  echo "${SCHEDULE} dokku ${DOKKU_BIN} ${PLUGIN_COMMAND_PREFIX}:backup ${SERVICE} ${BUCKET_NAME} ${USE_IAM_OPTIONAL_FLAG}" >"$TMP_CRON_FILE"
  sudo /bin/mv "$TMP_CRON_FILE" "$CRON_FILE"
  sudo /bin/chown root:root "$CRON_FILE"
  sudo /bin/chmod 644 "$CRON_FILE"
@@ -249,14 +281,6 @@ service_backup_schedule_cat() {
  cat "$CRON_FILE"
 }

-service_backup_unschedule() {
-  declare desc="unschedules the backup of the service"
-  declare SERVICE="$1"
-  local CRON_FILE="/etc/cron.d/dokku-${PLUGIN_COMMAND_PREFIX}-${SERVICE}"
-
-  sudo /bin/rm -f "$CRON_FILE"
-}
-
 service_backup_set_encryption() {
  declare desc="Sets up backup encryption"
  declare SERVICE="$1" ENCRYPTION_KEY="$2"
@@ -264,7 +288,15 @@ service_backup_set_encryption() {
  local SERVICE_BACKUP_ENCRYPTION_ROOT="${SERVICE_ROOT}/backup-encryption/"

  mkdir "$SERVICE_BACKUP_ENCRYPTION_ROOT"
-  echo "$ENCRYPTION_KEY" > "${SERVICE_BACKUP_ENCRYPTION_ROOT}/ENCRYPTION_KEY"
+  echo "$ENCRYPTION_KEY" >"${SERVICE_BACKUP_ENCRYPTION_ROOT}/ENCRYPTION_KEY"
+}
+
+service_backup_unschedule() {
+  declare desc="unschedules the backup of the service"
+  declare SERVICE="$1"
+  local CRON_FILE="/etc/cron.d/dokku-${PLUGIN_COMMAND_PREFIX}-${SERVICE}"
+
+  sudo /bin/rm -f "$CRON_FILE"
 }

 service_backup_unset_encryption() {
@@ -290,19 +322,26 @@ service_container_rm() {
  fi

  dokku_log_verbose_quiet "Removing container"
-  docker update --restart=no "$SERVICE_NAME" > /dev/null 2>&1
-  if ! docker rm "$SERVICE_NAME" > /dev/null 2>&1; then
+  docker update --restart=no "$SERVICE_NAME" >/dev/null 2>&1
+  if ! docker rm "$SERVICE_NAME" >/dev/null 2>&1; then
    dokku_log_fail "Unable to remove container for service $SERVICE"
  fi
 }

+service_dns_hostname() {
+  declare desc="Retrieves the alias of a service"
+  declare SERVICE="$1"
+  local SERVICE_NAME="$(get_service_name "$SERVICE")"
+  echo "$SERVICE_NAME" | tr ._ -
+}
+
 service_enter() {
  declare desc="enters running app container of specified proc type"
  declare SERVICE="$1" && shift 1
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local ID="$(cat "$SERVICE_ROOT/ID")"

-  docker inspect "$ID" &> /dev/null || dokku_log_fail "Service container does not exist"
+  docker inspect "$ID" &>/dev/null || dokku_log_fail "Service container does not exist"
  is_container_status "$ID" "Running" || dokku_log_fail "Service container is not running"

  local EXEC_CMD=""
@@ -318,7 +357,7 @@ service_exposed_ports() {
  local PORT_FILE="$SERVICE_ROOT/PORT"
  [[ ! -f $PORT_FILE ]] && echo '-' && return 0
  local PORTS=($(cat "$PORT_FILE"))
-  for (( i=0; i < ${#PLUGIN_DATASTORE_PORTS[@]}; i++ )); do
+  for ((i = 0; i < ${#PLUGIN_DATASTORE_PORTS[@]}; i++)); do
    echo -n "${PLUGIN_DATASTORE_PORTS[i]}->${PORTS[i]} "
  done
 }
@@ -327,7 +366,7 @@ service_image_exists() {
  declare desc="Checks if the current image exists"
  local IMAGE="$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION"

-  if [[ "$(docker images -q "$IMAGE" 2> /dev/null)" == "" ]]; then
+  if [[ "$(docker images -q "$IMAGE" 2>/dev/null)" == "" ]]; then
    return 1
  fi

@@ -356,7 +395,7 @@ service_info() {
    "--version: $(service_version "$SERVICE")"
  )
  if [[ -z "$INFO_FLAG" ]]; then
-    dokku_log_info2 "Container Information"
+    dokku_log_info2 "$SERVICE $PLUGIN_COMMAND_PREFIX service information"
    for flag in "${flag_map[@]}"; do
      key="$(echo "${flag#--}" | cut -f1 -d' ' | tr - ' ')"
      dokku_log_verbose "$(printf "%-20s %-25s" "${key^}" "${flag#*: }")"
@@ -415,10 +454,10 @@ service_link() {

  [[ -n $LINK ]] && dokku_log_fail "Already linked as $LINK"
  touch "$LINKS_FILE"
-  echo "$APP" >> "$LINKS_FILE"
+  echo "$APP" >>"$LINKS_FILE"
  sort "$LINKS_FILE" -u -o "$LINKS_FILE"

-  if declare -f -F add_passed_docker_option > /dev/null; then
+  if declare -f -F add_passed_docker_option >/dev/null; then
    # shellcheck disable=SC2034
    local passed_phases=(build deploy run)
    add_passed_docker_option passed_phases[@] "--link $SERVICE_NAME:$SERVICE_DNS_HOSTNAME"
@@ -430,33 +469,42 @@ service_link() {
 }

 service_linked_apps() {
-  declare desc="Lists all applications linked to a service"
+  declare desc="Lists all apps linked to a service for info output"
  declare SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local LINKS_FILE="$SERVICE_ROOT/LINKS"

  touch "$LINKS_FILE"
-  [[ -z $(< "$LINKS_FILE") ]] && echo '-' && return 0
+  [[ -z $(<"$LINKS_FILE") ]] && echo '-' && return 0

-  tr '\n' ' ' < "$LINKS_FILE"
+  tr '\n' ' ' <"$LINKS_FILE"
+}
+
+service_links() {
+  declare desc="Lists all apps linked to a service"
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local LINKS_FILE="$SERVICE_ROOT/LINKS"
+
+  touch "$LINKS_FILE"
+  [[ -z $(<"$LINKS_FILE") ]] && return 0
+
+  cat "$LINKS_FILE"
 }

 service_list() {
  declare desc="Lists all services and their status"
-  local SERVICES=$(ls "$PLUGIN_DATA_ROOT" 2> /dev/null)
+  local SERVICES=$(ls "$PLUGIN_DATA_ROOT" 2>/dev/null)
+
  if [[ -z $SERVICES ]]; then
    dokku_log_warn "There are no $PLUGIN_SERVICE services"
-  else
-    LIST=""
-    if [[ -z "$DOKKU_QUIET_OUTPUT" ]]; then
-      LIST="NAME,VERSION,STATUS,EXPOSED PORTS,LINKS\n"
-    fi
-
-    for SERVICE in $SERVICES; do
-      LIST+="$SERVICE,$(service_version "$SERVICE"),$(service_status "$SERVICE"),$(service_exposed_ports "$SERVICE"),$(service_linked_apps "$SERVICE")\n"
-    done
-    printf "%b" "$LIST" | column -t -s,
+    return
  fi
+
+  dokku_log_info2_quiet "$PLUGIN_SERVICE services"
+  for SERVICE in $SERVICES; do
+    echo "$SERVICE"
+  done
 }

 service_logs() {
@@ -471,7 +519,7 @@ service_logs() {
    DOKKU_LOGS_ARGS="--follow"
  fi

-  docker inspect "$ID" &> /dev/null || dokku_log_fail "Service container does not exist"
+  docker inspect "$ID" &>/dev/null || dokku_log_fail "Service container does not exist"
  is_container_status "$ID" "Running" || dokku_log_warn "Service logs may not be output as service is not running"

  # shellcheck disable=SC2086
@@ -480,24 +528,26 @@ service_logs() {

 service_parse_args() {
  declare desc="cli arg parser"
-  local next_index=1; local skip=false; local args=("$@")
+  local next_index=1
+  local skip=false
+  local args=("$@")

  for arg in "$@"; do
    shift
    case "$arg" in
-      "--alias")                 set -- "$@" "-a" ;;
-      "--config-options")        set -- "$@" "-c" ;;
-      "--custom-env")            set -- "$@" "-C" ;;
-      "--database")              set -- "$@" "-d" ;;
-      "--image-version")         set -- "$@" "-I" ;;
-      "--image")                 set -- "$@" "-i" ;;
-      "--memory")                set -- "$@" "-m" ;;
-      "--password")              set -- "$@" "-p" ;;
-      "--querystring")           set -- "$@" "-q" ;;
-      "--restart-apps")          set -- "$@" "-R" ;;
-      "--root-password")         set -- "$@" "-r" ;;
-      "--user")                  set -- "$@" "-u" ;;
-      *)                         set -- "$@" "$arg"
+      "--alias") set -- "$@" "-a" ;;
+      "--config-options") set -- "$@" "-c" ;;
+      "--custom-env") set -- "$@" "-C" ;;
+      "--database") set -- "$@" "-d" ;;
+      "--image-version") set -- "$@" "-I" ;;
+      "--image") set -- "$@" "-i" ;;
+      "--memory") set -- "$@" "-m" ;;
+      "--password") set -- "$@" "-p" ;;
+      "--querystring") set -- "$@" "-q" ;;
+      "--restart-apps") set -- "$@" "-R" ;;
+      "--root-password") set -- "$@" "-r" ;;
+      "--user") set -- "$@" "-u" ;;
+      *) set -- "$@" "$arg" ;;
    esac
  done

@@ -505,33 +555,65 @@ service_parse_args() {
  while getopts "a:c:C:d:i:I:m:p:q:R:r:u:" opt; do
    case "$opt" in
      a)
-         SERVICE_ALIAS="${OPTARG^^}"; export SERVICE_ALIAS="${SERVICE_ALIAS%_URL}"
-         ;;
-      c) export PLUGIN_CONFIG_OPTIONS=$OPTARG
-         ;;
-      C) export SERVICE_CUSTOM_ENV=$OPTARG
-         ;;
-      d) export SERVICE_DATABASE=$OPTARG
-         ;;
-      i) export PLUGIN_IMAGE=$OPTARG
-         ;;
-      I) export PLUGIN_IMAGE_VERSION=$OPTARG
-         ;;
-      m) export SERVICE_MEMORY=$OPTARG
-         ;;
-      p) export SERVICE_PASSWORD=$OPTARG
-         ;;
-      q) export SERVICE_QUERYSTRING=${OPTARG#"?"}
-         ;;
-      R) export SERVICE_RESTART_APPS=$OPTARG
-         ;;
-      r) export SERVICE_ROOT_PASSWORD=$OPTARG
-         ;;
-      u) export SERVICE_USER=$OPTARG
-         ;;
+        SERVICE_ALIAS="${OPTARG^^}"
+        export SERVICE_ALIAS="${SERVICE_ALIAS%_URL}"
+        ;;
+      c)
+        export PLUGIN_CONFIG_OPTIONS=$OPTARG
+        ;;
+      C)
+        export SERVICE_CUSTOM_ENV=$OPTARG
+        ;;
+      d)
+        export SERVICE_DATABASE=$OPTARG
+        ;;
+      i)
+        export PLUGIN_IMAGE=$OPTARG
+        ;;
+      I)
+        export PLUGIN_IMAGE_VERSION=$OPTARG
+        ;;
+      m)
+        export SERVICE_MEMORY=$OPTARG
+        ;;
+      p)
+        export SERVICE_PASSWORD=$OPTARG
+        ;;
+      q)
+        export SERVICE_QUERYSTRING=${OPTARG#"?"}
+        ;;
+      R)
+        export SERVICE_RESTART_APPS=$OPTARG
+        ;;
+      r)
+        export SERVICE_ROOT_PASSWORD=$OPTARG
+        ;;
+      u)
+        export SERVICE_USER=$OPTARG
+        ;;
    esac
  done
-  shift "$(( OPTIND - 1 ))" # remove options from positional parameters
+  shift "$((OPTIND - 1))" # remove options from positional parameters
+}
+
+service_password() {
+  declare desc="Fetch the password for a service"
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local PASSWORD_FILE="$SERVICE_ROOT/PASSWORD"
+  if [[ -f "$PASSWORD_FILE" ]]; then
+    cat "$PASSWORD_FILE"
+  fi
+}
+
+service_root_password() {
+  declare desc="Fetch the root password for a service"
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local PASSWORD_FILE="$SERVICE_ROOT/ROOTPASSWORD"
+  if [[ -f "$PASSWORD_FILE" ]]; then
+    cat "$PASSWORD_FILE"
+  fi
 }

 service_port_expose() {
@@ -564,8 +646,8 @@ service_port_pause() {
    return
  fi

-  docker stop "$EXPOSED_NAME" > /dev/null 2>&1 || true
-  docker rm "$EXPOSED_NAME" > /dev/null 2>&1 || true
+  docker stop "$EXPOSED_NAME" >/dev/null 2>&1 || true
+  docker rm "$EXPOSED_NAME" >/dev/null 2>&1 || true
  if [[ "$LOG_FAIL" == "true" ]]; then
    dokku_log_info1 "Service $SERVICE unexposed"
  fi
@@ -602,10 +684,10 @@ service_port_unpause() {
    PORTS=($(cat "$PORT_FILE"))
  fi

-  echo "${PORTS[@]}" > "$PORT_FILE"
+  echo "${PORTS[@]}" >"$PORT_FILE"

  # shellcheck disable=SC2046
-  docker run -d --link "$SERVICE_NAME:$PLUGIN_COMMAND_PREFIX" --name "$EXPOSED_NAME" $(docker_ports_options "${PORTS[@]}") --restart always --label dokku=ambassador --label "dokku.ambassador=$PLUGIN_COMMAND_PREFIX" dokku/ambassador:0.2.0 > /dev/null
+  docker run -d --link "$SERVICE_NAME:$PLUGIN_COMMAND_PREFIX" --name "$EXPOSED_NAME" $(docker_ports_options "${PORTS[@]}") --restart always --label dokku=ambassador --label "dokku.ambassador=$PLUGIN_COMMAND_PREFIX" "$PLUGIN_AMBASSADOR_IMAGE" >/dev/null
  if [[ "$LOG_FAIL" == "true" ]]; then
    dokku_log_info1 "Service $SERVICE exposed on port(s) [container->host]: $(service_exposed_ports "$SERVICE")"
  fi
@@ -646,7 +728,7 @@ service_set_alias() {
  local ALIAS_FILE="$SERVICE_ROOT/ALIAS"

  touch "$ALIAS_FILE"
-  echo "$ALIAS" > "$ALIAS_FILE"
+  echo "$ALIAS" >"$ALIAS_FILE"
 }

 service_status() {
@@ -656,13 +738,7 @@ service_status() {
  local ID="$(cat "$SERVICE_ROOT/ID")"
  local CONTAINER_STATUS

-  is_container_status "$ID" "Dead" && echo "dead" && return 0
-  is_container_status "$ID" "OOMKilled" && echo "oomkilled" && return 0
-  is_container_status "$ID" "Paused" && echo "paused" && return 0
-  is_container_status "$ID" "Restarting" && echo "restarting" && return 0
-  is_container_status "$ID" "Running" && echo "running" && return 0
-
-  CONTAINER_STATUS=$(docker inspect -f "{{.State.Status}}" "$CID" 2> /dev/null || true)
+  CONTAINER_STATUS=$(docker inspect -f "{{.State.Status}}" "$ID" 2>/dev/null || true)
  [[ -n "$CONTAINER_STATUS" ]] && echo "$CONTAINER_STATUS" && return 0
  echo "missing" && return 0
 }
@@ -670,14 +746,14 @@ service_status() {
 service_stop() {
  declare desc="Stops a running service"
  declare SERVICE="$1"
-  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE";
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
  local ID=$(docker ps -aq --no-trunc --filter "name=^/$SERVICE_NAME$" --format '{{ .ID }}') || true
  [[ -z $ID ]] && dokku_log_warn "Service is already stopped" && return 0

  if [[ -n $ID ]]; then
    dokku_log_info2_quiet "Stopping container"
-    docker stop "$SERVICE_NAME" > /dev/null
+    docker stop "$SERVICE_NAME" >/dev/null
    service_port_pause "$SERVICE"
    dokku_log_verbose_quiet "Container stopped"
  else
@@ -697,7 +773,7 @@ service_unlink() {

  remove_from_links_file "$SERVICE" "$APP"

-  if declare -f -F add_passed_docker_option > /dev/null; then
+  if declare -f -F add_passed_docker_option >/dev/null; then
    # shellcheck disable=SC2034
    local passed_phases=(build deploy run)
    remove_passed_docker_option passed_phases[@] "--link $SERVICE_NAME:$SERVICE_DNS_HOSTNAME"
@@ -713,7 +789,7 @@ service_version() {
  declare desc="Displays the running version for an image"
  declare SERVICE="$1"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  docker inspect -f '{{.Config.Image}}' "$SERVICE_NAME" 2> /dev/null || true
+  docker inspect -f '{{.Config.Image}}' "$SERVICE_NAME" 2>/dev/null || true
 }

 update_plugin_scheme_for_app() {
@@ -733,14 +809,12 @@ verify_service_name() {
  return 0
 }

-is_valid_service_name() {
-  declare desc="Validates a service name"
+write_database_name() {
+  declare desc="Writes a sanitized database name"
  declare SERVICE="$1"
-  [[ -z "$SERVICE" ]] && return 1
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"

-  if [[ "$SERVICE" =~ ^[A-Za-z0-9_]+$ ]]; then
-    return 0
-  fi
-
-  return 1
+  # some datastores do not like special characters in database names
+  # so we need to normalize them out
+  echo "$SERVICE" | tr .- _ > "$SERVICE_ROOT/DATABASE_NAME"
 }
--- a/9
+++ b/9
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 export MYSQL_IMAGE=${MYSQL_IMAGE:="mysql"}
-export MYSQL_IMAGE_VERSION=${MYSQL_IMAGE_VERSION:="5.7.25"}
+export MYSQL_IMAGE_VERSION=${MYSQL_IMAGE_VERSION:="5.7.28"}
 export MYSQL_ROOT=${MYSQL_ROOT:="$DOKKU_LIB_ROOT/services/mysql"}
 export MYSQL_HOST_ROOT=${MYSQL_HOST_ROOT:=$MYSQL_ROOT}

@@ -25,6 +25,7 @@ if [[ -n $DOKKU_API_VERSION ]]; then
  export PLUGIN_BASE_PATH="$PLUGIN_ENABLED_PATH"
 fi

-if [[ -d "$PLUGIN_DATA_ROOT/*" ]]; then
-  rm -rf "${PLUGIN_DATA_ROOT:?}/*"
-fi
+export PLUGIN_BUSYBOX_IMAGE="busybox:1.31.1-uclibc"
+export PLUGIN_AMBASSADOR_IMAGE="dokku/ambassador:0.3.3"
+export PLUGIN_S3BACKUP_IMAGE="dokku/s3backup:0.10.3"
+export PLUGIN_WAIT_IMAGE="dokku/wait:0.4.3"
--- a/62
+++ b/62
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/common-functions"
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$PLUGIN_AVAILABLE_PATH/config/functions"
@@ -12,11 +13,12 @@ service_connect() {
  local SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  local DATABASE_NAME="$(get_database_name "$SERVICE")"
+  local PASSWORD="$(service_password "$SERVICE")"
  local SERVICE_TTY_OPTS
  has_tty && SERVICE_TTY_OPTS="-t"

-  docker exec -i $SERVICE_TTY_OPTS "$SERVICE_NAME" mysql --user=mysql --password="$PASSWORD" --database="$SERVICE"
+  docker exec -i $SERVICE_TTY_OPTS "$SERVICE_NAME" mysql --user=mysql --password="$PASSWORD" --database="$DATABASE_NAME"
 }

 service_create() {
@@ -24,7 +26,8 @@ service_create() {
  is_valid_service_name "$SERVICE" || dokku_log_fail "Please specify a valid name for the service. Valid characters are: [A-Za-z0-9_]+"
  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
  [[ ! -d "$PLUGIN_DATA_ROOT/$SERVICE" ]] || dokku_log_fail "$PLUGIN_SERVICE service $SERVICE already exists"
-  SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"; LINKS_FILE="$SERVICE_ROOT/LINKS"
+  SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  LINKS_FILE="$SERVICE_ROOT/LINKS"

  service_parse_args "${@:2}"

@@ -43,8 +46,8 @@ service_create() {
  mkdir -p "$SERVICE_ROOT/config" || dokku_log_fail "Unable to create service config directory"
  touch "$LINKS_FILE"

-  echo -e "[mysqld]\nperformance_schema = 0" > "$SERVICE_ROOT/config/disable_performance_schema.cnf"
-  echo -e "[mysqld]\ncharacter-set-server = utf8\ncollation-server = utf8_general_ci" > "$SERVICE_ROOT/config/charset_utf8.cnf"
+  echo -e "[mysqld]\nperformance_schema = 0" >"$SERVICE_ROOT/config/disable_performance_schema.cnf"
+  echo -e "[mysqld]\ncharacter-set-server = utf8\ncollation-server = utf8_general_ci" >"$SERVICE_ROOT/config/charset_utf8.cnf"
  ROOTPASSWORD=$(openssl rand -hex 8)
  PASSWORD=$(openssl rand -hex 8)
  if [[ -n "$SERVICE_PASSWORD" ]]; then
@@ -55,16 +58,18 @@ service_create() {
    ROOTPASSWORD="$SERVICE_ROOT_PASSWORD"
    dokku_log_warn "Specified root password may not be as secure as the auto-generated root password"
  fi
-  echo "$ROOTPASSWORD" > "$SERVICE_ROOT/ROOTPASSWORD"
-  echo "$PASSWORD" > "$SERVICE_ROOT/PASSWORD"
+  echo "$ROOTPASSWORD" >"$SERVICE_ROOT/ROOTPASSWORD"
+  echo "$PASSWORD" >"$SERVICE_ROOT/PASSWORD"
  chmod 640 "$SERVICE_ROOT/ROOTPASSWORD" "$SERVICE_ROOT/PASSWORD"

  [[ -n "$SERVICE_CUSTOM_ENV" ]] && MYSQL_CUSTOM_ENV="$SERVICE_CUSTOM_ENV"
  if [[ -n $MYSQL_CUSTOM_ENV ]]; then
-    echo "$MYSQL_CUSTOM_ENV" | tr ';' "\n" > "$SERVICE_ROOT/ENV"
+    echo "$MYSQL_CUSTOM_ENV" | tr ';' "\n" >"$SERVICE_ROOT/ENV"
  else
-    echo "" > "$SERVICE_ROOT/ENV"
+    echo "" >"$SERVICE_ROOT/ENV"
  fi
+
+  write_database_name "$SERVICE"
  service_create_container "$SERVICE"
 }

@@ -73,14 +78,15 @@ service_create_container() {
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_HOST_ROOT="$PLUGIN_DATA_HOST_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  local ROOTPASSWORD="$(cat "$SERVICE_ROOT/ROOTPASSWORD")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  local ROOTPASSWORD="$(service_root_password "$SERVICE")"
+  local PASSWORD="$(service_password "$SERVICE")"
+  local DATABASE_NAME="$(get_database_name "$SERVICE")"

-  ID=$(docker run --name "$SERVICE_NAME" -v "$SERVICE_HOST_ROOT/data:/var/lib/mysql" -v "$SERVICE_HOST_ROOT/config:/etc/mysql/conf.d" -e "MYSQL_ROOT_PASSWORD=$ROOTPASSWORD" -e MYSQL_USER=mysql -e "MYSQL_PASSWORD=$PASSWORD" -e "MYSQL_DATABASE=$SERVICE" --env-file="$SERVICE_ROOT/ENV" -d --restart always --label dokku=service --label dokku.service=mysql "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION")
-  echo "$ID" > "$SERVICE_ROOT/ID"
+  ID=$(docker run --name "$SERVICE_NAME" -v "$SERVICE_HOST_ROOT/data:/var/lib/mysql" -v "$SERVICE_HOST_ROOT/config:/etc/mysql/conf.d" -e "MYSQL_ROOT_PASSWORD=$ROOTPASSWORD" -e MYSQL_USER=mysql -e "MYSQL_PASSWORD=$PASSWORD" -e "MYSQL_DATABASE=$DATABASE_NAME" --env-file="$SERVICE_ROOT/ENV" -d --restart always --label dokku=service --label dokku.service=mysql "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION")
+  echo "$ID" >"$SERVICE_ROOT/ID"

  dokku_log_verbose_quiet "Waiting for container to be ready"
-  docker run --rm --link "$SERVICE_NAME:$PLUGIN_COMMAND_PREFIX" dokku/wait:0.3.0 -p "$PLUGIN_DATASTORE_WAIT_PORT" > /dev/null
+  docker run --rm --link "$SERVICE_NAME:$PLUGIN_COMMAND_PREFIX" "$PLUGIN_WAIT_IMAGE" -p "$PLUGIN_DATASTORE_WAIT_PORT" >/dev/null

  dokku_log_info2 "$PLUGIN_SERVICE container created: $SERVICE"
  service_info "$SERVICE"
@@ -90,11 +96,12 @@ service_export() {
  local SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  local DATABASE_NAME="$(get_database_name "$SERVICE")"
+  local PASSWORD="$(service_password "$SERVICE")"

  [[ -n $SSH_TTY ]] && stty -opost
  docker exec "$SERVICE_NAME" bash -c "printf '[client]\npassword=$PASSWORD\n' > /root/credentials.cnf"
-  docker exec "$SERVICE_NAME" mysqldump --defaults-extra-file=/root/credentials.cnf --user=mysql "$SERVICE"
+  docker exec "$SERVICE_NAME" mysqldump --defaults-extra-file=/root/credentials.cnf --user=mysql "$DATABASE_NAME"
  docker exec "$SERVICE_NAME" rm /root/credentials.cnf
  status=$?
  [[ -n $SSH_TTY ]] && stty opost
@@ -106,12 +113,13 @@ service_import() {
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
  local SERVICE_HOST_ROOT="$PLUGIN_DATA_HOST_ROOT/$SERVICE"
-  local ROOTPASSWORD="$(cat "$SERVICE_ROOT/ROOTPASSWORD")"
+  local DATABASE_NAME="$(get_database_name "$SERVICE")"
+  local ROOTPASSWORD="$(service_root_password "$SERVICE")"

  if [[ -t 0 ]]; then
    dokku_log_fail "No data provided on stdin."
  fi
-  docker exec -i "$SERVICE_NAME" mysql --user=root --password="$ROOTPASSWORD" "$SERVICE"
+  docker exec -i "$SERVICE_NAME" mysql --user=root --password="$ROOTPASSWORD" "$DATABASE_NAME"
 }

 service_start() {
@@ -122,16 +130,20 @@ service_start() {
  local ID=$(docker ps -aq --no-trunc --filter "status=running" --filter "name=^/$SERVICE_NAME$" --format '{{ .ID }}') || true
  if [[ -n $ID ]]; then
    [[ -z $QUIET ]] && dokku_log_warn "Service is already started"
+    if [[ ! -f "$SERVICE_ROOT/ID" ]] || [[ "$(cat "$SERVICE_ROOT/ID")" != "$ID" ]]; then
+      [[ -z $QUIET ]] && dokku_log_warn "Updating local container ID"
+      echo "$ID" >"$SERVICE_ROOT/ID"
+    fi
    return 0
  fi

  dokku_log_info2_quiet "Starting container"
  local PREVIOUS_ID=$(docker ps -aq --no-trunc --filter "status=exited" --filter "name=^/$SERVICE_NAME$" --format '{{ .ID }}') || true
-  local ROOTPASSWORD="$(cat "$SERVICE_ROOT/ROOTPASSWORD")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  local ROOTPASSWORD="$(service_root_password "$SERVICE")"
+  local PASSWORD="$(service_password "$SERVICE")"

  if [[ -n $PREVIOUS_ID ]]; then
-    docker start "$PREVIOUS_ID" > /dev/null
+    docker start "$PREVIOUS_ID" >/dev/null
    service_port_unpause "$SERVICE"
    dokku_log_info2 "Container started"
  elif service_image_exists "$SERVICE" && [[ -n "$ROOTPASSWORD" ]] && [[ -n "$PASSWORD" ]]; then
@@ -143,8 +155,8 @@ service_start() {

 service_url() {
  local SERVICE="$1"
-  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
  local SERVICE_DNS_HOSTNAME="$(service_dns_hostname "$SERVICE")"
-  echo "$PLUGIN_SCHEME://mysql:$PASSWORD@$SERVICE_DNS_HOSTNAME:${PLUGIN_DATASTORE_PORTS[0]}/$SERVICE"
+  local DATABASE_NAME="$(get_database_name "$SERVICE")"
+  local PASSWORD="$(service_password "$SERVICE")"
+  echo "$PLUGIN_SCHEME://mysql:$PASSWORD@$SERVICE_DNS_HOSTNAME:${PLUGIN_DATASTORE_PORTS[0]}/$DATABASE_NAME"
 }
--- a/29
+++ b/29
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/common-functions"
 export SUBCOMMAND_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/subcommands"

@@ -13,7 +14,7 @@ fn-help() {
    exit 0
  fi

-  pushd "$SUBCOMMAND_ROOT" > /dev/null 2>&1
+  pushd "$SUBCOMMAND_ROOT" >/dev/null 2>&1
  for cmd in *; do
    if [[ "$CMD" == "${PLUGIN_COMMAND_PREFIX}:$cmd" ]]; then
      "$SUBCOMMAND_ROOT/$cmd" "$@"
@@ -21,7 +22,7 @@ fn-help() {
      exit "$EXIT_CODE"
    fi
  done
-  popd > /dev/null 2>&1
+  popd >/dev/null 2>&1

  exit "$DOKKU_NOT_IMPLEMENTED_EXIT"
 }
@@ -31,7 +32,7 @@ fn-help-all() {
  local CMD_OUTPUT BLUE BOLD FULL_OUTPUT NORMAL
  FULL_OUTPUT=true

-  if [[ "$CMD" = "$PLUGIN_COMMAND_PREFIX:help" ]] || [[ "$CMD" == "$PLUGIN_COMMAND_PREFIX" ]] || [[ "$CMD" == "$PLUGIN_COMMAND_PREFIX:default" ]] ; then
+  if [[ "$CMD" == "$PLUGIN_COMMAND_PREFIX:help" ]] || [[ "$CMD" == "$PLUGIN_COMMAND_PREFIX" ]] || [[ "$CMD" == "$PLUGIN_COMMAND_PREFIX:default" ]]; then
    BOLD="$(fn-help-fancy-tput bold)"
    NORMAL="$(fn-help-fancy-color "\033[m")"
    BLUE="$(fn-help-fancy-color "\033[0;34m")"
@@ -58,7 +59,7 @@ fn-help-all() {
  elif [[ $(ps -o command= $PPID) == *"--all"* ]]; then
    fn-help-contents
  else
-    cat<<help_desc
+    cat <<help_desc
    $PLUGIN_COMMAND_PREFIX, Plugin for managing $PLUGIN_SERVICE services
 help_desc
  fi
@@ -67,7 +68,7 @@ help_desc
 }

 fn-help-contents() {
-  pushd "$SUBCOMMAND_ROOT" > /dev/null 2>&1
+  pushd "$SUBCOMMAND_ROOT" >/dev/null 2>&1
  for cmd in *; do
    fn-help-contents-subcommand "$cmd" || true
  done
@@ -81,7 +82,7 @@ fn-help-contents-subcommand() {
  trap 'rm -rf "$TMPDIR" > /dev/null' RETURN INT TERM EXIT

  rm -rf "$UNCLEAN_FILE" "$CLEAN_FILE"
-  cat "$SUBCOMMAND_ROOT/$SUBCOMMAND" > "$UNCLEAN_FILE"
+  cat "$SUBCOMMAND_ROOT/$SUBCOMMAND" >"$UNCLEAN_FILE"

  fn-help-subcommand-sanitize "$UNCLEAN_FILE" "$CLEAN_FILE"
  if ! is_implemented_command "$SUBCOMMAND"; then
@@ -142,7 +143,7 @@ fn-help-contents-subcommand() {
 fn-help-fancy-tput() {
  declare desc="A wrapper around tput"

-  if [[ -n "$DOKKU_NO_COLOR" ]] || [[ "$TERM" = "unknown" ]] || [[ "$TERM" == "dumb" ]]; then
+  if [[ -n "$DOKKU_NO_COLOR" ]] || [[ "$TERM" == "unknown" ]] || [[ "$TERM" == "dumb" ]]; then
    return
  fi

@@ -152,7 +153,7 @@ fn-help-fancy-tput() {
 fn-help-fancy-color() {
  declare desc="A wrapper around colors"

-  if [[ -n "$DOKKU_NO_COLOR" ]] || [[ "$TERM" = "unknown" ]] || [[ "$TERM" == "dumb" ]]; then
+  if [[ -n "$DOKKU_NO_COLOR" ]] || [[ "$TERM" == "unknown" ]] || [[ "$TERM" == "dumb" ]]; then
    return
  fi

@@ -162,7 +163,7 @@ fn-help-fancy-color() {
 fn-help-list-example() {
  # shellcheck disable=SC2034
  declare desc="return $PLUGIN_COMMAND_PREFIX plugin help content"
-  cat<<help_list
+  cat <<help_list
      NAME, VERSION, STATUS, EXPOSED PORTS, LINKS
      service-name, $PLUGIN_COMMAND_PREFIX:$PLUGIN_IMAGE_VERSION, running, -, app-name
 help_list
@@ -190,7 +191,7 @@ fn-help-subcommand-args() {
    if [[ "$arg" == *_FLAG ]]; then
      arg="${arg/_FLAG/}"
      if [[ $arg == "INFO" ]]; then
-        arg="SINGLE_INFO_FLAG..."
+        arg="SINGLE_INFO_FLAG"
        args+=" ${BLUE}[--${arg//_/-}]${NORMAL}"
      else
        args+=" ${BLUE}[-${arg:0:1}|--${arg//_/-}]${NORMAL}"
@@ -295,16 +296,16 @@ fn-help-subcommand-sanitize() {
    fi

    if [[ "$FUNCTION_FOUND" == true ]]; then
-      echo "$p" >> "$OUTGOING_FUNC_FILE"
+      echo "$p" >>"$OUTGOING_FUNC_FILE"
      continue
    fi

    if [[ "$p" == *"()"* ]]; then
      FUNCTION_FOUND=true
-      echo "$p" >> "$OUTGOING_FUNC_FILE"
+      echo "$p" >>"$OUTGOING_FUNC_FILE"
      continue
    fi
-  done < "$FUNC_FILE"
+  done <"$FUNC_FILE"
 }

 _fn-help-apply-shell-expansion() {
--- a/15
+++ b/15
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x

 plugin-install() {
  pull-docker-image() {
@@ -10,16 +11,16 @@ plugin-install() {
      echo " !        docker pull ${IMAGE}" 1>&2
      return
    fi
-    if [[ "$(docker images -q "${IMAGE}" 2> /dev/null)" == "" ]]; then
+    if [[ "$(docker images -q "${IMAGE}" 2>/dev/null)" == "" ]]; then
      docker pull "${IMAGE}"
    fi
  }

  pull-docker-image "${PLUGIN_IMAGE}:${PLUGIN_IMAGE_VERSION}"
-  pull-docker-image "dokku/ambassador:0.2.0"
-  pull-docker-image "dokku/wait:0.3.0"
-  pull-docker-image "dokku/s3backup:0.9.4"
-  pull-docker-image "busybox:1.30.1-uclibc"
+  pull-docker-image "$PLUGIN_BUSYBOX_IMAGE"
+  pull-docker-image "$PLUGIN_AMBASSADOR_IMAGE"
+  pull-docker-image "$PLUGIN_S3BACKUP_IMAGE"
+  pull-docker-image "$PLUGIN_WAIT_IMAGE"

  mkdir -p "$PLUGIN_DATA_ROOT" || echo "Failed to create $PLUGIN_SERVICE data directory"
  chown dokku:dokku "$PLUGIN_DATA_ROOT"
@@ -31,7 +32,7 @@ plugin-install() {
  _SUDOERS_FILE="/etc/sudoers.d/dokku-${PLUGIN_COMMAND_PREFIX}"

  touch "$_SUDOERS_FILE"
-  cat > "$_SUDOERS_FILE" <<EOL
+  cat >"$_SUDOERS_FILE" <<EOL
 %dokku ALL=(ALL) NOPASSWD:/bin/rm -f /etc/cron.d/dokku-${PLUGIN_COMMAND_PREFIX}-*
 %dokku ALL=(ALL) NOPASSWD:/bin/chown root\:root /etc/cron.d/dokku-${PLUGIN_COMMAND_PREFIX}-*
 %dokku ALL=(ALL) NOPASSWD:/bin/chmod 644 /etc/cron.d/dokku-${PLUGIN_COMMAND_PREFIX}-*
--- a/plugin.toml
+++ b/plugin.toml
@@ -1,4 +1,4 @@
 [plugin]
 description = "dokku mysql service plugin"
-version = "1.7.0"
+version = "1.11.1"
 [plugin.config]
--- a/5
+++ b/5
@@ -1,7 +1,8 @@
 #!/usr/bin/env bash
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
 source "$PLUGIN_BASE_PATH/common/functions"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x

 PLUGIN_BASE_PATH="$PLUGIN_PATH"
 if [[ -n $DOKKU_API_VERSION ]]; then
@@ -11,7 +12,7 @@ source "$PLUGIN_BASE_PATH/common/functions"
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/functions"

 APP="$1"
-pushd "$PLUGIN_DATA_ROOT" > /dev/null
+pushd "$PLUGIN_DATA_ROOT" >/dev/null
 for SERVICE in *; do
  dokku_log_verbose_quiet "Unlinking from $SERVICE"
  remove_from_links_file "$(basename "$SERVICE")" "$APP"
--- a/subcommands/app-links
+++ b/subcommands/app-links
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -9,7 +10,8 @@ service-app-links-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:app-links playground
  #A app, app to run command against
  declare desc="list all $PLUGIN_SERVICE service links for a given app"
-  local cmd="$PLUGIN_COMMAND_PREFIX:app-links" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:app-links" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare APP="$1"
  APP=${APP:="$DOKKU_APP_NAME"}

--- a/subcommands/backup
+++ b/subcommands/backup
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -11,7 +12,8 @@ service-backup-cmd() {
  #A service, service to run command against
  #A bucket-name, name of the s3 bucket to upload backups to
  declare desc="creates a backup of the $PLUGIN_SERVICE service to an existing s3 bucket"
-  local cmd="$PLUGIN_COMMAND_PREFIX:backup" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:backup" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" BUCKET_NAME="$2" USE_IAM_OPTIONAL_FLAG="$3"
  is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"

--- a/subcommands/backup-auth
+++ b/subcommands/backup-auth
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -20,7 +21,8 @@ service-backup-auth-cmd() {
  #A aws-signature-version, (optional) the AWS signature version to use when signing S3 requests
  #A endpoint-url, (optional) an aws endpoint to upload to
  declare desc="sets up authentication for backups on the $PLUGIN_SERVICE service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:backup-auth" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:backup-auth" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" AWS_ACCESS_KEY_ID="$2" AWS_SECRET_ACCESS_KEY="$3" AWS_DEFAULT_REGION="$4" AWS_SIGNATURE_VERSION="$5" ENDPOINT_URL="$6"
  is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"

--- a/subcommands/backup-deauth
+++ b/subcommands/backup-deauth
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -9,7 +10,8 @@ service-backup-deauth-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:backup-deauth lolipop
  #A service, service to run command against
  declare desc="removes backup authentication for the $PLUGIN_SERVICE service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:backup-deauth" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:backup-deauth" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"
  is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"

--- a/subcommands/backup-schedule
+++ b/subcommands/backup-schedule
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -15,7 +16,8 @@ service-backup-schedule-cmd() {
  #A schedule, a cron schedule to run backups on
  #A bucket-name, name of the s3 bucket to upload backups to
  declare desc="schedules a backup of the $PLUGIN_SERVICE service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:backup-schedule" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:backup-schedule" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" SCHEDULE="$2" BUCKET_NAME="$3" USE_IAM_OPTIONAL_FLAG="$4"
  is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"

--- a/subcommands/backup-schedule-cat
+++ b/subcommands/backup-schedule-cat
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -9,7 +10,8 @@ service-backup-schedule-cat-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:backup-schedule-cat lolipop
  #A service, service to run command against
  declare desc="cat the contents of the configured backup cronfile for the service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:backup-schedule-cat" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:backup-schedule-cat" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"

  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
--- a/subcommands/backup-set-encryption
+++ b/subcommands/backup-set-encryption
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -10,7 +11,8 @@ service-backup-set-encryption-cmd() {
  #A service, service to run command against
  #A passphrase, a GPG-compatible passphrase
  declare desc="sets encryption for all future backups of $PLUGIN_SERVICE service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:backup-set-encryption" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:backup-set-encryption" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" PASSPHRASE="$2"
  is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"

--- a/subcommands/backup-unschedule
+++ b/subcommands/backup-unschedule
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -9,7 +10,8 @@ service-backup-unschedule-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:backup-unschedule lolipop
  #A service, service to run command against
  declare desc="unschedules the backup of the $PLUGIN_SERVICE service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:backup-unschedule" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:backup-unschedule" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"
  is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"

--- a/subcommands/backup-unset-encryption
+++ b/subcommands/backup-unset-encryption
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -9,7 +10,8 @@ service-backup-unset-encryption-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:backup-unset-encryption lolipop
  #A service, service to run command against
  declare desc="unsets encryption for future backups of the $PLUGIN_SERVICE service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:backup-unset-encryption" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:backup-unset-encryption" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"
  is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"

--- a/subcommands/clone
+++ b/subcommands/clone
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -15,7 +16,8 @@ service-clone-cmd() {
  #F -p|--password PASSWORD, override the user-level service password
  #F -r|--root-password PASSWORD, override the root-level service password
  declare desc="create container <new-name> then copy data from <name> into <new-name>"
-  local cmd="$PLUGIN_COMMAND_PREFIX:clone" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:clone" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" NEW_SERVICE="$2" CLONE_FLAGS_LIST=("${@:3}")
  is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"

@@ -27,15 +29,15 @@ service-clone-cmd() {
  local ID="$(cat "$SERVICE_ROOT/ID")"
  is_container_status "$ID" "Running" || dokku_log_fail "Service ${SERVICE} container is not running"

-  PLUGIN_IMAGE=$(service_version "$SERVICE" |  grep -o "^.*:" | sed -r "s/://g")
-  PLUGIN_IMAGE_VERSION=$(service_version "$SERVICE" |  grep -o ":.*$" | sed -r "s/://g")
+  PLUGIN_IMAGE=$(service_version "$SERVICE" | grep -o "^.*:" | sed -r "s/://g")
+  PLUGIN_IMAGE_VERSION=$(service_version "$SERVICE" | grep -o ":.*$" | sed -r "s/://g")

  service_parse_args "${@:3}"

  dokku_log_info2 "Cloning $SERVICE to $NEW_SERVICE @ $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION"
  service_create "$NEW_SERVICE" "${@:3}"
  dokku_log_info1 "Copying data from $SERVICE to $NEW_SERVICE"
-  service_export "$SERVICE" | service_import "$NEW_SERVICE" > /dev/null 2>&1 || true
+  service_export "$SERVICE" | service_import "$NEW_SERVICE" >/dev/null 2>&1 || true
  dokku_log_info2 "Done"
 }

--- a/subcommands/connect
+++ b/subcommands/connect
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -9,7 +10,8 @@ service-connect-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:connect lolipop
  #A service, service to run command against
  declare desc="connect to the service via the $PLUGIN_COMMAND_PREFIX connection tool"
-  local cmd="$PLUGIN_COMMAND_PREFIX:connect" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:connect" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"
  is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"

--- a/subcommands/create
+++ b/subcommands/create
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -12,7 +13,7 @@ service-create-cmd() {
  #E export ${PLUGIN_DEFAULT_ALIAS}_IMAGE="${PLUGIN_IMAGE}"
  #E export ${PLUGIN_DEFAULT_ALIAS}_IMAGE_VERSION="${PLUGIN_IMAGE_VERSION}"
  #E dokku $PLUGIN_COMMAND_PREFIX:create lolipop
-  #E you can also specify custom environment variables to start 
+  #E you can also specify custom environment variables to start
  #E the ${PLUGIN_COMMAND_PREFIX} service in semi-colon separated form.
  #E export ${PLUGIN_DEFAULT_ALIAS}_CUSTOM_ENV="USER=alpha;HOST=beta"
  #E dokku $PLUGIN_COMMAND_PREFIX:create lolipop
@@ -23,7 +24,8 @@ service-create-cmd() {
  #F -p|--password PASSWORD, override the user-level service password
  #F -r|--root-password PASSWORD, override the root-level service password
  declare desc="create a $PLUGIN_SERVICE service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:create" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:create" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" CREATE_FLAGS_LIST=("${@:2}")

  service_create "$SERVICE" "${@:2}"
--- a/subcommands/destroy
+++ b/subcommands/destroy
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -10,12 +11,14 @@ service-destroy-cmd() {
  #A service, service to run command against
  #F -f|--force, force destroy without asking for confirmation
  declare desc="delete the $PLUGIN_SERVICE service/data/container if there are no links left"
-  local cmd="$PLUGIN_COMMAND_PREFIX:destroy" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:destroy" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" FORCE_FLAG="$2"

  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
  verify_service_name "$SERVICE"
-  SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"; LINKS_FILE="$SERVICE_ROOT/LINKS"
+  SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  LINKS_FILE="$SERVICE_ROOT/LINKS"
  SERVICE_HOST_ROOT="$PLUGIN_DATA_HOST_ROOT/$SERVICE"
  SERVICE_NAME="$(get_service_name "$SERVICE")"

@@ -42,7 +45,7 @@ service-destroy-cmd() {
  service_container_rm "$SERVICE"

  dokku_log_verbose_quiet "Removing data"
-  docker run --rm -v "$SERVICE_HOST_ROOT/data:/data" -v "$SERVICE_HOST_ROOT/config:/config" busybox:1.30.1-uclibc chmod 777 -R /config /data
+  docker run --rm -v "$SERVICE_HOST_ROOT/data:/data" -v "$SERVICE_HOST_ROOT/config:/config" "$PLUGIN_BUSYBOX_IMAGE" chmod 777 -R /config /data
  rm -rf "$SERVICE_ROOT"

  dokku_log_info2 "$PLUGIN_SERVICE container deleted: $SERVICE"
--- a/subcommands/enter
+++ b/subcommands/enter
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -13,7 +14,8 @@ service-enter-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:enter lolipop touch /tmp/test
  #A service, service to run command against
  declare desc="enter or run a command in a running $PLUGIN_SERVICE service container"
-  local cmd="$PLUGIN_COMMAND_PREFIX:enter" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:enter" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"

  dokku_log_info1_quiet "Filesystem changes may not persist after container restarts"
--- a/subcommands/exists
+++ b/subcommands/exists
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -9,7 +10,8 @@ service-exists-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:exists lolipop
  #A service, service to run command against
  declare desc="check if the $PLUGIN_SERVICE service exists"
-  local cmd="$PLUGIN_COMMAND_PREFIX:exists" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:exists" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"

  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
--- a/subcommands/export
+++ b/subcommands/export
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -11,7 +12,8 @@ service-export-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:export lolipop > lolipop.dump
  #A service, service to run command against
  declare desc="export a dump of the $PLUGIN_SERVICE service database"
-  local cmd="$PLUGIN_COMMAND_PREFIX:export" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:export" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"
  is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"

--- a/subcommands/expose
+++ b/subcommands/expose
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -10,7 +11,8 @@ service-expose-cmd() {
  #A service, service to run command against
  #A ports, a list of ports to run against
  declare desc="expose a $PLUGIN_SERVICE service on custom port if provided (random port otherwise)"
-  local cmd="$PLUGIN_COMMAND_PREFIX:expose" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:expose" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" PORTS_LIST=("${@:2}")

  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
--- a/subcommands/import
+++ b/subcommands/import
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -9,7 +10,8 @@ service-import-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:import lolipop < database.dump
  #A service, service to run command against
  declare desc="import a dump into the $PLUGIN_SERVICE service database"
-  local cmd="$PLUGIN_COMMAND_PREFIX:import" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:import" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"
  is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"

--- a/subcommands/info
+++ b/subcommands/info
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -29,8 +30,9 @@ service-info-cmd() {
  #F --service-root, show the service root directory
  #F --status, show the service running status
  #F --version, show the service image version
-  declare desc="print the connection information"
-  local cmd="$PLUGIN_COMMAND_PREFIX:info" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare desc="print the service information"
+  local cmd="$PLUGIN_COMMAND_PREFIX:info" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" INFO_FLAG="$2"

  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
--- a/subcommands/link
+++ b/subcommands/link
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -42,7 +43,8 @@ service-link-cmd() {
  #F -a|--alias "BLUE_DATABASE", an alternative alias to use for linking to an app via environment variable
  #F -q|--querystring "pool=5", ampersand delimited querystring arguments to append to the service link
  declare desc="link the $PLUGIN_SERVICE service to the app"
-  local cmd="$PLUGIN_COMMAND_PREFIX:link" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:link" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" APP="$2" LINK_FLAGS_LIST=("${@:3}")
  APP=${APP:="$DOKKU_APP_NAME"}

--- a/subcommands/linked
+++ b/subcommands/linked
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -10,7 +11,8 @@ service-linked-cmd() {
  #A service, service to run command against
  #A app, app to run command against
  declare desc="check if the $PLUGIN_SERVICE service is linked to an app"
-  local cmd="$PLUGIN_COMMAND_PREFIX:linked" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:linked" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" APP="$2"
  APP=${APP:="$DOKKU_APP_NAME"}

--- a/subcommands/links
+++ b/subcommands/links
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_BASE_PATH/common/functions"
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
+
+service-links-cmd() {
+  #E list all apps linked to the 'lolipop' $PLUGIN_COMMAND_PREFIX service.
+  #E dokku $PLUGIN_COMMAND_PREFIX:links lolipop
+  #A service, service to run command against
+  declare desc="list all apps linked to the $PLUGIN_SERVICE service"
+  local cmd="$PLUGIN_COMMAND_PREFIX:links" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local LINKS_FILE="$SERVICE_ROOT/LINKS"
+
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
+  verify_service_name "$SERVICE"
+  service_links "$SERVICE"
+}
+
+service-links-cmd "$@"
--- a/subcommands/list
+++ b/subcommands/list
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -8,7 +9,8 @@ service-list-cmd() {
  #E list all services
  #E dokku $PLUGIN_COMMAND_PREFIX:list
  declare desc="list all $PLUGIN_SERVICE services"
-  local cmd="$PLUGIN_COMMAND_PREFIX:list" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:list" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1

  service_list
 }
--- a/subcommands/logs
+++ b/subcommands/logs
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -12,7 +13,8 @@ service-logs-cmd() {
  #A service, service to run command against
  #F -t|--tail, do not stop when end of the logs are reached and wait for additional output
  declare desc="print the most recent log(s) for this service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:logs" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:logs" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" TAIL_FLAG="$2"

  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
--- a/subcommands/promote
+++ b/subcommands/promote
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -23,7 +24,8 @@ service-promote-cmd() {
  #A service, service to run command against
  #A app, app to run command against
  declare desc="promote service <service> as ${PLUGIN_DEFAULT_ALIAS}_URL in <app>"
-  local cmd="$PLUGIN_COMMAND_PREFIX:promote" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:promote" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" APP="$2"
  APP=${APP:="$DOKKU_APP_NAME"}

--- a/subcommands/restart
+++ b/subcommands/restart
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -9,7 +10,8 @@ service-restart-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:restart lolipop
  #A service, service to run command against
  declare desc="graceful shutdown and restart of the $PLUGIN_SERVICE service container"
-  local cmd="$PLUGIN_COMMAND_PREFIX:restart" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:restart" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"

  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
--- a/subcommands/start
+++ b/subcommands/start
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -9,7 +10,8 @@ service-start-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:start lolipop
  #A service, service to run command against
  declare desc="start a previously stopped $PLUGIN_SERVICE service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:start" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:start" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"

  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
--- a/subcommands/stop
+++ b/subcommands/stop
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -9,7 +10,8 @@ service-stop-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:stop lolipop
  #A service, service to run command against
  declare desc="stop a running $PLUGIN_SERVICE service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:stop" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:stop" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"

  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
--- a/subcommands/unexpose
+++ b/subcommands/unexpose
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -9,7 +10,8 @@ service-unexpose-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:unexpose lolipop
  #A service, service to run command against
  declare desc="unexpose a previously exposed $PLUGIN_SERVICE service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:unexpose" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:unexpose" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"

  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
--- a/subcommands/unlink
+++ b/subcommands/unlink
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

@@ -11,7 +12,8 @@ service-unlink-cmd() {
  #A service, service to run command against
  #A app, app to run command against
  declare desc="unlink the $PLUGIN_SERVICE service from the app"
-  local cmd="$PLUGIN_COMMAND_PREFIX:unlink" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:unlink" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" APP="$2"
  APP=${APP:="$DOKKU_APP_NAME"}

--- a/subcommands/upgrade
+++ b/subcommands/upgrade
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 source "$PLUGIN_AVAILABLE_PATH/ps/functions"
@@ -14,7 +15,8 @@ service-upgrade-cmd() {
  #F -I|--image-version IMAGE_VERSION, the image version to start the service with
  #F -R|--restart-apps "true", whether to force an app restart
  declare desc="upgrade service <service> to the specified versions"
-  local cmd="$PLUGIN_COMMAND_PREFIX:upgrade" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:upgrade" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" UPGRADE_FLAGS_LIST=("${@:2}")

  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
--- a/tests/service_create.bats
+++ b/tests/service_create.bats
@@ -7,6 +7,15 @@ load test_helper
  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }

+@test "($PLUGIN_COMMAND_PREFIX:create) service with dashes" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:create" service-with-dashes
+  assert_contains "${lines[*]}" "container created: service-with-dashes"
+  assert_contains "${lines[*]}" "dokku-$PLUGIN_COMMAND_PREFIX-service-with-dashes"
+  assert_contains "${lines[*]}" "service_with_dashes"
+
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" service-with-dashes
+}
+
@test "($PLUGIN_COMMAND_PREFIX:create) error when there are no arguments" {
  run dokku "$PLUGIN_COMMAND_PREFIX:create"
  assert_contains "${lines[*]}" "Please specify a valid name for the service"
@@ -15,7 +24,4 @@ load test_helper
@test "($PLUGIN_COMMAND_PREFIX:create) error when there is an invalid name specified" {
  run dokku "$PLUGIN_COMMAND_PREFIX:create" d.erp
  assert_failure
-
-  run dokku "$PLUGIN_COMMAND_PREFIX:create" d-erp
-  assert_failure
 }
--- a/tests/service_link.bats
+++ b/tests/service_link.bats
@@ -85,7 +85,7 @@ teardown() {

@test "($PLUGIN_COMMAND_PREFIX:link) links to app with docker-options" {
  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  run dokku docker-options my_app
+  run dokku docker-options:report my_app
  assert_contains "${lines[*]}" "--link dokku.mysql.l:dokku-mysql-l"
  assert_success
  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
--- a/tests/service_list.bats
+++ b/tests/service_list.bats
@@ -10,27 +10,13 @@ teardown() {
 }

@test "($PLUGIN_COMMAND_PREFIX:list) with no exposed ports, no linked apps" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "l     mysql:5.7.25  running  -              -"
-}
-
-@test "($PLUGIN_COMMAND_PREFIX:list) with exposed ports" {
-  dokku "$PLUGIN_COMMAND_PREFIX:expose" l 4242
-  run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "l     mysql:5.7.25  running  3306->4242     -"
-}
-
-@test "($PLUGIN_COMMAND_PREFIX:list) with linked app" {
-  dokku apps:create my_app
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "l     mysql:5.7.25  running  -              my_app"
-  dokku --force apps:destroy my_app
+  run dokku --quiet "$PLUGIN_COMMAND_PREFIX:list"
+  assert_output "l"
 }

@test "($PLUGIN_COMMAND_PREFIX:list) when there are no services" {
  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
  run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "There are no MySQL services"
+  assert_output "${lines[*]}" "There are no $PLUGIN_SERVICE services"
  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
--- a/tests/setup.sh
+++ b/tests/setup.sh
@@ -1,5 +1,14 @@
 #!/usr/bin/env bash
-set -eo pipefail; [[ $TRACE ]] && set -x
+set -eo pipefail
+[[ $TRACE ]] && set -x
+sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 762E3157
+echo "deb http://nginx.org/packages/ubuntu $(lsb_release -cs) nginx" | sudo tee /etc/apt/sources.list.d/nginx.list
+curl -fsSL https://nginx.org/keys/nginx_signing.key | sudo apt-key add -
+
+sudo mkdir -p /etc/nginx
+sudo curl https://raw.githubusercontent.com/dokku/dokku/master/tests/dhparam.pem -o /etc/nginx/dhparam.pem
+
+echo "dokku dokku/skip_key_file boolean true" | sudo debconf-set-selections
 wget https://raw.githubusercontent.com/dokku/dokku/master/bootstrap.sh
 if [[ "$DOKKU_VERSION" == "master" ]]; then
  sudo bash bootstrap.sh
@@ -12,9 +21,10 @@ export DOKKU_LIB_ROOT="/var/lib/dokku"
 export DOKKU_PLUGINS_ROOT="$DOKKU_LIB_ROOT/plugins/available"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 sudo rm -rf "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX"
-sudo mkdir -p "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands"
+sudo mkdir -p "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/scripts"
 sudo find ./ -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" \;
-sudo find ./subcommands -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" \;
+[[ -d "./scripts" ]] && sudo find ./scripts -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/scripts" \;
+[[ -d "./subcommands" ]] && sudo find ./subcommands -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" \;
 sudo mkdir -p "$PLUGIN_CONFIG_ROOT" "$PLUGIN_DATA_ROOT"
 sudo dokku plugin:enable "$PLUGIN_COMMAND_PREFIX"
 sudo dokku plugin:install
--- a/tests/shellcheck-exclude
+++ b/tests/shellcheck-exclude
@@ -1,3 +1,7 @@
 # SC1090 - Can't follow non-constant source. Use a directive to specify location - https://github.com/koalaman/shellcheck/wiki/SC1090
 # SC2034 - Variable appears unused. Verify it or export it - https://github.com/koalaman/shellcheck/wiki/SC2034
 # SC2155 - Declare and assign separately to avoid masking return values - https://github.com/koalaman/shellcheck/wiki/SC2155
+# SC2206 - Quote to prevent word splitting/globbing, or split robustly with mapfile or read -a - https://github.com/koalaman/shellcheck/wiki/SC2206
+# SC2207 - Prefer mapfile or read -a to split command output (or quote to avoid splitting) - https://github.com/koalaman/shellcheck/wiki/SC2207
+# SC2220 - Invalid flags are not handled. Add a *) case - https://github.com/koalaman/shellcheck/wiki/SC2220
+# SC2230 - which is non-standard. Use builtin 'command -v' instead - https://github.com/koalaman/shellcheck/wiki/SC2230
--- a/tests/test_helper.bash
+++ b/tests/test_helper.bash
@@ -3,8 +3,11 @@ export DOKKU_LIB_ROOT="/var/lib/dokku"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"

 flunk() {
-  { if [ "$#" -eq 0 ]; then cat -
-    else echo "$*"
+  {
+    if [ "$#" -eq 0 ]; then
+      cat -
+    else
+      echo "$*"
    fi
  }
  return 1
@@ -12,7 +15,8 @@ flunk() {

 assert_equal() {
  if [ "$1" != "$2" ]; then
-    { echo "expected: $1"
+    {
+      echo "expected: $1"
      echo "actual:   $2"
    } | flunk
  fi
@@ -59,8 +63,10 @@ assert_contains() {
 # shellcheck disable=SC2154
 assert_output() {
  local expected
-  if [ $# -eq 0 ]; then expected="$(cat -)"
-  else expected="$1"
+  if [ $# -eq 0 ]; then
+    expected="$(cat -)"
+  else
+    expected="$1"
  fi
  assert_equal "$expected" "$output"
 }
Author	SHA1	Message	Date
Jose Diaz-Gonzalez	9557f9cc91	Release 1.11.1	2020-04-04 21:50:29 -04:00
Jose Diaz-Gonzalez	e4395e52c4	tests: drop travisci usage	2020-04-04 21:43:59 -04:00
Jose Diaz-Gonzalez	e0cf629712	tests: store test results for usage in circleci	2020-04-04 21:41:43 -04:00
Jose Diaz-Gonzalez	247838d9f8	feat: enable circleci	2020-04-04 21:27:53 -04:00
Jose Diaz-Gonzalez	1aaed290a5	feat: speed up tests by dropping dhparam generation	2020-04-04 21:27:43 -04:00
Jose Diaz-Gonzalez	ff3cd23714	fix: use python3 for generating the readme	2020-04-04 16:47:36 -04:00
Jose Diaz-Gonzalez	1b333b992c	docs: drop unimpemented commands from readme and reorganize	2020-04-04 16:43:31 -04:00
Jose Diaz-Gonzalez	636907f6eb	feat: autogenerate readme from command help	2020-04-04 16:20:35 -04:00
Jose Diaz-Gonzalez	c6ec5b74c5	fix: correct issue where help output for info flag implied multiple flags	2020-04-04 16:18:22 -04:00
Jose Diaz-Gonzalez	3f014b76b8	feat: update shellcheck excludes	2020-04-04 13:38:33 -04:00
Jose Diaz-Gonzalez	78716b46d2	feat: add xunit-reader to output xunit files in human readable format	2020-04-04 13:37:50 -04:00
Jose Diaz-Gonzalez	b21e20679c	feat: parameterize xunit-to-github version	2020-04-04 13:37:03 -04:00
Jose Diaz-Gonzalez	d19c32ce0a	fix: use non-deprecated method of fetching docker-options	2020-04-04 13:36:27 -04:00
Jose Diaz-Gonzalez	28f5f9a88c	feat: upgrade shfmt	2020-04-04 13:35:52 -04:00
Jose Diaz-Gonzalez	7af558a0dd	Release 1.11.0	2020-03-31 01:35:29 -04:00
Jose Diaz-Gonzalez	6dd81c8472	feat: upgrade tertiary container images	2020-03-30 20:12:18 -04:00
Jose Diaz-Gonzalez	3e7269293e	feat: move all image names to config file This allows us to more quickly update the image versions in use for tertiary images.	2020-03-30 20:09:03 -04:00
Jose Diaz-Gonzalez	943f1249f4	feat: add service-specific header to info call	2020-03-20 15:59:03 -04:00
Jose Diaz-Gonzalez	38120ef23d	fix: correct test case for :list command	2020-03-20 14:58:06 -04:00
Jose Diaz-Gonzalez	9e132e7712	fix: ignore the keyfile install for tests	2020-03-20 11:14:27 -04:00
Jose Diaz-Gonzalez	8312c39b40	fix: correct shellcheck issue	2020-03-20 11:05:44 -04:00
Jose Diaz-Gonzalez	562d75e6d7	feat: update travis setup - Use ubuntu bionic - Upgrade tested version of dokku	2020-03-20 10:58:25 -04:00
Jose Diaz-Gonzalez	d6df977b40	Release 1.10.1	2020-03-06 10:20:14 -05:00
Jose Diaz-Gonzalez	b3bd0eed5a	fix: correct service title	2020-03-06 10:19:43 -05:00
Jose Diaz-Gonzalez	b9da3d231a	Release 1.10.0	2020-03-03 16:05:18 -05:00
Jose Diaz-Gonzalez	d191f396bd	refactor: drop full info from :list command This can be fetched from :info if necessary, and slows down the list quite a bit.	2020-03-03 16:02:51 -05:00
Jose Diaz-Gonzalez	cf57016c86	fix: speed up service_status by reducing container status calls	2020-03-03 15:57:20 -05:00
Jose Diaz-Gonzalez	489b7db1a6	Release 1.9.5	2019-12-27 16:57:43 -05:00
Jose Diaz-Gonzalez	dc3bb16cfe	chore: update dokku/wait version	2019-12-27 16:57:13 -05:00
Jose Diaz-Gonzalez	51fce5828d	Release 1.9.4	2019-12-27 16:56:04 -05:00
Jose Diaz-Gonzalez	adee49ac1e	chore: update dokku/ambassador version	2019-12-27 16:55:25 -05:00
Jose Diaz-Gonzalez	76e36056b5	Release 1.9.3	2019-12-27 16:54:08 -05:00
Jose Diaz-Gonzalez	98699bf79d	chore: update dokku/s3backup version	2019-12-27 16:53:23 -05:00
Jose Diaz-Gonzalez	f67ccbb3e0	Release 1.9.2	2019-11-22 19:19:04 -05:00
Jose Diaz-Gonzalez	d5004ccb9b	feat: update patch release of mysql	2019-11-22 19:19:01 -05:00
Jose Diaz-Gonzalez	fa0f26d466	Release 1.9.1	2019-09-19 15:17:34 -04:00
Jose Diaz-Gonzalez	7fbf25ef2b	fix: install updated gpg key and nginx apt repository	2019-09-19 13:30:46 -04:00
Jose Diaz-Gonzalez	d3a8821897	fix: add missing ampersands	2019-07-30 10:51:51 -04:00
Jose Diaz-Gonzalez	56c918342f	chore: create scripts directory as necessary	2019-07-30 10:46:00 -04:00
Jose Diaz-Gonzalez	6c18d6740e	feat: skip subcommand copy if no subcommands directory exists	2019-07-29 22:03:01 -04:00
Jose Diaz-Gonzalez	7adb4a9a04	Release 1.9.0	2019-07-15 15:00:27 -07:00
Jose Diaz-Gonzalez	925fb8597e	feat: add service:links command This allows users to script against apps that are linked to a given service	2019-07-15 14:59:05 -07:00
Jose Diaz-Gonzalez	9b88cde4c0	Merge pull request #112 from dokku/upgrade-version Upgrade docker image versions	2019-07-15 14:17:56 -07:00
Jose Diaz-Gonzalez	0fca2b6ee0	chore: increase vm.max_map_count This is mainly used for elasticsearch but adding it to the generic test suite for all datastore plugins makes it easier to copy the travis config to each plugin.	2019-07-12 13:43:57 -07:00
Jose Diaz-Gonzalez	26084da79a	fix: use correct variable for checking for password file	2019-07-12 12:56:37 -07:00
Jose Diaz-Gonzalez	6418fa4474	chore: update build targets	2019-07-11 16:35:06 -07:00
Jose Diaz-Gonzalez	c585944582	chore: move to helper functions for fetching passwords	2019-07-11 16:34:35 -07:00
Jose Diaz-Gonzalez	3b9255bf85	chore: reorder images	2019-07-11 14:32:49 -07:00
Jose Diaz-Gonzalez	3c28a9f2a7	feat: update ambassador, s3backup, and wait images	2019-07-11 14:31:47 -07:00
Jose Diaz-Gonzalez	c5a6f4fc37	feat: upgrade busybox to 1.31.0-uclibc	2019-07-11 13:36:41 -07:00
Jose Diaz-Gonzalez	70fb9d8d1d	feat: upgrade to 5.7.26	2019-07-11 13:24:12 -07:00
Jose Diaz-Gonzalez	e4272eabde	Release 1.8.1	2019-06-11 15:45:36 -04:00
Jose Diaz-Gonzalez	4f7e01973a	fix: ensure the tracked container id is up to date If the ID file contained an incorrect value, calling :start would say the service is started but :info would still show the container as missing. Also fix an issue where docker inspect leaked stderr when the container was missing. Refs dokku/dokku-redis#133	2019-06-11 15:44:54 -04:00
Jose Diaz-Gonzalez	236770b80e	Release 1.8.0	2019-06-08 15:57:45 +02:00
Jose Diaz-Gonzalez	97b9b9582f	fix: drop now unnecessary rm call in config This was used to delete an errant '*' service that was accidentally created during service deletion. That was fixed in dokku/dokku-redis#126 - and the respective PRs for each service - and is thus no longer necessary. The fix was done by utilizing pushd when iterating over folders instead of trying to get a subdirectory with a partially quoted path. Closes dokku/dokku-redis#130	2019-06-08 15:53:54 +02:00
Jose Diaz-Gonzalez	040f100686	Merge pull request #111 from dokku/allow-dash-in-name feat: re-allow dashes in names	2019-06-08 14:55:42 +02:00
Jose Diaz-Gonzalez	ce916eb846	feat: re-allow dashes in names This PR allows dashes in service names, while still sanitizing them before they are used as database names. If the datastore is pre-existing, the datatabase name is assumed to be the same as the service name, and returned appropriately.	2019-05-30 17:03:48 -04:00
Jose Diaz-Gonzalez	143e249892	chore: reorder functions	2019-05-30 11:13:22 -04:00
Jose Diaz-Gonzalez	416a26c107	chore: move retry-docker-command to common-functions	2019-05-30 11:11:02 -04:00
Jose Diaz-Gonzalez	6fe30de9f2	chore: run shfmt	2019-05-30 11:06:25 -04:00