Release 1.13.0

dev: add convenience copy-file bin and fix data path used by plugin
dev: make devcontainer setup plugin agnostic
2021-09-12 04:43:02 -04:00 · 2021-09-12 03:28:55 -04:00 · 2021-09-12 02:39:17 -04:00 · 2021-09-12 00:54:23 -04:00 · 2021-09-12 00:53:12 -04:00 · 2021-09-12 00:40:12 -04:00
65 changed files with 1941 additions and 545 deletions
--- a/.devcontainer/20_init_plugin
+++ b/.devcontainer/20_init_plugin
@@ -0,0 +1,24 @@
+#!/bin/bash
+set -eo pipefail
+
+log-info() {
+  declare desc="Log info formatter"
+  echo "    $*" 1>&2
+}
+
+log-fail() {
+  declare desc="Log fail formatter"
+  echo "!   $*" 1>&2
+  exit 1
+}
+
+main() {
+  dokku plugin:install
+
+  # built in the Dockerfile
+  PLUGIN_NAME="$(source /tmp/.env && echo "$PLUGIN_NAME")"
+  PLUGIN_VARIABLE="$(source /tmp/.env && echo "$PLUGIN_VARIABLE")"
+  echo "export ${PLUGIN_VARIABLE}_HOST_ROOT=${SERVICE_HOST_ROOT}/$PLUGIN_NAME" > /etc/default/dokku
+}
+
+main "$@"
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -0,0 +1,26 @@
+FROM dokku/dokku:latest
+
+RUN apt-get update
+RUN apt-get install --no-install-recommends -y build-essential && \
+  apt-get clean autoclean && \
+  apt-get autoremove --yes && \
+  rm -rf /var/lib/apt/lists/* && \
+  mkdir -p /mnt/dokku/home/dokku /mnt/dokku/var/lib/dokku/config /mnt/dokku/var/lib/dokku/data /mnt/dokku/var/lib/dokku/services && \
+  chown -R dokku:dokku /mnt/dokku/home/dokku /mnt/dokku/var/lib/dokku/config /mnt/dokku/var/lib/dokku/data /mnt/dokku/var/lib/dokku/services && \
+  echo "dokku.me" > /home/dokku/VHOST
+
+ADD https://raw.githubusercontent.com/dokku/dokku/master/tests/dhparam.pem /mnt/dokku/etc/nginx/dhparam.pem
+
+COPY .devcontainer/20_init_plugin /etc/my_init.d/20_init_plugin
+COPY .devcontainer/bin/ /usr/local/bin/
+
+COPY . .
+
+RUN source /tmp/config && \
+  echo "export ${PLUGIN_DISABLE_PULL_VARIABLE}=true" > /tmp/.env && \
+  echo "export PLUGIN_NAME=${PLUGIN_COMMAND_PREFIX}" >> /tmp/.env && \
+  echo "export PLUGIN_VARIABLE=${PLUGIN_VARIABLE}" >> /tmp/.env
+
+RUN source /tmp/.env && \
+  dokku plugin:install file:///tmp --name $PLUGIN_NAME && \
+  make ci-dependencies
--- a/.devcontainer/bin/copy-file
+++ b/.devcontainer/bin/copy-file
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+main() {
+  PLUGIN_NAME="$(source /tmp/.env && echo "$PLUGIN_NAME")"
+  cp "$1" "/var/lib/dokku/plugins/enabled/$PLUGIN_NAME/$1"
+}
+
+main "$@"
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,16 @@
+{
+  "build": {
+    "dockerfile": "Dockerfile",
+    "context": ".."
+  },
+  "containerEnv": {
+    "SERVICE_HOST_ROOT": "${localWorkspaceFolder}/tmp/data"
+  },
+  "initializeCommand": ["mkdir", "-p", "tmp/data"],
+  "mounts": [
+    "source=/var/run/docker.sock,target=/var/run/docker.sock,type=bind",
+    "source=${localWorkspaceFolder}/tmp/data/,target=/var/lib/dokku/services/,type=bind"
+  ],
+  "overrideCommand": false,
+  "runArgs": ["--init"]
+}
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "docker"
+    directory: "/"
+    schedule:
+      interval: "daily"
--- 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/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,100 @@
+---
+name: CI
+
+# yamllint disable-line rule:truthy
+on:
+  pull_request:
+    branches:
+      - '*'
+  push:
+    branches:
+      - master
+
+jobs:
+  unit-tests-master:
+    name: unit-tests
+    runs-on: ubuntu-18.04
+    strategy:
+      fail-fast: true
+    env:
+      DOKKU_VERSION: master
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v2
+        with:
+          python-version: '3.7.x'
+
+      - run: make setup
+
+      - run: sudo sysctl -w vm.max_map_count=262144
+
+      - run: |
+          git fetch -q origin master
+          changed=$(git --no-pager diff --name-only $GITHUB_SHA..origin/master)
+          if [ $changed = "Dockerfile" ]; then
+            echo "Please run 'make generate' to update the image version in the README.md"
+          else
+            make generate
+            if ! git diff --quiet README.md; then
+              echo "Please run 'make generate'"
+              git status --short
+              git --no-pager diff README.md
+              exit 1
+            fi
+          fi
+
+      - run: make test
+
+      - uses: actions/upload-artifact@v2
+        if: failure()
+        with:
+          name: tmp/test-results
+          path: test-results
+
+  unit-tests-0_19_0:
+    name: unit-tests-0.19.0
+    runs-on: ubuntu-18.04
+    strategy:
+      fail-fast: true
+    env:
+      DOKKU_TAG: v0.19.0
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v2
+        with:
+          python-version: '3.7.x'
+
+      - run: make setup
+
+      - run: sudo sysctl -w vm.max_map_count=262144
+
+      - run: |
+          git fetch -q origin master
+          changed=$(git --no-pager diff --name-only $GITHUB_SHA..origin/master)
+          if [ $changed = "Dockerfile" ]; then
+            echo "Please run 'make generate' to update the image version in the README.md"
+          else
+            make generate
+            if ! git diff --quiet README.md; then
+              echo "Please run 'make generate'"
+              git status --short
+              git --no-pager diff README.md
+              exit 1
+            fi
+          fi
+
+      - run: make test
+
+      - uses: actions/upload-artifact@v2
+        if: failure()
+        with:
+          name: tmp/test-results
+          path: test-results
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 /tmp
 .vagrant
+bootstrap.sh
--- 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/1
+++ b/1
@@ -0,0 +1 @@
+FROM mongo:5.0.2
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,4 +1,4 @@
-Copyright (C) 2018 Jose Diaz-Gonzalez
+Copyright (C) 2020 Jose Diaz-Gonzalez

 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

--- a/40
+++ b/40
@@ -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)
@@ -7,7 +11,7 @@ ifneq ($(shell bats --version >/dev/null 2>&1 ; echo $$?),0)
 	brew install bats-core
 endif
 else
-	git clone https://github.com/josegonzalez/bats-core.git /tmp/bats
+	git clone https://github.com/bats-core/bats-core.git /tmp/bats
 	cd /tmp/bats && sudo ./install.sh /usr/local
 	rm -rf /tmp/bats
 endif
@@ -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
@@ -59,13 +63,13 @@ unit-tests:
 	@echo running unit tests...
 	@mkdir -p tmp/test-results/bats
 	@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
+	cd tests && bats --report-formatter junit --timing -o ../tmp/test-results/bats *.bats

-tmp/xunit-to-github:
+tmp/xunit-reader:
 	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
-	tar xf tmp/xunit-to-github.tgz -C tmp
-	chmod +x tmp/xunit-to-github
+	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

 setup:
 	bash tests/setup.sh
@@ -73,11 +77,17 @@ setup:

 test: lint unit-tests

-report: tmp/xunit-to-github
-ifdef TRAVIS_REPO_SLUG
-ifdef GITHUB_ACCESS_TOKEN
-ifneq ($(TRAVIS_PULL_REQUEST),false)
-	tmp/xunit-to-github --skip-ok --job-url "$(TRAVIS_JOB_WEB_URL)" --pull-request-id "$(TRAVIS_PULL_REQUEST)" --repository-slug "$(TRAVIS_REPO_SLUG)" --title "DOKKU_VERSION=$(DOKKU_VERSION)" tmp/test-results/bats tmp/test-results/shellcheck
-endif
-endif
-endif
+report: tmp/xunit-reader
+	tmp/xunit-reader -p 'tmp/test-results/bats/*.xml'
+	tmp/xunit-reader -p 'tmp/test-results/shellcheck/*.xml'
+
+.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,87 +1,127 @@
-# dokku mongo [![Build Status](https://img.shields.io/travis/dokku/dokku-mongo.svg?branch=master "Build Status")](https://travis-ci.org/dokku/dokku-mongo) [![IRC Network](https://img.shields.io/badge/irc-freenode-blue.svg "IRC Freenode")](https://webchat.freenode.net/?channels=dokku)
+# dokku mongo [![Build Status](https://img.shields.io/github/workflow/status/dokku/dokku-mongo/CI/master?style=flat-square "Build Status")](https://github.com/dokku/dokku-mongo/actions/workflows/ci.yml?query=branch%3Amaster) [![IRC Network](https://img.shields.io/badge/irc-libera-blue.svg?style=flat-square "IRC Libera")](https://webchat.libera.chat/?channels=dokku)

-Official mongo plugin for dokku. Currently defaults to installing [mongo 3.4.9](https://hub.docker.com/_/mongo/).
+Official mongo plugin for dokku. Currently defaults to installing [mongo 5.0.2](https://hub.docker.com/_/mongo/).

-## requirements
+## Requirements

- dokku 0.12.x+
+- dokku 0.19.x+
 - docker 1.8.x

-## installation
+## Installation

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

-## commands
+## Commands

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

 ```shell
-# create a mongo service named lolipop
-dokku mongo:create lolipop
+# usage
+dokku mongo: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 mongo image
+flags:
+
+- `-C|--custom-env "USER=alpha;HOST=beta"`: semi-colon delimited environment variables to start the service with
+- `-i|--image IMAGE`: the image name to start the service with
+- `-I|--image-version IMAGE_VERSION`: the image version to start the service with
+- `-p|--password PASSWORD`: override the user-level service password
+- `-r|--root-password PASSWORD`: override the root-level service password
+
+Create a mongo service named lolipop:
+
+```shell
+dokku mongo:create lolipop
+```
+
+You can also specify the image and image version to use for the service. It *must* be compatible with the mongo image. 
+
+```shell
 export MONGO_IMAGE="mongo"
-export MONGO_IMAGE_VERSION="3.0.5"
+export MONGO_IMAGE_VERSION="${PLUGIN_IMAGE_VERSION}"
 dokku mongo:create lolipop
+```

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

-# by default we use the wiredTiger storage solution
-# if you are using an image version less than 3.x
-# you will need to set a custom MONGO_CONFIG_OPTIONS
-# environment variable
-export MONGO_CONFIG_OPTIONS=" --auth "
-export MONGO_IMAGE_VERSION="2.6.11"
-dokku mongo:create lolipop
+### print the service information

-# get connection information as follows
+```shell
+# usage
+dokku mongo:info <service> [--single-info-flag]
+```
+
+flags:
+
+- `--config-dir`: show the service configuration directory
+- `--data-dir`: show the service data directory
+- `--dsn`: show the service DSN
+- `--exposed-ports`: show service exposed ports
+- `--id`: show the service container id
+- `--internal-ip`: show the service internal ip
+- `--links`: show the service app links
+- `--service-root`: show the service root directory
+- `--status`: show the service running status
+- `--version`: show the service image version
+
+Get connection information as follows:
+
+```shell
 dokku mongo: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 mongo:info lolipop --config-dir
 dokku mongo:info lolipop --data-dir
 dokku mongo:info lolipop --dsn
@@ -92,152 +132,525 @@ dokku mongo:info lolipop --links
 dokku mongo:info lolipop --service-root
 dokku mongo:info lolipop --status
 dokku mongo:info lolipop --version
+```

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

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

-# a mongo 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 mongo: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_MONGO_LOLIPOP_NAME=/lolipop/DATABASE
-#   DOKKU_MONGO_LOLIPOP_PORT=tcp://172.17.0.1:27017
-#   DOKKU_MONGO_LOLIPOP_PORT_27017_TCP=tcp://172.17.0.1:27017
-#   DOKKU_MONGO_LOLIPOP_PORT_27017_TCP_PROTO=tcp
-#   DOKKU_MONGO_LOLIPOP_PORT_27017_TCP_PORT=27017
-#   DOKKU_MONGO_LOLIPOP_PORT_27017_TCP_ADDR=172.17.0.1
-#
-# and the following will be set on the linked application by default
-#
-#   MONGO_URL=mongodb://lolipop:SOME_PASSWORD@dokku-mongo-lolipop:27017/lolipop
-#
-# NOTE: the host exposed here only works internally in docker containers. If
-# you want your container to be reachable from outside, you should use `expose`.
+```shell
+dokku mongo:list
+```

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

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

-# you can then promote the new service to be the primary one
-# NOTE: this will restart your app
-dokku mongo:promote other_service playground
+flags:

-# this will replace MONGO_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:
-#
-#   MONGO_URL=mongodb://other_service:ANOTHER_PASSWORD@dokku-mongo-other-service:27017/other_service
-#   DOKKU_MONGO_BLUE_URL=mongodb://other_service:ANOTHER_PASSWORD@dokku-mongo-other-service:27017/other_service
-#   DOKKU_MONGO_SILVER_URL=mongodb://lolipop:SOME_PASSWORD@dokku-mongo-lolipop:27017/lolipop
+- `-t|--tail`: do not stop when end of the logs are reached and wait for additional output

-# you can also unlink a mongo service
-# NOTE: this will restart your app and unset related environment variables
-dokku mongo:unlink lolipop playground
+You can tail logs for a particular service:

-# you can tail logs for a particular service
+```shell
 dokku mongo:logs lolipop
-dokku mongo:logs lolipop -t # to tail
-
-# you can dump the database
-dokku mongo:export lolipop > lolipop.dump.gz
-
-# you can import a dump
-dokku mongo:import lolipop < database.dump.gz
-
-# you can clone an existing database to a new one
-dokku mongo:clone lolipop new_database
-
-# finally, you can destroy the container
-dokku mongo:destroy lolipop
 ```

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

+```shell
+dokku mongo:logs lolipop --tail
 ```
-dokku config:set playground MONGO_DATABASE_SCHEME=mongo2
+
+### link the mongo service to the app
+
+```shell
+# usage
+dokku mongo:link <service> <app> [--link-flags...]
+```
+
+flags:
+
+- `-a|--alias "BLUE_DATABASE"`: an alternative alias to use for linking to an app via environment variable
+- `-q|--querystring "pool=5"`: ampersand delimited querystring arguments to append to the service link
+
+A mongo 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 mongo:link lolipop playground
 ```

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

-CAUTION: Changing MONGO_DATABASE_SCHEME after linking will cause dokku to
-believe the mongo is not linked when attempting to use `dokku mongo:unlink`
-or `dokku mongo:promote`.
-You should be able to fix this by
+```
+DOKKU_MONGO_LOLIPOP_NAME=/lolipop/DATABASE
+DOKKU_MONGO_LOLIPOP_PORT=tcp://172.17.0.1:27017
+DOKKU_MONGO_LOLIPOP_PORT_27017_TCP=tcp://172.17.0.1:27017
+DOKKU_MONGO_LOLIPOP_PORT_27017_TCP_PROTO=tcp
+DOKKU_MONGO_LOLIPOP_PORT_27017_TCP_PORT=27017
+DOKKU_MONGO_LOLIPOP_PORT_27017_TCP_ADDR=172.17.0.1
+```

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

-OR
+```
+MONGO_URL=mongodb://lolipop:SOME_PASSWORD@dokku-mongo-lolipop:27017/lolipop
+```

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

-## Backups
+```shell
+dokku mongo:link other_service playground
+```
+
+It is possible to change the protocol for `MONGO_URL` by setting the environment variable `MONGO_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 MONGO_DATABASE_SCHEME=mongodb2
+dokku mongo:link lolipop playground
+```
+
+This will cause `MONGO_URL` to be set as:
+
+```
+mongodb2://lolipop:SOME_PASSWORD@dokku-mongo-lolipop:27017/lolipop
+```
+
+### unlink the mongo service from the app
+
+```shell
+# usage
+dokku mongo:unlink <service> <app>
+```
+
+You can unlink a mongo service:
+
+> NOTE: this will restart your app and unset related environment variables
+
+```shell
+dokku mongo:unlink lolipop playground
+```
+
+### Service Lifecycle
+
+The lifecycle of each service can be managed through the following commands:
+
+### connect to the service via the mongo connection tool
+
+```shell
+# usage
+dokku mongo:connect <service>
+```
+
+Connect to the service via the mongo connection tool:
+
+```shell
+dokku mongo:connect lolipop
+```
+
+### enter or run a command in a running mongo service container
+
+```shell
+# usage
+dokku mongo:enter <service>
+```
+
+A bash prompt can be opened against a running service. Filesystem changes will not be saved to disk. 
+
+```shell
+dokku mongo:enter lolipop
+```
+
+You may also run a command directly against the service. Filesystem changes will not be saved to disk. 
+
+```shell
+dokku mongo:enter lolipop touch /tmp/test
+```
+
+### expose a mongo service on custom port if provided (random port otherwise)
+
+```shell
+# usage
+dokku mongo: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 mongo:expose lolipop 27017 27018 27019 28017
+```
+
+### unexpose a previously exposed mongo service
+
+```shell
+# usage
+dokku mongo:unexpose <service>
+```
+
+Unexpose the service, removing access to it from the public interface (`0.0.0.0`):
+
+```shell
+dokku mongo:unexpose lolipop
+```
+
+### promote service <service> as MONGO_URL in <app>
+
+```shell
+# usage
+dokku mongo:promote <service> <app>
+```
+
+If you have a mongo service linked to an app and try to link another mongo service another link environment variable will be generated automatically:
+
+```
+DOKKU_MONGO_BLUE_URL=mongodb://other_service:ANOTHER_PASSWORD@dokku-mongo-other-service:27017/other_service
+```
+
+You can promote the new service to be the primary one:
+
+> NOTE: this will restart your app
+
+```shell
+dokku mongo:promote other_service playground
+```
+
+This will replace `MONGO_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:
+
+```
+MONGO_URL=mongodb://other_service:ANOTHER_PASSWORD@dokku-mongo-other-service:27017/other_service
+DOKKU_MONGO_BLUE_URL=mongodb://other_service:ANOTHER_PASSWORD@dokku-mongo-other-service:27017/other_service
+DOKKU_MONGO_SILVER_URL=mongodb://lolipop:SOME_PASSWORD@dokku-mongo-lolipop:27017/lolipop
+```
+
+### start a previously stopped mongo service
+
+```shell
+# usage
+dokku mongo:start <service>
+```
+
+Start the service:
+
+```shell
+dokku mongo:start lolipop
+```
+
+### stop a running mongo service
+
+```shell
+# usage
+dokku mongo:stop <service>
+```
+
+Stop the service and the running container:
+
+```shell
+dokku mongo:stop lolipop
+```
+
+### graceful shutdown and restart of the mongo service container
+
+```shell
+# usage
+dokku mongo:restart <service>
+```
+
+Restart the service:
+
+```shell
+dokku mongo:restart lolipop
+```
+
+### upgrade service <service> to the specified versions
+
+```shell
+# usage
+dokku mongo:upgrade <service> [--upgrade-flags...]
+```
+
+flags:
+
+- `-C|--custom-env "USER=alpha;HOST=beta"`: semi-colon delimited environment variables to start the service with
+- `-i|--image IMAGE`: the image name to start the service with
+- `-I|--image-version IMAGE_VERSION`: the image version to start the service with
+- `-R|--restart-apps "true"`: whether to force an app restart
+
+You can upgrade an existing service to a new image or image-version:
+
+```shell
+dokku mongo:upgrade lolipop
+```
+
+### Service Automation
+
+Service scripting can be executed using the following commands:
+
+### list all mongo service links for a given app
+
+```shell
+# usage
+dokku mongo:app-links <app>
+```
+
+List all mongo services that are linked to the 'playground' app. 
+
+```shell
+dokku mongo:app-links playground
+```
+
+### create container <new-name> then copy data from <name> into <new-name>
+
+```shell
+# usage
+dokku mongo:clone <service> <new-service> [--clone-flags...]
+```
+
+flags:
+
+- `-C|--custom-env "USER=alpha;HOST=beta"`: semi-colon delimited environment variables to start the service with
+- `-i|--image IMAGE`: the image name to start the service with
+- `-I|--image-version IMAGE_VERSION`: the image version to start the service with
+- `-p|--password PASSWORD`: override the user-level service password
+- `-r|--root-password PASSWORD`: override the root-level service password
+
+You can clone an existing service to a new one:
+
+```shell
+dokku mongo:clone lolipop lolipop-2
+```
+
+### check if the mongo service exists
+
+```shell
+# usage
+dokku mongo:exists <service>
+```
+
+Here we check if the lolipop mongo service exists. 
+
+```shell
+dokku mongo:exists lolipop
+```
+
+### check if the mongo service is linked to an app
+
+```shell
+# usage
+dokku mongo:linked <service> <app>
+```
+
+Here we check if the lolipop mongo service is linked to the 'playground' app. 
+
+```shell
+dokku mongo:linked lolipop playground
+```
+
+### list all apps linked to the mongo service
+
+```shell
+# usage
+dokku mongo:links <service>
+```
+
+List all apps linked to the 'lolipop' mongo service. 
+
+```shell
+dokku mongo:links lolipop
+```
+
+### Data Management
+
+The underlying service data can be imported and exported with the following commands:
+
+### import a dump into the mongo service database
+
+```shell
+# usage
+dokku mongo:import <service>
+```
+
+Import a datastore dump:
+
+```shell
+dokku mongo:import lolipop < database.dump
+```
+
+### export a dump of the mongo service database
+
+```shell
+# usage
+dokku mongo:export <service>
+```
+
+By default, datastore output is exported to stdout:
+
+```shell
+dokku mongo:export lolipop
+```
+
+You can redirect this output to a file:
+
+```shell
+dokku mongo: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 mongo service
+
+```shell
+# usage
+dokku mongo: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 mongo:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY
-
-# remove s3 authentication
-dokku mongo:backup-deauth lolipop
-
-# backup the `lolipop` service to the `BUCKET_NAME` bucket on AWS
-dokku mongo:backup lolipop BUCKET_NAME
-
-# schedule a backup
-# CRON_SCHEDULE is a crontab expression, eg. "0 3 * * *" for each day at 3am
-dokku mongo:backup-schedule lolipop CRON_SCHEDULE BUCKET_NAME
-
-# cat the contents of the configured backup cronfile for the service
-dokku mongo:backup-schedule-cat lolipop
-
-# remove the scheduled backup from cron
-dokku mongo: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 mongo: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 mongo: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 mongo: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 mongo service
+
+```shell
+# usage
+dokku mongo:backup-deauth <service>
+```
+
+Remove s3 authentication:
+
+```shell
+dokku mongo:backup-deauth lolipop
+```
+
+### creates a backup of the mongo service to an existing s3 bucket
+
+```shell
+# usage
+dokku mongo:backup <service> <bucket-name> [--use-iam]
+```
+
+flags:
+
+- `-u|--use-iam`: use the IAM profile associated with the current server
+
+Backup the 'lolipop' service to the 'my-s3-bucket' bucket on ``AWS`:`
+
+```shell
+dokku mongo:backup lolipop my-s3-bucket --use-iam
+```
+
+### sets encryption for all future backups of mongo service
+
+```shell
+# usage
+dokku mongo:backup-set-encryption <service> <passphrase>
+```
+
+Set the GPG-compatible passphrase for encrypting backups for backups:
+
+```shell
+dokku mongo:backup-set-encryption lolipop
+```
+
+### unsets encryption for future backups of the mongo service
+
+```shell
+# usage
+dokku mongo:backup-unset-encryption <service>
+```
+
+Unset the `GPG` encryption passphrase for backups:
+
+```shell
+dokku mongo:backup-unset-encryption lolipop
+```
+
+### schedules a backup of the mongo service
+
+```shell
+# usage
+dokku mongo:backup-schedule <service> <schedule> <bucket-name> [--use-iam]
+```
+
+flags:
+
+- `-u|--use-iam`: use the IAM profile associated with the current server
+
+Schedule a backup:
+
+> 'schedule' is a crontab expression, eg. "0 3 * * *" for each day at 3am
+
+```shell
+dokku mongo:backup-schedule lolipop "0 3 * * *" my-s3-bucket
+```
+
+Schedule a backup and authenticate via iam:
+
+```shell
+dokku mongo:backup-schedule lolipop "0 3 * * *" my-s3-bucket --use-iam
+```
+
+### cat the contents of the configured backup cronfile for the service
+
+```shell
+# usage
+dokku mongo:backup-schedule-cat <service>
+```
+
+Cat the contents of the configured backup cronfile for the service:
+
+```shell
+dokku mongo:backup-schedule-cat lolipop
+```
+
+### unschedules the backup of the mongo service
+
+```shell
+# usage
+dokku mongo:backup-unschedule <service>
+```
+
+Remove the scheduled backup from cron:
+
+```shell
+dokku mongo:backup-unschedule lolipop
+```
+
+### Disabling `docker pull` calls

 If you wish to disable the `docker pull` calls that the plugin triggers, you may set the `MONGO_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.

--- a/bin/generate
+++ b/bin/generate
@@ -0,0 +1,518 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import print_function
+import os
+import re
+
+
+def compile(service, version, variable, alias, image, scheme, ports, sponsors, unimplemented, dokku_version):
+    prefix = "\n\n".join([
+        header(service),
+        description(service, image, version),
+    ])
+
+    if len(sponsors) > 0:
+        prefix += "\n\n"
+        prefix += sponsors_section(service, sponsors)
+
+    return (
+        "\n\n".join(
+            [
+                prefix,
+                requirements_section(dokku_version),
+                installation_section(service, dokku_version),
+                commands_section(service, variable, alias, image, scheme, ports, unimplemented),
+                usage_section(service, variable, alias, image, 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/github/workflow/status/dokku/dokku-{service}/CI/master?style=flat-square "Build Status")](https://github.com/dokku/dokku-{service}/actions/workflows/ci.yml?query=branch%3Amaster)',
+            f'[![IRC Network](https://img.shields.io/badge/irc-libera-blue.svg?style=flat-square "IRC Libera")](https://webchat.libera.chat/?channels=dokku)',
+        ]
+    )
+
+
+def description(service, full_image, version):
+    base = "_"
+    image = full_image
+    if "/" in full_image:
+        base = "r/" + full_image.split("/")[0]
+        image = full_image.split("/")[1]
+
+    return f"Official {service} plugin for dokku. Currently defaults to installing [{full_image} {version}](https://hub.docker.com/{base}/{image}/)."
+
+
+def sponsors_section(service, sponsors):
+    if len(sponsors) == 0:
+        return ""
+
+    sponsor_data = ["## Sponsors", "", f"The {service} plugin was generously sponsored by the following:", ""]
+    sponsor_data.extend([f"- [{s}](https://github.com/{s})" for s in sponsors])
+
+    return "\n".join(
+        sponsor_data
+    )
+
+
+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, variable, alias, image, 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, variable, alias, image, 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, variable, alias, image, 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, variable, alias, image, scheme, ports, unimplemented),
+            usage_lifecycle(service, variable, alias, image, scheme, ports, unimplemented),
+            usage_automation(service, variable, alias, image, scheme, ports, unimplemented),
+            usage_data_management(service, variable, alias, image, scheme, ports, unimplemented),
+            usage_backup(service, variable, alias, image, scheme, ports, unimplemented),
+            usage_docker_pull(service, variable, alias, image, scheme, ports, unimplemented),
+        ]
+    )
+
+
+def usage_intro(service, variable, alias, image, scheme, ports, unimplemented):
+    commands = ["create", "info", "list", "logs", "link", "unlink"]
+    content = ["### Basic Usage"]
+
+    return fetch_commands_content(
+        service, variable, alias, image, scheme, ports, unimplemented, commands, content
+    )
+
+
+def usage_lifecycle(service, variable, alias, image, 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, variable, alias, image, scheme, ports, unimplemented, commands, content
+    )
+
+
+def usage_automation(service, variable, alias, image, 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, variable, alias, image, scheme, ports, unimplemented, commands, content
+    )
+
+
+def usage_data_management(service, variable, alias, image, 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, variable, alias, image, scheme, ports, unimplemented, commands, content
+    )
+
+
+def usage_backup(service, variable, alias, image, 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, variable, alias, image, scheme, ports, unimplemented, commands, content
+    )
+
+
+def usage_docker_pull(service, variable, alias, image, 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, variable, alias, image, scheme, ports, unimplemented, commands, content
+):
+    i = 0
+    for command in commands:
+        output = command_help(command, service, variable, alias, image, 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, variable, alias, image, scheme, ports, unimplemented):
+    if command in unimplemented:
+        return ""
+
+    data = command_data(command, service, variable, alias, image, 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, variable, alias, image, 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_VARIABLE}", variable)
+            line = line.replace("${PLUGIN_DEFAULT_ALIAS}", alias)
+            line = line.replace("${PLUGIN_IMAGE}", image)
+            line = line.replace("${PLUGIN_SCHEME}", scheme)
+            line = line.replace("${PLUGIN_DATASTORE_PORTS[0]}", ports[0])
+            line = line.replace("${PLUGIN_DATASTORE_PORTS[@]}", " ".join(ports))
+
+            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(
+        upperfirst(i.strip()) for i in sentence_lines.split(".")
+    ).strip()
+    if not sentences.endswith(".") and not sentences.endswith(":"):
+        sentences += ":"
+
+    text = []
+    for sentence in sentences.split("."):
+        parts = []
+        for word in sentence.strip().split(" "):
+            if word.isupper() and len(word) > 1:
+                for ending in [':', '.']:
+                    if word.endswith(ending):
+                        word = '`{0}`{1}'.format(word[:-1], ending)
+                else:
+                    word = '`{0}`'.format(word)
+            parts.append(word)
+        text.append(" ".join(parts))
+
+    text = ". ".join(text)
+
+    # some cleanup
+    text = text.replace("(0. 0. 0. 0)", "(`0.0.0.0`)")
+
+    return text
+
+
+def upperfirst(x):
+    return x[:1].upper() + x[1:]
+
+
+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
+    variable = None
+    image = None
+    alias = None
+    unimplemented = []
+
+    with open("Dockerfile") as f:
+        for line in f.readlines():
+          if "FROM " in line:
+              image, version = line.split(" ")[1].split(":")
+              image = image.strip()
+              version = version.strip()
+
+    with open("config") as f:
+        for line in f.readlines():
+            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_VARIABLE=" in line:
+                variable = 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(" ")]
+
+    sponsors = []
+    with open("plugin.toml") as f:
+        for line in f.readlines():
+            if line.startswith("sponsors"):
+                sponsors = re.search("\[([\"\w\s,_-]+)\]", line).group(1)
+                sponsors = [s.strip("\"") for s in sponsors.split(",")]
+
+    text = compile(service, version, variable, alias, image, scheme, ports, sponsors, unimplemented, "0.19.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 + "\n")
+
+
+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/337
+++ b/337
@@ -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
+    suppress_output docker exec "$ID" sh -c "$COMMAND"
+    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
@@ -155,18 +188,18 @@ service_backup() {
    dokku_log_fail "Provide AWS credentials or use the --use-iam flag"
  fi

-  TMPDIR=$(mktemp -d)
-  trap 'rm -rf "$TMPDIR" > /dev/null' RETURN INT TERM EXIT
+  BACKUP_TMPDIR=$(mktemp -d --tmpdir)
+  trap 'rm -rf "$BACKUP_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" >"${BACKUP_TMPDIR}/export")

  # Build parameter list for s3backup tool
  BACKUP_PARAMETERS="$BACKUP_PARAMETERS -e BUCKET_NAME=$BUCKET_NAME"
  BACKUP_PARAMETERS="$BACKUP_PARAMETERS -e BACKUP_NAME=${PLUGIN_COMMAND_PREFIX}-${SERVICE}"
-  BACKUP_PARAMETERS="$BACKUP_PARAMETERS -v ${TMPDIR}:/backup"
+  BACKUP_PARAMETERS="$BACKUP_PARAMETERS -v ${BACKUP_TMPDIR}:/backup"

  if [[ -f "$SERVICE_BACKUP_ROOT/AWS_DEFAULT_REGION" ]]; then
    BACKUP_PARAMETERS="$BACKUP_PARAMETERS -e AWS_DEFAULT_REGION=$(cat "$SERVICE_BACKUP_ROOT/AWS_DEFAULT_REGION")"
@@ -185,7 +218,7 @@ service_backup() {
  fi

  # shellcheck disable=SC2086
-  docker run --rm $BACKUP_PARAMETERS dokkupaas/s3backup:0.8.0
+  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

@@ -343,7 +383,7 @@ service_info() {
  local flag key valid_flags

  local flag_map=(
-    "--config-dir: ${SERVICE_ROOT}/config"
+    "--config-dir: ${SERVICE_ROOT}/${PLUGIN_CONFIG_SUFFIX}"
    "--data-dir: ${SERVICE_ROOT}/data"
    "--dsn: ${SERVICE_URL}"
    "--exposed-ports: $(service_exposed_ports "$SERVICE")"
@@ -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#*: }")"
@@ -413,11 +453,12 @@ service_link() {
  fi

  [[ -n $LINK ]] && dokku_log_fail "Already linked as $LINK"
+  plugn trigger service-action pre-link "$SERVICE" "$APP"
  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"
@@ -425,37 +466,48 @@ service_link() {
    dokku docker-options:add "$APP" build,deploy,run "--link $SERVICE_NAME:$SERVICE_DNS_HOSTNAME"
  fi
  [[ -n "$SERVICE_QUERYSTRING" ]] && SERVICE_URL="${SERVICE_URL}?${SERVICE_QUERYSTRING}"
+  plugn trigger service-action post-link "$SERVICE" "$APP"
  config_set "$APP" "${ALIAS}_URL=$SERVICE_URL"
+  plugn trigger service-action post-link-complete "$SERVICE" "$APP"
 }

 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 +522,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 +531,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 +558,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 +649,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 +687,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" svendowideit/ambassador > /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 +731,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 +741,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 +749,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
@@ -694,9 +774,10 @@ service_unlink() {
  local SERVICE_DNS_HOSTNAME=$(service_dns_hostname "$SERVICE")
  local LINK=($(echo "$EXISTING_CONFIG" | grep "$SERVICE_URL" | cut -d: -f1)) || true

+  plugn trigger service-action pre-unlink "$SERVICE" "$APP"
  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"
@@ -705,14 +786,16 @@ service_unlink() {
  fi

  [[ -z ${LINK[*]} ]] && dokku_log_fail "Not linked to app $APP"
+  plugn trigger service-action post-unlink "$SERVICE" "$APP"
  config_unset "$APP" "${LINK[*]}"
+  plugn trigger service-action post-unlink-complete "$SERVICE" "$APP"
 }

 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 +815,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/13
+++ b/13
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
-export MONGO_IMAGE=${MONGO_IMAGE:="mongo"}
-export MONGO_IMAGE_VERSION=${MONGO_IMAGE_VERSION:="3.4.9"}
+_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+export MONGO_IMAGE=${MONGO_IMAGE:="$(awk -F '[ :]' '{print $2}' "${_DIR}/Dockerfile")"}
+export MONGO_IMAGE_VERSION=${MONGO_IMAGE_VERSION:="$(awk -F '[ :]' '{print $3}' "${_DIR}/Dockerfile")"}
 export MONGO_ROOT=${MONGO_ROOT:="$DOKKU_LIB_ROOT/services/mongo"}
 export MONGO_HOST_ROOT=${MONGO_HOST_ROOT:=$MONGO_ROOT}

@@ -21,12 +22,14 @@ export PLUGIN_SCHEME="mongodb"
 export PLUGIN_SERVICE="MongoDB"
 export PLUGIN_VARIABLE="MONGO"
 export PLUGIN_BASE_PATH="$PLUGIN_PATH"
+export PLUGIN_CONFIG_SUFFIX="config"
 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"

 export MONGO_CONFIG_OPTIONS=${MONGO_CONFIG_OPTIONS:=" --storageEngine wiredTiger --auth "}
--- a/80
+++ b/80
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/common-functions"
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$PLUGIN_AVAILABLE_PATH/config/functions"
@@ -12,11 +13,12 @@ service_connect() {
  local SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  local DATABASE_NAME="$(get_database_name "$SERVICE")"
+  local PASSWORD="$(service_password "$SERVICE")"
  local SERVICE_TTY_OPTS
  has_tty && SERVICE_TTY_OPTS="-t"

-  docker exec -i $SERVICE_TTY_OPTS "$SERVICE_NAME" mongo -u "$SERVICE" -p "$PASSWORD" --authenticationDatabase "$SERVICE" "$SERVICE"
+  docker exec -i $SERVICE_TTY_OPTS "$SERVICE_NAME" mongo -u "$SERVICE" -p "$PASSWORD" --authenticationDatabase "$DATABASE_NAME" "$DATABASE_NAME"
 }

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

  service_parse_args "${@:2}"

@@ -38,9 +41,10 @@ service_create() {
    docker pull "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" || dokku_log_fail "$PLUGIN_SERVICE image $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION pull failed"
  fi

+  plugn trigger service-action pre-create "$SERVICE"
  mkdir -p "$SERVICE_ROOT" || dokku_log_fail "Unable to create service directory"
  mkdir -p "$SERVICE_ROOT/data" || dokku_log_fail "Unable to create service data directory"
-  mkdir -p "$SERVICE_ROOT/config" || dokku_log_fail "Unable to create service config directory"
+  mkdir -p "$SERVICE_ROOT/$PLUGIN_CONFIG_SUFFIX" || dokku_log_fail "Unable to create service config directory"
  touch "$LINKS_FILE"

  ROOTPASSWORD=$(openssl rand -hex 16)
@@ -53,25 +57,28 @@ service_create() {
    ROOTPASSWORD="$SERVICE_ROOT_PASSWORD"
    dokku_log_warn "Specified root password may not be as secure as the auto-generated root password"
  fi
-  echo "$ROOTPASSWORD" > "$SERVICE_ROOT/ROOTPASSWORD"
-  echo "$PASSWORD" > "$SERVICE_ROOT/PASSWORD"
+  echo "$ROOTPASSWORD" >"$SERVICE_ROOT/ROOTPASSWORD"
+  echo "$PASSWORD" >"$SERVICE_ROOT/PASSWORD"
  chmod 640 "$SERVICE_ROOT/ROOTPASSWORD" "$SERVICE_ROOT/PASSWORD"

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

  [[ -n "$PLUGIN_CONFIG_OPTIONS" ]] && MONGO_CONFIG_OPTIONS="$PLUGIN_CONFIG_OPTIONS"
  if [[ -n "$MONGO_CONFIG_OPTIONS" ]]; then
-    echo "$MONGO_CONFIG_OPTIONS" > "$SERVICE_ROOT/MONGO_CONFIG_OPTIONS"
+    echo "$MONGO_CONFIG_OPTIONS" >"$SERVICE_ROOT/MONGO_CONFIG_OPTIONS"
  else
-    echo "" > "$SERVICE_ROOT/MONGO_CONFIG_OPTIONS"
+    echo "" >"$SERVICE_ROOT/MONGO_CONFIG_OPTIONS"
  fi

+  write_database_name "$SERVICE"
+  plugn trigger service-action post-create "$SERVICE"
  service_create_container "$SERVICE"
+  plugn trigger service-action post-create-complete "$SERVICE"
 }

 service_create_container() {
@@ -79,22 +86,23 @@ service_create_container() {
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_HOST_ROOT="$PLUGIN_DATA_HOST_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  local ROOTPASSWORD="$(cat "$SERVICE_ROOT/ROOTPASSWORD")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  local ROOTPASSWORD="$(service_root_password "$SERVICE")"
+  local PASSWORD="$(service_password "$SERVICE")"
+  local DATABASE_NAME="$(get_database_name "$SERVICE")"

  if [[ -f "$SERVICE_ROOT/MONGO_CONFIG_OPTIONS" ]]; then
    export MONGO_CONFIG_OPTIONS="$(cat "$SERVICE_ROOT/MONGO_CONFIG_OPTIONS")"
  fi

  # shellcheck disable=SC2086
-  ID=$(docker run --name "$SERVICE_NAME" -v "$SERVICE_HOST_ROOT/data:/data/db" --env-file="$SERVICE_ROOT/ENV" -d --restart always --label dokku=service --label dokku.service=mongo "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" mongod $MONGO_CONFIG_OPTIONS)
-  echo "$ID" > "$SERVICE_ROOT/ID"
+  ID=$(docker run --name "$SERVICE_NAME" -v "$SERVICE_HOST_ROOT/data:/data/db" --env-file="$SERVICE_ROOT/ENV" --env "MONGO_INITDB_DATABASE=$DATABASE_NAME" -d --restart always --label dokku=service --label dokku.service=mongo "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" mongod $MONGO_CONFIG_OPTIONS)
+  echo "$ID" >"$SERVICE_ROOT/ID"

  dokku_log_verbose_quiet "Waiting for container to be ready"
-  docker run --rm --link "$SERVICE_NAME:$PLUGIN_COMMAND_PREFIX" dokkupaas/wait:0.2 -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

-  echo "db.createUser({user:'admin',pwd:'$ROOTPASSWORD',roles:[{role:'userAdminAnyDatabase',db:'admin'},{role:'__system',db:'admin'},{role:'root',db:'admin'}]})" | docker exec -i "$SERVICE_NAME" mongo admin > /dev/null
-  echo "db.createUser({user:'$SERVICE',pwd:'$PASSWORD',roles:[{role:'readWrite',db:'$SERVICE'}]})" | docker exec -i "$SERVICE_NAME" mongo -u admin -p "$ROOTPASSWORD" --authenticationDatabase admin "$SERVICE" > /dev/null
+  echo "db.createUser({user:'admin',pwd:'$ROOTPASSWORD',roles:[{role:'userAdminAnyDatabase',db:'admin'},{role:'__system',db:'admin'},{role:'root',db:'admin'}]})" | docker exec -i "$SERVICE_NAME" mongo admin >/dev/null
+  echo "db.createUser({user:'$SERVICE',pwd:'$PASSWORD',roles:[{role:'readWrite',db:'$DATABASE_NAME'}]})" | docker exec -i "$SERVICE_NAME" mongo -u admin -p "$ROOTPASSWORD" --authenticationDatabase admin "$DATABASE_NAME" >/dev/null
  dokku_log_info2 "$PLUGIN_SERVICE container created: $SERVICE"
  service_info "$SERVICE"
 }
@@ -103,10 +111,11 @@ service_export() {
  local SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  local DATABASE_NAME="$(get_database_name "$SERVICE")"
+  local PASSWORD="$(service_password "$SERVICE")"

  [[ -n $SSH_TTY ]] && stty -opost
-  docker exec "$SERVICE_NAME" bash -c "mongodump -d $SERVICE -u \"$SERVICE\" -p \"$PASSWORD\" --authenticationDatabase \"$SERVICE\" --quiet --gzip --archive 2>/dev/null"
+  docker exec "$SERVICE_NAME" bash -c "mongodump -d $DATABASE_NAME -u \"$SERVICE\" -p \"$PASSWORD\" --authenticationDatabase \"$DATABASE_NAME\" --quiet --gzip --archive 2>/dev/null"
  status=$?
  [[ -n $SSH_TTY ]] && stty opost
  exit $status
@@ -117,12 +126,13 @@ service_import() {
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_HOST_ROOT="$PLUGIN_DATA_HOST_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  local DATABASE_NAME="$(get_database_name "$SERVICE")"
+  local PASSWORD="$(service_password "$SERVICE")"

  if [[ -t 0 ]]; then
    dokku_log_fail "No data provided on stdin."
  fi
-  docker exec -i "$SERVICE_NAME" bash -c "mongorestore -u \"$SERVICE\" -p \"$PASSWORD\" --authenticationDatabase \"$SERVICE\" --gzip --archive --nsFrom '\$db\$.\$coll\$' --nsTo '$SERVICE.\$coll\$'"
+  docker exec -i "$SERVICE_NAME" bash -c "mongorestore -u \"$SERVICE\" -p \"$PASSWORD\" --authenticationDatabase \"$DATABASE_NAME\" --gzip --archive --nsFrom '\$db\$.\$coll\$' --nsTo '$DATABASE_NAME.\$coll\$'"
 }

 service_start() {
@@ -130,32 +140,40 @@ service_start() {
  local QUIET="$2"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  local ID=$(docker ps -f status=running --no-trunc | grep -e "$SERVICE_NAME$" | awk '{print $1}') || true
+  local ID=$(docker ps -aq --no-trunc --filter "status=running" --filter "name=^/$SERVICE_NAME$" --format '{{ .ID }}') || true
  if [[ -n $ID ]]; then
    [[ -z $QUIET ]] && dokku_log_warn "Service is already started"
+    if [[ ! -f "$SERVICE_ROOT/ID" ]] || [[ "$(cat "$SERVICE_ROOT/ID")" != "$ID" ]]; then
+      [[ -z $QUIET ]] && dokku_log_warn "Updating local container ID"
+      echo "$ID" >"$SERVICE_ROOT/ID"
+    fi
    return 0
  fi

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

  if [[ -n $PREVIOUS_ID ]]; then
-    docker start "$PREVIOUS_ID" > /dev/null
+    docker start "$PREVIOUS_ID" >/dev/null
    service_port_unpause "$SERVICE"
    dokku_log_info2 "Container started"
  elif service_image_exists "$SERVICE" && [[ -n "$ROOTPASSWORD" ]] && [[ -n "$PASSWORD" ]]; then
    service_create_container "$SERVICE"
  else
-    dokku_log_verbose_quiet "Neither container nor valid configuration exists for $SERVICE"
+    if ! service_image_exists "$SERVICE"; then
+      dokku_log_verbose_quiet "Missing image $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION for $SERVICE"
+    else
+      dokku_log_verbose_quiet "Neither container nor valid configuration exists for $SERVICE"
+    fi
  fi
 }

 service_url() {
  local SERVICE="$1"
-  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
  local SERVICE_DNS_HOSTNAME="$(service_dns_hostname "$SERVICE")"
-  echo "$PLUGIN_SCHEME://$SERVICE:$PASSWORD@$SERVICE_DNS_HOSTNAME:${PLUGIN_DATASTORE_PORTS[0]}/$SERVICE"
+  local DATABASE_NAME="$(get_database_name "$SERVICE")"
+  local PASSWORD="$(service_password "$SERVICE")"
+  echo "$PLUGIN_SCHEME://$SERVICE:$PASSWORD@$SERVICE_DNS_HOSTNAME:${PLUGIN_DATASTORE_PORTS[0]}/$DATABASE_NAME"
 }
--- a/39
+++ b/39
@@ -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
@@ -75,13 +76,13 @@ fn-help-contents() {

 fn-help-contents-subcommand() {
  declare SUBCOMMAND="$1" FULL_OUTPUT="$2"
-  local TMPDIR=$(mktemp -d)
-  local UNCLEAN_FILE="${TMPDIR}/cmd-unclean" CLEAN_FILE="${TMPDIR}/cmd-clean"
+  local HELP_TMPDIR=$(mktemp -d --tmpdir)
+  local UNCLEAN_FILE="${HELP_TMPDIR}/cmd-unclean" CLEAN_FILE="${HELP_TMPDIR}/cmd-clean"
  local BOLD CMD_OUTPUT CYAN EXAMPLE LIGHT_GRAY NORMAL
-  trap 'rm -rf "$TMPDIR" > /dev/null' RETURN INT TERM EXIT
+  trap 'rm -rf "$HELP_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,9 +163,9 @@ fn-help-fancy-color() {
 fn-help-list-example() {
  # shellcheck disable=SC2034
  declare desc="return $PLUGIN_COMMAND_PREFIX plugin help content"
-  cat<<help_list
-      NAME, VERSION, STATUS, EXPOSED PORTS, LINKS
-      service-name, $PLUGIN_COMMAND_PREFIX:$PLUGIN_IMAGE_VERSION, running, -, app-name
+  cat <<help_list
+      $PLUGIN_SERVICE services
+      service-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 "svendowideit/ambassador:latest"
-  pull-docker-image "dokkupaas/wait:0.2"
-  pull-docker-image "dokkupaas/s3backup:0.8.0"
-  pull-docker-image "busybox:latest"
+  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 mongo service plugin"
-version = "1.5.0"
+version = "1.13.0"
 [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,16 +1,18 @@
 #!/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"

 service-backup-set-encryption-cmd() {
-  #E set a GPG passphrase for backups
+  #E set the GPG-compatible passphrase for encrypting backups for backups
  #E dokku $PLUGIN_COMMAND_PREFIX:backup-set-encryption lolipop
  #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,15 +1,17 @@
 #!/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"

 service-backup-unset-encryption-cmd() {
-  #E unset a GPG encryption key for backups
+  #E unset the GPG encryption passphrase for backups
  #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/connect-admin
+++ b/subcommands/connect-admin
@@ -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,14 +10,15 @@ service-connect-admin-cmd() {
  #E dokku $PLUGIN_COMMAND_PREFIX:connect-admin lolipop
  #A service, service to run command against
  declare desc="connect via mongo to a $PLUGIN_SERVICE service as admin user"
-  local cmd="$PLUGIN_COMMAND_PREFIX:connect-admin" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:connect-admin" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1"

  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
  verify_service_name "$SERVICE"
  SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  SERVICE_NAME="$(get_service_name "$SERVICE")"
-  PASSWORD="$(cat "$SERVICE_ROOT/ROOTPASSWORD")"
+  PASSWORD="$(service_root_password "$SERVICE")"
  has_tty && SERVICE_TTY_OPTS="-t"

  docker exec -i $SERVICE_TTY_OPTS "$SERVICE_NAME" mongo -u admin -p "$PASSWORD" --authenticationDatabase admin "$SERVICE"
--- 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")"

@@ -38,13 +41,15 @@ service-destroy-cmd() {
  fi

  dokku_log_info2_quiet "Deleting $SERVICE"
+  plugn trigger service-action pre-delete "$SERVICE"
  service_backup_unschedule "$SERVICE"
  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 chmod 777 -R /config /data
+  docker run --rm -v "$SERVICE_HOST_ROOT/data:/data" -v "$SERVICE_HOST_ROOT/$PLUGIN_CONFIG_SUFFIX:/config" "$PLUGIN_BUSYBOX_IMAGE" chmod 777 -R /config /data
  rm -rf "$SERVICE_ROOT"

+  plugn trigger service-action post-delete "$SERVICE"
  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"

@@ -29,10 +30,10 @@ service-link-cmd() {
  #E use the 'expose' subcommand. another service can be linked to your app:
  #E dokku $PLUGIN_COMMAND_PREFIX:link other_service playground
  #E it is possible to change the protocol for ${PLUGIN_DEFAULT_ALIAS}_URL by setting the
-  #E environment variable ${PLUGIN_DEFAULT_ALIAS}_DATABASE_SCHEME on the app. doing so will
+  #E environment variable ${PLUGIN_VARIABLE}_DATABASE_SCHEME on the app. doing so will
  #E after linking will cause the plugin to think the service is not
  #E linked, and we advise you to unlink before proceeding.
-  #E dokku config:set playground ${PLUGIN_DEFAULT_ALIAS}_DATABASE_SCHEME=${PLUGIN_SCHEME}2
+  #E dokku config:set playground ${PLUGIN_VARIABLE}_DATABASE_SCHEME=${PLUGIN_SCHEME}2
  #E dokku $PLUGIN_COMMAND_PREFIX:link lolipop playground
  #E this will cause ${PLUGIN_DEFAULT_ALIAS}_URL to be set as:
  #E
@@ -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/hook_pre_delete.bats
+++ b/tests/hook_pre_delete.bats
@@ -2,18 +2,18 @@
 load test_helper

 setup() {
-  dokku apps:create my_app
+  dokku apps:create my-app
  dokku "$PLUGIN_COMMAND_PREFIX:create" l
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app >&2
 }

 teardown() {
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app >&2
  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }

@test "($PLUGIN_COMMAND_PREFIX:hook:pre-delete) removes app from links file when destroying app" {
  [[ -n $(< "$PLUGIN_DATA_ROOT/l/LINKS") ]]
-  dokku --force apps:destroy my_app
+  dokku --force apps:destroy my-app
  [[ -z $(< "$PLUGIN_DATA_ROOT/l/LINKS") ]]
 }
--- a/tests/service_create.bats
+++ b/tests/service_create.bats
@@ -7,6 +7,15 @@ load test_helper
  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }

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

@test "($PLUGIN_COMMAND_PREFIX:export) success with SSH_TTY" {
+  if [[ -n "$GITHUB_WORKFLOW" ]]; then
+    skip "No tty is available on Github Actions"
+  fi
  export SSH_TTY=`tty`
  run dokku "$PLUGIN_COMMAND_PREFIX:export" l
  echo "output: $output"
--- a/tests/service_import.bats
+++ b/tests/service_import.bats
@@ -24,6 +24,9 @@ teardown() {
 }

@test "($PLUGIN_COMMAND_PREFIX:import) error when data is not provided" {
+  if [[ -n "$GITHUB_WORKFLOW" ]]; then
+    skip "No tty is available on Github Actions"
+  fi
  run dokku "$PLUGIN_COMMAND_PREFIX:import" l
  assert_contains "${lines[*]}" "No data provided on stdin"
  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 apps:create my_app
+  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
+  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"
@@ -36,7 +39,7 @@ teardown() {
 }

@test "($PLUGIN_COMMAND_PREFIX:link) error when the service does not exist" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:link" not_existing_service my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" not_existing_service my-app
  echo "output: $output"
  echo "status: $status"
  assert_contains "${lines[*]}" "service not_existing_service does not exist"
@@ -44,67 +47,73 @@ teardown() {
 }

@test "($PLUGIN_COMMAND_PREFIX:link) error when the service is already linked to app" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  run dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app
  echo "output: $output"
  echo "status: $status"
  assert_contains "${lines[*]}" "Already linked as MONGO_URL"
  assert_failure

-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
 }

@test "($PLUGIN_COMMAND_PREFIX:link) exports MONGO_URL to app" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app
  echo "output: $output"
  echo "status: $status"
-  url=$(dokku config:get my_app MONGO_URL)
+  url=$(dokku config:get my-app MONGO_URL)
  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
  assert_contains "$url" "mongodb://l:$password@dokku-mongo-l:27017/l"
  assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
 }

@test "($PLUGIN_COMMAND_PREFIX:link) generates an alternate config url when MONGO_URL already in use" {
-  dokku config:set my_app MONGO_URL=mongodb://user:pass@host:27017/db
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  run dokku config my_app
-  assert_contains "${lines[*]}" "DOKKU_MONGO_"
+  dokku config:set my-app MONGO_URL=mongodb://user:pass@host:27017/db
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app
+  run dokku config my-app
+  assert_contains "${lines[*]}" "DOKKU_MONGO_AQUA_URL"
  assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+
+  dokku "$PLUGIN_COMMAND_PREFIX:link" m my-app
+  run dokku config my-app
+  assert_contains "${lines[*]}" "DOKKU_MONGO_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
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app
+  run dokku docker-options:report my-app
  assert_contains "${lines[*]}" "--link dokku.mongo.l:dokku-mongo-l"
  assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
 }

@test "($PLUGIN_COMMAND_PREFIX:link) uses apps MONGO_DATABASE_SCHEME variable" {
-  dokku config:set my_app MONGO_DATABASE_SCHEME=mongodb2
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  url=$(dokku config:get my_app MONGO_URL)
+  dokku config:set my-app MONGO_DATABASE_SCHEME=mongodb2
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app
+  url=$(dokku config:get my-app MONGO_URL)
  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
  assert_contains "$url" "mongodb2://l:$password@dokku-mongo-l:27017/l"
  assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
 }

@test "($PLUGIN_COMMAND_PREFIX:link) adds a querystring" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app --querystring "pool=5"
-  url=$(dokku config:get my_app MONGO_URL)
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app --querystring "pool=5"
+  url=$(dokku config:get my-app MONGO_URL)
  assert_contains "$url" "?pool=5"
  assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
 }

@test "($PLUGIN_COMMAND_PREFIX:link) uses a specified config url when alias is specified" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app --alias "ALIAS"
-  url=$(dokku config:get my_app ALIAS_URL)
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app --alias "ALIAS"
+  url=$(dokku config:get my-app ALIAS_URL)
  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
  assert_contains "$url" "mongodb://l:$password@dokku-mongo-l:27017/l"
  assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  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     mongo:3.4.9  running  -              -"
-}
-
-@test "($PLUGIN_COMMAND_PREFIX:list) with exposed ports" {
-  dokku "$PLUGIN_COMMAND_PREFIX:expose" l 4242 4243 4244 4245
-  run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "l     mongo:3.4.9  running  27017->4242 27018->4243 27019->4244 28017->4245   -"
-}
-
-@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     mongo:3.4.9  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 MongoDB services"
+  assert_output "${lines[*]}" "There are no $PLUGIN_SERVICE services"
  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
--- a/tests/service_promote.bats
+++ b/tests/service_promote.bats
@@ -3,14 +3,14 @@ load test_helper

 setup() {
  dokku "$PLUGIN_COMMAND_PREFIX:create" l
-  dokku apps:create my_app
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
+  dokku apps:create my-app
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app
 }

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

@test "($PLUGIN_COMMAND_PREFIX:promote) error when there are no arguments" {
@@ -29,34 +29,34 @@ teardown() {
 }

@test "($PLUGIN_COMMAND_PREFIX:promote) error when the service does not exist" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:promote" not_existing_service my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:promote" not_existing_service my-app
  assert_contains "${lines[*]}" "service not_existing_service does not exist"
 }

@test "($PLUGIN_COMMAND_PREFIX:promote) error when the service is already promoted" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:promote" l my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:promote" l my-app
  assert_contains "${lines[*]}" "already promoted as MONGO_URL"
 }

@test "($PLUGIN_COMMAND_PREFIX:promote) changes MONGO_URL" {
  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  dokku config:set my_app "MONGO_URL=mongodb://u:p@host:27017/db" "DOKKU_MONGO_BLUE_URL=mongodb://l:$password@dokku-mongo-l:27017/l"
-  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my_app
-  url=$(dokku config:get my_app MONGO_URL)
+  dokku config:set my-app "MONGO_URL=mongodb://u:p@host:27017/db" "DOKKU_MONGO_BLUE_URL=mongodb://l:$password@dokku-mongo-l:27017/l"
+  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my-app
+  url=$(dokku config:get my-app MONGO_URL)
  assert_equal "$url" "mongodb://l:$password@dokku-mongo-l:27017/l"
 }

@test "($PLUGIN_COMMAND_PREFIX:promote) creates new config url when needed" {
  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  dokku config:set my_app "MONGO_URL=mongodb://u:p@host:27017/db" "DOKKU_MONGO_BLUE_URL=mongodb://l:$password@dokku-mongo-l:27017/l"
-  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my_app
-  run dokku config my_app
+  dokku config:set my-app "MONGO_URL=mongodb://u:p@host:27017/db" "DOKKU_MONGO_BLUE_URL=mongodb://l:$password@dokku-mongo-l:27017/l"
+  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my-app
+  run dokku config my-app
  assert_contains "${lines[*]}" "DOKKU_MONGO_"
 }
@test "($PLUGIN_COMMAND_PREFIX:promote) uses MONGO_DATABASE_SCHEME variable" {
  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  dokku config:set my_app "MONGO_DATABASE_SCHEME=mongodb2" "MONGO_URL=mongodb://u:p@host:27017/db" "DOKKU_MONGO_BLUE_URL=mongodb2://l:$password@dokku-mongo-l:27017/l"
-  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my_app
-  url=$(dokku config:get my_app MONGO_URL)
+  dokku config:set my-app "MONGO_DATABASE_SCHEME=mongodb2" "MONGO_URL=mongodb://u:p@host:27017/db" "DOKKU_MONGO_BLUE_URL=mongodb2://l:$password@dokku-mongo-l:27017/l"
+  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my-app
+  url=$(dokku config:get my-app MONGO_URL)
  assert_contains "$url" "mongodb2://l:$password@dokku-mongo-l:27017/l"
 }
--- a/tests/service_unlink.bats
+++ b/tests/service_unlink.bats
@@ -2,13 +2,13 @@
 load test_helper

 setup() {
-  dokku apps:create my_app
+  dokku apps:create my-app
  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }

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

@test "($PLUGIN_COMMAND_PREFIX:unlink) error when there are no arguments" {
@@ -27,27 +27,27 @@ teardown() {
 }

@test "($PLUGIN_COMMAND_PREFIX:unlink) error when the service does not exist" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" not_existing_service my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" not_existing_service my-app
  assert_contains "${lines[*]}" "service not_existing_service does not exist"
 }

@test "($PLUGIN_COMMAND_PREFIX:unlink) error when service not linked to app" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
-  assert_contains "${lines[*]}" "Not linked to app my_app"
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
+  assert_contains "${lines[*]}" "Not linked to app my-app"
 }

@test "($PLUGIN_COMMAND_PREFIX:unlink) removes link from docker-options" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app >&2
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app

  check_value="Docker options build: Docker options deploy: --restart=on-failure:10 Docker options run:"
-  options=$(dokku --quiet docker-options:report my_app | xargs)
+  options=$(dokku --quiet docker-options:report my-app | xargs)
  assert_equal "$options" "$check_value"
 }

@test "($PLUGIN_COMMAND_PREFIX:unlink) unsets config url from app" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app >&2
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
-  config=$(dokku config:get my_app MONGO_URL || true)
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
+  config=$(dokku config:get my-app MONGO_URL || true)
  assert_equal "$config" ""
 }
--- 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
@@ -10,11 +19,15 @@ echo "Dokku version $DOKKU_VERSION"

 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"
+pushd "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")" >/dev/null
+source "config"
+popd >/dev/null
 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" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/templates"
 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" \;
+[[ -d "./templates" ]] && sudo find ./templates -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/templates" \;
 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	563e4a2ee6	Release 1.13.0	2021-09-12 04:43:02 -04:00
Jose Diaz-Gonzalez	7b22b310df	dev: add convenience copy-file bin and fix data path used by plugin	2021-09-12 03:28:55 -04:00
Jose Diaz-Gonzalez	66996bced9	dev: make devcontainer setup plugin agnostic	2021-09-12 02:39:17 -04:00
Jose Diaz-Gonzalez	ffddb96ec4	chore: show a better error message when the image is missing Refs dokku/dokku-clickhouse#4	2021-09-12 00:54:23 -04:00
Jose Diaz-Gonzalez	e9891556d9	dev: mount the service directory from the host to ensure tests can pass inside of a docker container	2021-09-12 00:53:12 -04:00
Jose Diaz-Gonzalez	7a0b20aed6	fix: copy any existing templates and drop unnecessary interactivity	2021-09-12 00:40:12 -04:00
Jose Diaz-Gonzalez	cdfe98a4e1	fix: use correct path	2021-09-11 23:45:00 -04:00
Jose Diaz-Gonzalez	cfeff3e168	fix: copy templates if they exist	2021-09-11 23:18:28 -04:00
Jose Diaz-Gonzalez	b9e339f1d0	feat: add devcontainer support This should make it possible to run tests locally in a lighter way than pulling up a full VM.	2021-09-11 21:06:06 -04:00
Jose Diaz-Gonzalez	9da6fd80f7	docs: regenerate readme	2021-09-11 18:16:56 -04:00
Jose Diaz-Gonzalez	9de844b8eb	Merge pull request #140 from dokku/dependabot/docker/mongo-5.0.2 chore(deps): bump mongo from 3.6.15 to 5.0.2	2021-09-11 18:11:05 -04:00
Jose Diaz-Gonzalez	4d0f09ff6b	chore: drop references to circleci, libera, travis-ci	2021-09-11 17:57:20 -04:00
dependabot[bot]	8bac5ad244	chore(deps): bump mongo from 3.6.15 to 5.0.2 Bumps mongo from 3.6.15 to 5.0.2. --- updated-dependencies: - dependency-name: mongo dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com>	2021-08-06 13:07:05 +00:00
Jose Diaz-Gonzalez	4cbcefdb0f	tests: refactor tests to ignore readme generation for Dockerfile changes Ideally we can trigger a readme update on merge in the future. For now, this will work well.	2021-04-26 11:43:13 -04:00
Jose Diaz-Gonzalez	ddf4d4d58c	chore: gitignore bootstrap file and minor cleanup of ci	2021-04-25 02:54:07 -04:00
Jose Diaz-Gonzalez	de11d2f9b1	Merge pull request #135 from dokku/github-actions-attempt tests: migrate to github actions	2021-04-25 01:04:23 -04:00
Jose Diaz-Gonzalez	fefed14b39	tests: skip tests that require tty for github actions	2021-04-25 00:35:42 -04:00
Jose Diaz-Gonzalez	de492a3aa1	docs: regenerate readme	2021-04-24 14:09:33 -04:00
Jose Diaz-Gonzalez	8cb329581f	tests: drop copying of test results Bats will now output the results on stdout so no need to copy results anywhere.	2021-04-24 14:05:47 -04:00
Jose Diaz-Gonzalez	23cf608add	tests: fix job name	2021-04-24 14:04:39 -04:00
Jose Diaz-Gonzalez	0bedfa6dde	tests: split tests to version and tag	2021-04-24 14:03:01 -04:00
Jose Diaz-Gonzalez	f6be651ab1	chore: update min dokku version and only test push on master branch	2021-04-24 13:57:18 -04:00
Jose Diaz-Gonzalez	b0bd29f770	tests: migrate to github actions	2021-04-24 02:20:30 -04:00
Jose Diaz-Gonzalez	0d23b71c28	Release 1.12.0	2021-04-24 00:32:06 -04:00
Jose Diaz-Gonzalez	eeecc9127c	feat: add dependabot config to all repositories	2021-04-24 00:10:33 -04:00
Jose Diaz-Gonzalez	a72a118e71	Merge pull request #133 from dokku/dockerfile-update Pull image from Dockerfile	2021-04-23 23:55:26 -04:00
Jose Diaz-Gonzalez	4d6972fd4b	tests: refactor source again	2021-02-26 00:45:09 -05:00
Jose Diaz-Gonzalez	6822c923a0	tests: fix path to Dockerfile when sourcing config for tests	2021-02-26 00:27:52 -05:00
Jose Diaz-Gonzalez	7c63d5c04d	docs: handle image and version correctly	2021-02-26 00:11:16 -05:00
Jose Diaz-Gonzalez	aa2b3c8b86	refactor: move base image reference to Dockerfile This will allow us to take advantage of automatic update software to auto-pull new versions when they are released to docker hub.	2021-02-25 23:16:23 -05:00
Jose Diaz-Gonzalez	b97b7ce2e6	tests: use dash instead of underscore	2021-02-25 20:32:57 -05:00
Jose Diaz-Gonzalez	483e6c54cc	feat: add plugin trigger for service creation and deletion	2021-02-25 19:54:59 -05:00
Jose Diaz-Gonzalez	476ccb73e1	refactor: use pre/post triggers for service-action naming This is a bit more clear as the links aren't always idempotent and may have errors - this allows users to reconcile at what point a link may have failed so that they can take further action.	2021-02-25 16:05:24 -05:00
Jose Diaz-Gonzalez	6ca823d417	feat: add service-action plugin trigger for link/unlink This can be used to track in alternate systems when a service is linked/unlinked from an app by implementing the custom trigger.	2021-02-25 15:58:31 -05:00
Jose Diaz-Gonzalez	114fc89ec3	Release 1.11.6	2021-01-17 21:16:10 -05:00
Jose Diaz-Gonzalez	7f4a5d2b09	fix: do not shadow TMPDIR variable This enables usage of the plugin with libpam-tmpdir. Refs dokku/dokku#3149	2021-01-17 21:02:28 -05:00
Jose Diaz-Gonzalez	224173e5dc	fix: correct image link	2020-09-27 12:38:50 -04:00
Jose Diaz-Gonzalez	51efb0150b	Merge pull request #129 from dokku/configurable-config fix: allow config directory to be configurable	2020-05-16 04:52:36 -04:00
Jose Diaz-Gonzalez	31ade32c05	fix: allow config directory to be configurable For postgres, the config directory doesn't actually exist, so adding this configurability allows the plugin's info command to report correctly.	2020-05-16 02:49:34 -04:00
Jose Diaz-Gonzalez	f6523d1917	Release 1.11.5	2020-05-15 00:58:33 -04:00
Jose Diaz-Gonzalez	7b3b134b49	fix: respect the TMPDIR environment variable Refs dokku/dokku-redis#143	2020-05-15 00:57:21 -04:00
Jose Diaz-Gonzalez	dc3ae48aed	Release 1.11.4	2020-05-15 00:53:14 -04:00
Jose Diaz-Gonzalez	f62d233fdd	docs: correct help output Refs dokku/dokku-postgres#197	2020-05-15 00:40:24 -04:00
Jose Diaz-Gonzalez	956bc4aafa	docs: correct casing/quoting on sentences	2020-05-15 00:34:37 -04:00
Jose Diaz-Gonzalez	dd83b621f2	chore: run black	2020-05-14 23:57:49 -04:00
Jose Diaz-Gonzalez	d0060ad532	docs: document all flags in readme	2020-05-14 23:37:57 -04:00
Jose Diaz-Gonzalez	19b4960ea2	docs: make the gpg passphrase a bit more clear	2020-05-14 23:33:01 -04:00
Jose Diaz-Gonzalez	2cd56cdf4b	Release 1.11.3	2020-05-14 22:59:30 -04:00
Jose Diaz-Gonzalez	6285aa7d68	chore: update copyright date	2020-05-14 22:57:38 -04:00
Jose Diaz-Gonzalez	b11dea9734	docs: switch build shield to circleci	2020-04-05 20:41:00 -04:00
Jose Diaz-Gonzalez	78da679ea6	tests: use circleci 2.1	2020-04-05 20:40:20 -04:00
Jose Diaz-Gonzalez	4db7db89be	Release 1.11.2	2020-04-04 22:27:43 -04:00
Jose Diaz-Gonzalez	6479bb4d30	fix: store the correct path	2020-04-04 22:25:11 -04:00
Jose Diaz-Gonzalez	a9fabcb0dd	Release 1.11.1	2020-04-04 21:50:26 -04:00
Jose Diaz-Gonzalez	de80e058bf	tests: drop travisci usage	2020-04-04 21:43:59 -04:00
Jose Diaz-Gonzalez	a7a226318c	tests: store test results for usage in circleci	2020-04-04 21:41:43 -04:00
Jose Diaz-Gonzalez	06ab80ae76	feat: enable circleci	2020-04-04 21:27:53 -04:00
Jose Diaz-Gonzalez	b3f28d3496	feat: speed up tests by dropping dhparam generation	2020-04-04 21:27:43 -04:00
Jose Diaz-Gonzalez	15fc2cbc0f	fix: use python3 for generating the readme	2020-04-04 16:47:36 -04:00
Jose Diaz-Gonzalez	76054a308f	docs: drop unimpemented commands from readme and reorganize	2020-04-04 16:43:31 -04:00
Jose Diaz-Gonzalez	ddf0662068	feat: autogenerate readme from command help	2020-04-04 16:20:35 -04:00
Jose Diaz-Gonzalez	af649d8085	fix: correct issue where help output for info flag implied multiple flags	2020-04-04 16:18:22 -04:00
Jose Diaz-Gonzalez	56832abe7d	feat: update shellcheck excludes	2020-04-04 13:38:33 -04:00
Jose Diaz-Gonzalez	140185ae06	feat: add xunit-reader to output xunit files in human readable format	2020-04-04 13:37:50 -04:00
Jose Diaz-Gonzalez	9a23c62941	feat: parameterize xunit-to-github version	2020-04-04 13:37:03 -04:00
Jose Diaz-Gonzalez	75dc0c925d	fix: use non-deprecated method of fetching docker-options	2020-04-04 13:36:27 -04:00
Jose Diaz-Gonzalez	5ad3a5604b	feat: upgrade shfmt	2020-04-04 13:35:52 -04:00
Jose Diaz-Gonzalez	919e8644c8	Release 1.11.0	2020-03-31 01:35:25 -04:00
Jose Diaz-Gonzalez	22dd667b2c	feat: upgrade tertiary container images	2020-03-30 20:12:18 -04:00
Jose Diaz-Gonzalez	61664799dd	feat: move all image names to config file This allows us to more quickly update the image versions in use for tertiary images.	2020-03-30 20:09:03 -04:00
Jose Diaz-Gonzalez	0b6a76d6e4	feat: add service-specific header to info call	2020-03-20 15:59:03 -04:00
Jose Diaz-Gonzalez	5156079c19	fix: correct test case for :list command	2020-03-20 14:58:06 -04:00
Jose Diaz-Gonzalez	432894e297	fix: ignore the keyfile install for tests	2020-03-20 11:14:27 -04:00
Jose Diaz-Gonzalez	a99902a39e	fix: correct shellcheck issue	2020-03-20 11:05:44 -04:00
Jose Diaz-Gonzalez	48a9828f39	feat: update travis setup - Use ubuntu bionic - Upgrade tested version of dokku	2020-03-20 10:58:25 -04:00
Jose Diaz-Gonzalez	90698a2e9d	Release 1.10.1	2020-03-06 10:20:10 -05:00
Jose Diaz-Gonzalez	b76659d914	fix: correct service title	2020-03-06 10:19:43 -05:00
Jose Diaz-Gonzalez	ac4010f12b	Release 1.10.0	2020-03-03 16:05:13 -05:00
Jose Diaz-Gonzalez	259316d664	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	9a420cc991	fix: speed up service_status by reducing container status calls	2020-03-03 15:57:20 -05:00
Jose Diaz-Gonzalez	2da57f1336	Release 1.9.5	2019-12-27 16:57:39 -05:00
Jose Diaz-Gonzalez	f5e0d87501	chore: update dokku/wait version	2019-12-27 16:57:13 -05:00
Jose Diaz-Gonzalez	2a14c2e914	Release 1.9.4	2019-12-27 16:56:00 -05:00
Jose Diaz-Gonzalez	66dda254bf	chore: update dokku/ambassador version	2019-12-27 16:55:25 -05:00
Jose Diaz-Gonzalez	6d3cf7a0e5	Release 1.9.3	2019-12-27 16:54:05 -05:00
Jose Diaz-Gonzalez	2992132100	chore: update dokku/s3backup version	2019-12-27 16:53:23 -05:00
Jose Diaz-Gonzalez	f218908750	Release 1.9.2	2019-11-22 19:20:05 -05:00
Jose Diaz-Gonzalez	fdd9ec0ee4	feat: update patch release of mongo	2019-11-22 19:20:04 -05:00
Jose Diaz-Gonzalez	28ade2e348	Release 1.9.1	2019-09-19 15:17:30 -04:00
Jose Diaz-Gonzalez	9aa09b3a3f	fix: install updated gpg key and nginx apt repository	2019-09-19 13:30:46 -04:00
Jose Diaz-Gonzalez	07c47e10d3	fix: add missing ampersands	2019-07-30 10:51:51 -04:00
Jose Diaz-Gonzalez	bd809017f2	chore: create scripts directory as necessary	2019-07-30 10:46:00 -04:00
Jose Diaz-Gonzalez	1b1c409369	feat: skip subcommand copy if no subcommands directory exists	2019-07-29 22:03:01 -04:00
Jose Diaz-Gonzalez	df7ea1e7ec	Release 1.9.0	2019-07-15 15:00:22 -07:00
Jose Diaz-Gonzalez	ff3a221f22	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	01823f28e3	Merge pull request #125 from dokku/upgrade-version Upgrade docker image versions	2019-07-15 14:17:56 -07:00
Jose Diaz-Gonzalez	a552d34f6d	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	576ce30062	fix: use correct variable for checking for password file	2019-07-12 12:56:37 -07:00
Jose Diaz-Gonzalez	2757aa1fe8	chore: update build targets	2019-07-11 16:35:06 -07:00
Jose Diaz-Gonzalez	2b507c6938	chore: move to helper functions for fetching passwords	2019-07-11 16:34:35 -07:00
Jose Diaz-Gonzalez	c98705f29d	chore: reorder images	2019-07-11 14:32:49 -07:00
Jose Diaz-Gonzalez	20deba8771	feat: update ambassador, s3backup, and wait images	2019-07-11 14:31:47 -07:00
Jose Diaz-Gonzalez	1ad804adba	feat: upgrade busybox to 1.31.0-uclibc	2019-07-11 13:36:40 -07:00
Jose Diaz-Gonzalez	c36d9d37b9	feat: upgrade to 3.6.13	2019-07-11 13:25:30 -07:00
Jose Diaz-Gonzalez	d022e18325	Merge pull request #123 from intergestalt/master Update README.md	2019-06-17 09:54:16 -05:00
retani	81e381efe3	Update README.md Explain mongo:export output format	2019-06-17 13:25:48 +02:00
Jose Diaz-Gonzalez	353163a4ef	Release 1.8.1	2019-06-11 15:45:33 -04:00
Jose Diaz-Gonzalez	0ba13eec86	fix: ensure the tracked container id is up to date If the ID file contained an incorrect value, calling :start would say the service is started but :info would still show the container as missing. Also fix an issue where docker inspect leaked stderr when the container was missing. Refs dokku/dokku-redis#133	2019-06-11 15:44:54 -04:00
Jose Diaz-Gonzalez	99ee8e7113	Release 1.8.0	2019-06-08 15:57:41 +02:00
Jose Diaz-Gonzalez	70b5e3d0d2	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	f494f1edbb	Merge pull request #122 from dokku/allow-dash-in-name feat: re-allow dashes in names	2019-06-08 14:54:54 +02:00
Jose Diaz-Gonzalez	80daa5d741	Merge pull request #119 from dokku/121-fix-alias fix: correct issue where aliases were being generated incorrectly	2019-06-08 14:54:42 +02:00
Jose Diaz-Gonzalez	ade8b44569	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	d97376cc48	chore: reorder functions	2019-05-30 11:13:22 -04:00
Jose Diaz-Gonzalez	44c0d80e31	chore: move retry-docker-command to common-functions	2019-05-30 11:11:02 -04:00
Jose Diaz-Gonzalez	238f09dae0	chore: run shfmt	2019-05-30 11:06:25 -04:00
Jose Diaz-Gonzalez	c90a9fdd16	Release 1.7.0	2019-04-22 03:50:22 -04:00
Jose Diaz-Gonzalez	24fd5fcaeb	Release 1.6.2	2019-04-22 03:49:36 -04:00
Jose Diaz-Gonzalez	f7583ba092	Merge pull request #121 from dokku/upgrade-versions feat: upgrade image version in use	2019-04-19 17:12:56 -04:00
Jose Diaz-Gonzalez	856dbcb93d	feat: upgrade image version in use	2019-04-19 12:48:07 -04:00
Jose Diaz-Gonzalez	3f0cd12235	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	1211610e50	Release 1.6.1	2019-03-28 05:24:59 -04:00
Jose Diaz-Gonzalez	2a2803754a	fix: update docker-s3backup image to fix backups to s3	2019-03-28 05:23:39 -04:00
Jose Diaz-Gonzalez	031c45ebb7	fix: correct env var	2019-03-27 22:17:42 -04:00
Jose Diaz-Gonzalez	2be3a4d502	fix: correct issue where aliases were being generated incorrectly	2019-03-27 12:18:18 -04:00
Jose Diaz-Gonzalez	1b9e661fed	docs: update readme install instructions to point to correct dokku version	2019-03-26 11:51:12 -04:00
Jose Diaz-Gonzalez	1fcb939e9b	Release 1.6.0	2019-03-25 14:16:04 -04:00
Jose Diaz-Gonzalez	2f2de28e87	feat: pin busybox to an actual version Rather than dancing around what version of busybox to use, pin it to the latest, known good version of busybox. This will give us confidence in what is being shipped and run on a user's machine.	2019-03-25 14:14:22 -04:00
Jose Diaz-Gonzalez	e6cd4fb666	fix: pin busybox in run commands to the image we pull down	2019-03-25 13:51:15 -04:00
Jose Diaz-Gonzalez	fa15a7231e	feat: update to latest dokku/s3backup image	2019-03-25 13:47:03 -04:00
Jose Diaz-Gonzalez	f2846ab25b	feat: switch to updated wait image	2019-03-25 12:46:42 -04:00
Jose Diaz-Gonzalez	7604d5bc32	feat: switch to updated ambassador image	2019-03-25 12:46:01 -04:00
Jose Diaz-Gonzalez	1a4e141279	fix: correct handling of container retrieval In the previous method, if the container was renamed or there were multiple names attached to the container, fetching the container ID would fail as the regex would only match at the end. Instead of using grep, use the docker 'filter' functionality to fetch the container ID as appropriate.	2019-03-25 12:37:35 -04:00