Release 1.12.2

fix: store the correct path
Release 1.12.1
2020-04-04 22:28:01 -04:00 · 2020-04-04 22:25:11 -04:00 · 2020-04-04 21:50:44 -04:00 · 2020-04-04 21:44:00 -04:00 · 2020-04-04 21:41:43 -04:00 · 2020-04-04 21:27:54 -04:00
51 changed files with 1546 additions and 440 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: tmp/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: tmp/test-results
+
+workflows:
+  version: 2
+  build:
+    jobs:
+      - "build-master"
+      - "build-version"
--- a/.github/labels.yml
+++ b/.github/labels.yml
@@ -0,0 +1,57 @@
+labels:
+- name: bc-break
+  color: eb6420
+- name: blocks release
+  color: "000000"
+- name: 'difficulty: easy'
+  color: c5def5
+- name: 'difficulty: hard'
+  color: e99695
+- name: 'difficulty: medium'
+  color: fef2c0
+- name: hacktoberfest
+  color: b0581d
+- name: 'needs: documentation'
+  color: c2e0c6
+- name: 'needs: more info'
+  color: c2e0c6
+- name: 'needs: rebase'
+  color: c2e0c6
+- name: 'needs: tests'
+  color: c2e0c6
+- name: 'status: duplicate'
+  color: cccccc
+- name: 'status: fix-provided'
+  color: c5def5
+- name: 'status: future'
+  color: c5def5
+- name: 'status: has plan'
+  color: c5def5
+- name: 'status: invalid'
+  color: cccccc
+- name: 'status: merge for next minor'
+  color: c5def5
+- name: 'status: merge for next patch'
+  color: c5def5
+- name: 'status: wontfix'
+  color: cccccc
+- name: 'type: bug'
+  color: e01b1b
+- name: 'type: documentation'
+  color: 0052cc
+- name: 'type: enhancement'
+  color: 09ab3c
+- name: 'type: question'
+  color: cc317c
+- name: 'type: refactor'
+  color: 0052cc
+- name: 'type: rfc'
+  color: 0052cc
+- name: 'type: roadmap'
+  color: 0052cc
+- name: 'type: service'
+  color: "5319e7"
+- name: 'type: support'
+  color: cc317c
+- name: 'type: tests'
+  color: 0052cc
--- 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 redis [![Build Status](https://img.shields.io/travis/dokku/dokku-redis.svg?branch=master "Build Status")](https://travis-ci.org/dokku/dokku-redis) [![IRC Network](https://img.shields.io/badge/irc-freenode-blue.svg "IRC Freenode")](https://webchat.freenode.net/?channels=dokku)

-Official redis plugin for dokku. Currently defaults to installing [redis 4.0.11](https://hub.docker.com/_/redis/).
+Official redis plugin for dokku. Currently defaults to installing [redis 5.0.7](https://hub.docker.com/_/redis/).

-## requirements
+## Requirements

 - dokku 0.12.x+
 - docker 1.8.x

-## installation
+## Installation

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

-## commands
+## Commands

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

 ```shell
-# create a redis service named lolipop
-dokku redis:create lolipop
+# usage
+dokku redis: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 redis image
-export REDIS_IMAGE="redis"
-export REDIS_IMAGE_VERSION="2.8.21"
-dokku redis:create lolipop
+Create a redis service named lolipop:

-# you can also specify custom environment
-# variables to start the redis service
-# in semi-colon separated form
+```shell
+dokku redis:create lolipop
+```
+
+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 REDIS_IMAGE="${PLUGIN_IMAGE}"
+export REDIS_IMAGE_VERSION="${PLUGIN_IMAGE_VERSION}"
+dokku redis:create lolipop
+```
+
+You can also specify custom environment variables to start the redis service in semi-colon separated form.
+
+```shell
 export REDIS_CUSTOM_ENV="USER=alpha;HOST=beta"
 dokku redis:create lolipop
+```

-# get connection information as follows
+### print the service information
+
+```shell
+# usage
+dokku redis:info <service> [--single-info-flag]
+```
+
+Get connection information as follows:
+
+```shell
 dokku redis: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 redis:info lolipop --config-dir
 dokku redis:info lolipop --data-dir
 dokku redis:info lolipop --dsn
@@ -83,153 +110,494 @@ dokku redis:info lolipop --links
 dokku redis:info lolipop --service-root
 dokku redis:info lolipop --status
 dokku redis:info lolipop --version
+```

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

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

-# a redis 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 redis: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_REDIS_LOLIPOP_NAME=/lolipop/DATABASE
-#   DOKKU_REDIS_LOLIPOP_PORT=tcp://172.17.0.1:6379
-#   DOKKU_REDIS_LOLIPOP_PORT_6379_TCP=tcp://172.17.0.1:6379
-#   DOKKU_REDIS_LOLIPOP_PORT_6379_TCP_PROTO=tcp
-#   DOKKU_REDIS_LOLIPOP_PORT_6379_TCP_PORT=6379
-#   DOKKU_REDIS_LOLIPOP_PORT_6379_TCP_ADDR=172.17.0.1
-#
-# and the following will be set on the linked application by default
-#
-#   REDIS_URL=redis://lolipop:SOME_PASSWORD@dokku-redis-lolipop:6379
-#
-# 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 redis:list
+```

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

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

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

-# this will replace REDIS_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:
-#
-#   REDIS_URL=redis://other_service:ANOTHER_PASSWORD@dokku-redis-other-service:6379
-#   DOKKU_REDIS_BLUE_URL=redis://other_service:ANOTHER_PASSWORD@dokku-redis-other-service:6379
-#   DOKKU_REDIS_SILVER_URL=redis://lolipop:SOME_PASSWORD@dokku-redis-lolipop:6379/lolipop
-
-# you can also unlink a redis service
-# NOTE: this will restart your app and unset related environment variables
-dokku redis:unlink lolipop playground
-
-# you can tail logs for a particular service
+```shell
 dokku redis:logs lolipop
-dokku redis:logs lolipop -t # to tail
-
-# you can dump the database
-dokku redis:export lolipop > lolipop.rdb
-
-# you can import a dump
-dokku redis:import lolipop < database.rdb
-
-# you can clone an existing database to a new one
-dokku redis:clone lolipop new_database
-
-# finally, you can destroy the container
-dokku redis:destroy lolipop
 ```

-## Changing database adapter
+By default, logs will not be tailed, but you can do this with the --tail flag:

-It's possible to change the protocol for REDIS_URL by setting
-the environment variable REDIS_DATABASE_SCHEME on the app:
+```shell
+dokku redis:logs lolipop --tail
+```
+
+### link the redis service to the app
+
+```shell
+# usage
+dokku redis:link <service> <app> [--link-flags...]
+```
+
+A redis 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 redis:link lolipop playground
+```
+
+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_REDIS_LOLIPOP_NAME=/lolipop/DATABASE
+DOKKU_REDIS_LOLIPOP_PORT=tcp://172.17.0.1:6379
+DOKKU_REDIS_LOLIPOP_PORT_6379_TCP=tcp://172.17.0.1:6379
+DOKKU_REDIS_LOLIPOP_PORT_6379_TCP_PROTO=tcp
+DOKKU_REDIS_LOLIPOP_PORT_6379_TCP_PORT=6379
+DOKKU_REDIS_LOLIPOP_PORT_6379_TCP_ADDR=172.17.0.1
+```
+
+The following will be set on the linked application by default:
+
+```
+REDIS_URL=redis://lolipop:SOME_PASSWORD@dokku-redis-lolipop:6379/lolipop
+```
+
+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:
+
+```shell
+dokku redis:link other_service playground
+```
+
+It is possible to change the protocol for redis_url by setting the environment variable redis_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.
+
+```shell
 dokku config:set playground REDIS_DATABASE_SCHEME=redis2
 dokku redis:link lolipop playground
 ```

-Will cause REDIS_URL to be set as
+This will cause redis_url to be set as:
+
+```
 redis2://lolipop:SOME_PASSWORD@dokku-redis-lolipop:6379/lolipop
+```

-CAUTION: Changing REDIS_DATABASE_SCHEME after linking will cause dokku to
-believe the redis is not linked when attempting to use `dokku redis:unlink`
-or `dokku redis:promote`.
-You should be able to fix this by
+### unlink the redis service from the app

- Changing REDIS_URL manually to the new value.
+```shell
+# usage
+dokku redis:unlink <service> <app>
+```

-OR
+You can unlink a redis service:

- Set REDIS_DATABASE_SCHEME back to its original setting
- Unlink the service
- Change REDIS_DATABASE_SCHEME to the desired setting
- Relink the service
+> NOTE: this will restart your app and unset related environment variables

-## Backups
+```shell
+dokku redis:unlink lolipop playground
+```
+
+### Service Lifecycle
+
+The lifecycle of each service can be managed through the following commands:
+
+### connect to the service via the redis connection tool
+
+```shell
+# usage
+dokku redis:connect <service>
+```
+
+Connect to the service via the redis connection tool:
+
+```shell
+dokku redis:connect lolipop
+```
+
+### enter or run a command in a running redis service container
+
+```shell
+# usage
+dokku redis:enter <service>
+```
+
+A bash prompt can be opened against a running service. Filesystem changes will not be saved to disk.
+
+```shell
+dokku redis:enter lolipop
+```
+
+You may also run a command directly against the service. Filesystem changes will not be saved to disk.
+
+```shell
+dokku redis:enter lolipop touch /tmp/test
+```
+
+### expose a redis service on custom port if provided (random port otherwise)
+
+```shell
+# usage
+dokku redis: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 redis:expose lolipop ${PLUGIN_DATASTORE_PORTS[@]}
+```
+
+### unexpose a previously exposed redis service
+
+```shell
+# usage
+dokku redis:unexpose <service>
+```
+
+Unexpose the service, removing access to it from the public interface (0. 0. 0. 0):
+
+```shell
+dokku redis:unexpose lolipop
+```
+
+### promote service <service> as REDIS_URL in <app>
+
+```shell
+# usage
+dokku redis:promote <service> <app>
+```
+
+If you have a redis service linked to an app and try to link another redis service another link environment variable will be generated automatically:
+
+```
+DOKKU_REDIS_BLUE_URL=redis://other_service:ANOTHER_PASSWORD@dokku-redis-other-service:6379/other_service
+```
+
+You can promote the new service to be the primary one:
+
+> NOTE: this will restart your app
+
+```shell
+dokku redis:promote other_service playground
+```
+
+This will replace redis_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:
+
+```
+REDIS_URL=redis://other_service:ANOTHER_PASSWORD@dokku-redis-other-service:6379/other_service
+DOKKU_REDIS_BLUE_URL=redis://other_service:ANOTHER_PASSWORD@dokku-redis-other-service:6379/other_service
+DOKKU_REDIS_SILVER_URL=redis://lolipop:SOME_PASSWORD@dokku-redis-lolipop:6379/lolipop
+```
+
+### start a previously stopped redis service
+
+```shell
+# usage
+dokku redis:start <service>
+```
+
+Start the service:
+
+```shell
+dokku redis:start lolipop
+```
+
+### stop a running redis service
+
+```shell
+# usage
+dokku redis:stop <service>
+```
+
+Stop the service and the running container:
+
+```shell
+dokku redis:stop lolipop
+```
+
+### graceful shutdown and restart of the redis service container
+
+```shell
+# usage
+dokku redis:restart <service>
+```
+
+Restart the service:
+
+```shell
+dokku redis:restart lolipop
+```
+
+### upgrade service <service> to the specified versions
+
+```shell
+# usage
+dokku redis:upgrade <service> [--upgrade-flags...]
+```
+
+You can upgrade an existing service to a new image or image-version:
+
+```shell
+dokku redis:upgrade lolipop
+```
+
+### Service Automation
+
+Service scripting can be executed using the following commands:
+
+### list all redis service links for a given app
+
+```shell
+# usage
+dokku redis:app-links <app>
+```
+
+List all redis services that are linked to the 'playground' app.
+
+```shell
+dokku redis:app-links playground
+```
+
+### create container <new-name> then copy data from <name> into <new-name>
+
+```shell
+# usage
+dokku redis:clone <service> <new-service> [--clone-flags...]
+```
+
+You can clone an existing service to a new one:
+
+```shell
+dokku redis:clone lolipop lolipop-2
+```
+
+### check if the redis service exists
+
+```shell
+# usage
+dokku redis:exists <service>
+```
+
+Here we check if the lolipop redis service exists.
+
+```shell
+dokku redis:exists lolipop
+```
+
+### check if the redis service is linked to an app
+
+```shell
+# usage
+dokku redis:linked <service> <app>
+```
+
+Here we check if the lolipop redis service is linked to the 'playground' app.
+
+```shell
+dokku redis:linked lolipop playground
+```
+
+### list all apps linked to the redis service
+
+```shell
+# usage
+dokku redis:links <service>
+```
+
+List all apps linked to the 'lolipop' redis service.
+
+```shell
+dokku redis:links lolipop
+```
+
+### Data Management
+
+The underlying service data can be imported and exported with the following commands:
+
+### import a dump into the redis service database
+
+```shell
+# usage
+dokku redis:import <service>
+```
+
+Import a datastore dump:
+
+```shell
+dokku redis:import lolipop < database.dump
+```
+
+### export a dump of the redis service database
+
+```shell
+# usage
+dokku redis:export <service>
+```
+
+By default, datastore output is exported to stdout:
+
+```shell
+dokku redis:export lolipop
+```
+
+You can redirect this output to a file:
+
+```shell
+dokku redis: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 redis service
+
+```shell
+# usage
+dokku redis: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 redis:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY
-
-# remove s3 authentication
-dokku redis:backup-deauth lolipop
-
-# backup the `lolipop` service to the `BUCKET_NAME` bucket on AWS
-dokku redis:backup lolipop BUCKET_NAME
-
-# schedule a backup
-# CRON_SCHEDULE is a crontab expression, eg. "0 3 * * *" for each day at 3am
-dokku redis:backup-schedule lolipop CRON_SCHEDULE BUCKET_NAME
-
-# cat the contents of the configured backup cronfile for the service
-dokku redis:backup-schedule-cat lolipop
-
-# remove the scheduled backup from cron
-dokku redis: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 redis: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 redis: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 redis: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 redis service
+
+```shell
+# usage
+dokku redis:backup-deauth <service>
+```
+
+Remove s3 authentication:
+
+```shell
+dokku redis:backup-deauth lolipop
+```
+
+### creates a backup of the redis service to an existing s3 bucket
+
+```shell
+# usage
+dokku redis:backup <service> <bucket-name> [--use-iam]
+```
+
+Backup the 'lolipop' service to the 'my-s3-bucket' bucket on aws:
+
+```shell
+dokku redis:backup lolipop my-s3-bucket --use-iam
+```
+
+### sets encryption for all future backups of redis service
+
+```shell
+# usage
+dokku redis:backup-set-encryption <service> <passphrase>
+```
+
+Set a gpg passphrase for backups:
+
+```shell
+dokku redis:backup-set-encryption lolipop
+```
+
+### unsets encryption for future backups of the redis service
+
+```shell
+# usage
+dokku redis:backup-unset-encryption <service>
+```
+
+Unset a gpg encryption key for backups:
+
+```shell
+dokku redis:backup-unset-encryption lolipop
+```
+
+### schedules a backup of the redis service
+
+```shell
+# usage
+dokku redis: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 redis:backup-schedule lolipop "0 3 * * *" my-s3-bucket
+```
+
+Schedule a backup and authenticate via iam:
+
+```shell
+dokku redis:backup-schedule lolipop "0 3 * * *" my-s3-bucket --use-iam
+```
+
+### cat the contents of the configured backup cronfile for the service
+
+```shell
+# usage
+dokku redis:backup-schedule-cat <service>
+```
+
+Cat the contents of the configured backup cronfile for the service:
+
+```shell
+dokku redis:backup-schedule-cat lolipop
+```
+
+### unschedules the backup of the redis service
+
+```shell
+# usage
+dokku redis:backup-unschedule <service>
+```
+
+Remove the scheduled backup from cron:
+
+```shell
+dokku redis:backup-unschedule lolipop
+```
+
+### Disabling `docker pull` calls

 If you wish to disable the `docker pull` calls that the plugin triggers, you may set the `REDIS_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/323
+++ b/323
@@ -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,25 +115,40 @@ 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}"
    local IN_USE=$(echo "$EXISTING_CONFIG" | grep "${ALIAS}_URL")
-    if [[ -n $IN_USE ]]; then
-      unset ALIAS
+    if [[ -z "$IN_USE" ]]; then
+      break
    fi
+    unset ALIAS
  done
  echo "$ALIAS"
 }
@@ -125,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
@@ -158,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"
@@ -185,7 +218,7 @@ service_backup() {
  fi

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

 service_backup_auth() {
@@ -194,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
 }

@@ -230,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"
@@ -248,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"
@@ -263,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() {
@@ -289,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=""
@@ -317,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
 }
@@ -326,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

@@ -355,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#*: }")"
@@ -414,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"
@@ -429,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() {
@@ -470,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
@@ -479,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

@@ -504,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() {
@@ -563,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
@@ -601,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
@@ -645,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() {
@@ -655,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
 }
@@ -669,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
@@ -696,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"
@@ -712,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() {
@@ -732,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 REDIS_IMAGE=${REDIS_IMAGE:="redis"}
-export REDIS_IMAGE_VERSION=${REDIS_IMAGE_VERSION:="4.0.11"}
+export REDIS_IMAGE_VERSION=${REDIS_IMAGE_VERSION:="5.0.7"}
 export REDIS_ROOT=${REDIS_ROOT:="$DOKKU_LIB_ROOT/services/redis"}
 export REDIS_HOST_ROOT=${REDIS_HOST_ROOT:=$REDIS_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/50
+++ b/50
@@ -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"
@@ -24,7 +25,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 +45,8 @@ service_create() {
  mkdir -p "$SERVICE_ROOT/config" || dokku_log_fail "Unable to create service config directory"
  touch "$LINKS_FILE"

-  if [[ -z $REDIS_CONFIG_PATH ]] ; then
-    curl -sSL "https://raw.githubusercontent.com/antirez/redis/${PLUGIN_IMAGE_VERSION:0:3}/redis.conf" > "$SERVICE_ROOT/config/redis.conf" || dokku_log_fail "Unable to download the default redis.conf to the config directory"
+  if [[ -z $REDIS_CONFIG_PATH ]]; then
+    curl -sSL "https://raw.githubusercontent.com/antirez/redis/${PLUGIN_IMAGE_VERSION:0:3}/redis.conf" >"$SERVICE_ROOT/config/redis.conf" || dokku_log_fail "Unable to download the default redis.conf to the config directory"
  else
    cp "$REDIS_CONFIG_PATH" "$SERVICE_ROOT/config/redis.conf" || dokku_log_fail "Unable to copy the ${REDIS_CONFIG_PATH} to the config directory"
  fi
@@ -53,16 +55,18 @@ service_create() {
    PASSWORD="$SERVICE_PASSWORD"
    dokku_log_warn "Specified password may not be as secure as the auto-generated password"
  fi
-  echo "$PASSWORD" > "$SERVICE_ROOT/PASSWORD"
+  echo "$PASSWORD" >"$SERVICE_ROOT/PASSWORD"
  chmod 640 "$SERVICE_ROOT/PASSWORD"
  sed -i.bak "s/# requirepass.*/requirepass ${PASSWORD}/" "$SERVICE_ROOT/config/redis.conf" && rm "$SERVICE_ROOT/config/redis.conf.bak"

  [[ -n "$SERVICE_CUSTOM_ENV" ]] && REDIS_CUSTOM_ENV="$SERVICE_CUSTOM_ENV"
  if [[ -n $REDIS_CUSTOM_ENV ]]; then
-    echo "$REDIS_CUSTOM_ENV" | tr ';' "\n" > "$SERVICE_ROOT/ENV"
+    echo "$REDIS_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,10 +77,10 @@ service_create_container() {
  local SERVICE_NAME="$(get_service_name "$SERVICE")"

  ID=$(docker run --name "$SERVICE_NAME" -v "$SERVICE_HOST_ROOT/data:/data" -v "$SERVICE_HOST_ROOT/config:/usr/local/etc/redis" --env-file="$SERVICE_ROOT/ENV" -d --restart always --label dokku=service --label dokku.service=redis "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" redis-server /usr/local/etc/redis/redis.conf --bind 0.0.0.0)
-  echo "$ID" > "$SERVICE_ROOT/ID"
+  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"
@@ -89,7 +93,16 @@ service_export() {
  local PASSWORD="$(service_password "$SERVICE")"

  [[ -n $SSH_TTY ]] && stty -opost
-  docker exec "$SERVICE_NAME" bash -c "echo SAVE | redis-cli -a ${PASSWORD}" > /dev/null 2>&1
+  LASTSAVE1=$(docker exec "$SERVICE_NAME" bash -c "echo LASTSAVE | redis-cli -a ${PASSWORD}")
+  docker exec "$SERVICE_NAME" bash -c "echo BGSAVE | redis-cli -a ${PASSWORD}" >/dev/null 2>&1
+  LASTSAVE2=$(docker exec "$SERVICE_NAME" bash -c "echo LASTSAVE | redis-cli -a ${PASSWORD}")
+
+  until [[ "$LASTSAVE1" != "$LASTSAVE2" ]];
+  do
+    LASTSAVE2=$(docker exec "$SERVICE_NAME" bash -c "echo LASTSAVE | redis-cli -a ${PASSWORD}")
+    sleep 5
+  done
+
  docker exec "$SERVICE_NAME" cat /data/dump.rdb
  status=$?
  [[ -n $SSH_TTY ]] && stty opost
@@ -104,9 +117,9 @@ service_import() {
  if [[ -t 0 ]]; then
    dokku_log_fail "No data provided on stdin."
  fi
-  dokku "$PLUGIN_COMMAND_PREFIX:stop" "$SERVICE" > /dev/null 2>&1
+  dokku "$PLUGIN_COMMAND_PREFIX:stop" "$SERVICE" >/dev/null 2>&1
  docker run --rm -i -v "$SERVICE_HOST_ROOT/data:/data" "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" bash -c "cat > /data/dump.rdb && chown redis: /data/dump.rdb"
-  dokku "$PLUGIN_COMMAND_PREFIX:start" "$SERVICE" > /dev/null 2>&1
+  dokku "$PLUGIN_COMMAND_PREFIX:start" "$SERVICE" >/dev/null 2>&1
 }

 service_start() {
@@ -117,6 +130,10 @@ 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

@@ -124,7 +141,7 @@ service_start() {
  local PREVIOUS_ID=$(docker ps -aq --no-trunc --filter "status=exited" --filter "name=^/$SERVICE_NAME$" --format '{{ .ID }}') || true

  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"; then
@@ -134,13 +151,6 @@ service_start() {
  fi
 }

-service_password() {
-    local SERVICE="$1"
-    local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
-    local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
-    echo "$PASSWORD"
-}
-
 service_url() {
  local SERVICE="$1"
  local PASSWORD="$(service_password "$SERVICE")"
--- 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.1"
-  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 redis service plugin"
-version = "1.6.0"
+version = "1.12.2"
 [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,14 @@ 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"
+
+  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 +23,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
@@ -3,14 +3,17 @@ load test_helper

 setup() {
  dokku "$PLUGIN_COMMAND_PREFIX:create" l
+  dokku "$PLUGIN_COMMAND_PREFIX:create" m
  dokku apps:create my_app
 }

 teardown() {
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" m
  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
  dokku --force apps:destroy my_app
 }

+
@test "($PLUGIN_COMMAND_PREFIX:link) error when there are no arguments" {
  run dokku "$PLUGIN_COMMAND_PREFIX:link"
  echo "output: $output"
@@ -69,14 +72,20 @@ teardown() {
  dokku config:set my_app REDIS_URL=redis://host:6379
  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
  run dokku config my_app
-  assert_contains "${lines[*]}" "DOKKU_REDIS_"
+  assert_contains "${lines[*]}" "DOKKU_REDIS_AQUA_URL"
  assert_success
+
+  dokku "$PLUGIN_COMMAND_PREFIX:link" m my_app
+  run dokku config my_app
+  assert_contains "${lines[*]}" "DOKKU_REDIS_BLACK_URL"
+  assert_success
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" m my_app
  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
 }

@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.redis.l:dokku-redis-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     redis:4.0.11  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     redis:4.0.11  running  6379->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     redis:4.0.11  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 Redis 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	75efb47a97	Release 1.12.2	2020-04-04 22:28:01 -04:00
Jose Diaz-Gonzalez	3d4258c794	fix: store the correct path	2020-04-04 22:25:11 -04:00
Jose Diaz-Gonzalez	4c194bf734	Release 1.12.1	2020-04-04 21:50:44 -04:00
Jose Diaz-Gonzalez	53968775f6	tests: drop travisci usage	2020-04-04 21:44:00 -04:00
Jose Diaz-Gonzalez	9589ad3924	tests: store test results for usage in circleci	2020-04-04 21:41:43 -04:00
Jose Diaz-Gonzalez	5093de6bd9	feat: enable circleci	2020-04-04 21:27:54 -04:00
Jose Diaz-Gonzalez	565dba9801	feat: speed up tests by dropping dhparam generation	2020-04-04 21:27:43 -04:00
Jose Diaz-Gonzalez	81cca3b12b	fix: use python3 for generating the readme	2020-04-04 16:47:36 -04:00
Jose Diaz-Gonzalez	2d07341518	docs: drop unimpemented commands from readme and reorganize	2020-04-04 16:43:31 -04:00
Jose Diaz-Gonzalez	18f925d9f4	feat: autogenerate readme from command help	2020-04-04 16:20:35 -04:00
Jose Diaz-Gonzalez	a4e1f43905	fix: correct issue where help output for info flag implied multiple flags	2020-04-04 16:18:22 -04:00
Jose Diaz-Gonzalez	a6f3ea4552	feat: update shellcheck excludes	2020-04-04 13:38:33 -04:00
Jose Diaz-Gonzalez	138bcd3fe1	feat: add xunit-reader to output xunit files in human readable format	2020-04-04 13:37:51 -04:00
Jose Diaz-Gonzalez	da6676efb8	feat: parameterize xunit-to-github version	2020-04-04 13:37:04 -04:00
Jose Diaz-Gonzalez	3a7564c401	fix: use non-deprecated method of fetching docker-options	2020-04-04 13:36:27 -04:00
Jose Diaz-Gonzalez	2d820a7c1c	feat: upgrade shfmt	2020-04-04 13:35:52 -04:00
Jose Diaz-Gonzalez	ba4024d202	Release 1.12.0	2020-03-31 01:38:34 -04:00
Jose Diaz-Gonzalez	34cbc30f63	feat: upgrade tertiary container images	2020-03-30 20:12:18 -04:00
Jose Diaz-Gonzalez	9ace27266c	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:04 -04:00
Jose Diaz-Gonzalez	d2185f2144	feat: add service-specific header to info call	2020-03-20 15:59:03 -04:00
Jose Diaz-Gonzalez	6feb270037	fix: correct test case for :list command	2020-03-20 14:58:06 -04:00
Jose Diaz-Gonzalez	62484924e6	fix: ignore the keyfile install for tests	2020-03-20 11:14:27 -04:00
Jose Diaz-Gonzalez	b9740bffcd	fix: correct shellcheck issue	2020-03-20 11:05:44 -04:00
Jose Diaz-Gonzalez	3c4267fbb9	feat: update travis setup - Use ubuntu bionic - Upgrade tested version of dokku	2020-03-20 10:58:25 -04:00
Jose Diaz-Gonzalez	fb1b189aea	Release 1.11.1	2020-03-06 10:20:27 -05:00
Jose Diaz-Gonzalez	e216b97c23	fix: correct service title	2020-03-06 10:19:43 -05:00
Jose Diaz-Gonzalez	0c210e64f3	Release 1.11.0	2020-03-03 16:05:40 -05:00
Jose Diaz-Gonzalez	bc9874bc49	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	b7cfbd37b4	fix: speed up service_status by reducing container status calls	2020-03-03 15:57:21 -05:00
Jose Diaz-Gonzalez	0ecf4f7cfd	Release 1.10.4	2019-12-27 16:57:56 -05:00
Jose Diaz-Gonzalez	3bfcb5bc2c	chore: update dokku/wait version	2019-12-27 16:57:13 -05:00
Jose Diaz-Gonzalez	0fe6933897	Release 1.10.3	2019-12-27 16:56:17 -05:00
Jose Diaz-Gonzalez	0cec2f2119	chore: update dokku/ambassador version	2019-12-27 16:55:26 -05:00
Jose Diaz-Gonzalez	3dcf263b56	Release 1.10.2	2019-12-27 16:54:21 -05:00
Jose Diaz-Gonzalez	233b03e7ca	chore: update dokku/s3backup version	2019-12-27 16:53:23 -05:00
Jose Diaz-Gonzalez	9bc7830c0c	Release 1.10.1	2019-11-22 19:17:09 -05:00
Jose Diaz-Gonzalez	150591eb75	feat: update patch release of redis	2019-11-22 19:16:55 -05:00
Jose Diaz-Gonzalez	417311e9fb	Release 1.10.0	2019-09-19 15:29:17 -04:00
Jose Diaz-Gonzalez	6fe12abbb5	Merge pull request #139 from plotly/11839-modify-SAVE-call Modify export command to use BGSAVE.	2019-09-19 15:28:54 -04:00
Jose Diaz-Gonzalez	bb27a06da9	Release 1.9.1	2019-09-19 15:17:48 -04:00
V. Anastassiou	068145b46e	Modify export command to use BGSAVE.	2019-09-19 13:40:28 -04:00
Jose Diaz-Gonzalez	c5442f9754	Delete empty	2019-09-19 13:28:28 -04:00
Jose Diaz-Gonzalez	07c36b7e6f	Merge pull request #141 from dokku/test-ci fix: import the missing key and install nginx from upstream	2019-09-19 13:28:05 -04:00
Jose Diaz-Gonzalez	b2b39c86f1	fix: import the missing key and install nginx from upstream	2019-09-19 12:59:58 -04:00
Jose Diaz-Gonzalez	0a0e6c3140	fix: add missing ampersands	2019-07-30 10:51:51 -04:00
Jose Diaz-Gonzalez	007acf952a	chore: create scripts directory as necessary	2019-07-30 10:46:00 -04:00
Jose Diaz-Gonzalez	28275d777d	feat: skip subcommand copy if no subcommands directory exists	2019-07-29 22:03:01 -04:00
Jose Diaz-Gonzalez	a243d3cec9	Release 1.9.0	2019-07-15 15:00:46 -07:00
Jose Diaz-Gonzalez	312d9298c7	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	25ad144b54	Merge pull request #134 from dokku/upgrade-version Upgrade docker image versions	2019-07-15 14:18:00 -07:00
Jose Diaz-Gonzalez	77573a97ff	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	5849f1f19f	fix: use correct variable for checking for password file	2019-07-12 12:56:37 -07:00
Jose Diaz-Gonzalez	b3eb9ed085	chore: update build targets	2019-07-11 16:35:06 -07:00
Jose Diaz-Gonzalez	86e7d53749	chore: move to helper functions for fetching passwords	2019-07-11 16:34:35 -07:00
Jose Diaz-Gonzalez	ba5b90349b	chore: reorder images	2019-07-11 14:32:49 -07:00
Jose Diaz-Gonzalez	46bd7f534f	feat: update ambassador, s3backup, and wait images	2019-07-11 14:31:47 -07:00
Jose Diaz-Gonzalez	f2342ed6fc	feat: upgrade busybox to 1.31.0-uclibc	2019-07-11 13:36:41 -07:00
Jose Diaz-Gonzalez	b1e5298be0	feat: upgrade to 5.0.5	2019-07-11 13:19:34 -07:00
Jose Diaz-Gonzalez	656cdd896f	Release 1.8.1	2019-06-11 15:45:48 -04:00
Jose Diaz-Gonzalez	0c4db51565	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:55 -04:00
Jose Diaz-Gonzalez	358f7068ba	Release 1.8.0	2019-06-08 15:58:08 +02:00
Jose Diaz-Gonzalez	a8327c9100	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	dda5b3661c	Merge pull request #132 from dokku/allow-dash-in-name feat: re-allow dashes in names	2019-06-08 14:59:44 +02:00
Jose Diaz-Gonzalez	6cc3db0896	fix: service_with_dashes is not in create output That is only the case when the service has a database specified, which is not the case for the redis plugin	2019-06-07 17:45:49 +02:00
Jose Diaz-Gonzalez	6bab5bad28	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	86ff4b4cfa	chore: reorder functions	2019-05-30 11:13:22 -04:00
Jose Diaz-Gonzalez	e8e645f087	chore: move retry-docker-command to common-functions	2019-05-30 11:11:02 -04:00
Jose Diaz-Gonzalez	7ddd0c9201	chore: run shfmt	2019-05-30 11:06:25 -04:00
Jose Diaz-Gonzalez	6545dde255	Release 1.7.0	2019-04-22 03:50:36 -04:00
Jose Diaz-Gonzalez	e1b1ada14a	Release 1.6.2	2019-04-22 03:49:50 -04:00
Jose Diaz-Gonzalez	96d5147daa	Merge pull request #129 from dokku/upgrade-versions feat: upgrade image version in use	2019-04-19 17:13:23 -04:00
Jose Diaz-Gonzalez	8c00ac34a3	feat: upgrade image version in use	2019-04-19 12:47:38 -04:00
Jose Diaz-Gonzalez	05ae4f30a7	feat: commit github labels to the repo This will allow us to apply track what labels are available in the issue tracker using tonglil/labeler.	2019-04-10 03:28:09 -04:00
Jose Diaz-Gonzalez	1957d39f60	Release 1.6.1	2019-03-28 05:25:21 -04:00
Jose Diaz-Gonzalez	2ddc21b748	fix: update docker-s3backup image to fix backups to s3	2019-03-28 05:23:39 -04:00
Jose Diaz-Gonzalez	c75fb3fa33	Merge pull request #127 from dokku/121-fix-alias fix: correct issue where aliases were being generated incorrectly	2019-03-28 05:21:41 -04:00
Jose Diaz-Gonzalez	87c89f61af	fix: correct issue where aliases were being generated incorrectly	2019-03-27 12:18:18 -04:00
Jose Diaz-Gonzalez	40e1c2c253	docs: update readme install instructions to point to correct dokku version	2019-03-26 11:51:12 -04:00