Release 1.11.2

This allows us to more quickly update the image versions in use for tertiary images.

.circleci/config.yml

@@ -0,0 +1,68 @@
+version: 2
+jobs:
+  build-master:
+    environment:
+      DOKKU_VERSION: master
+    machine:
+      docker_layer_caching: false
+      image: ubuntu-1604:201903-01
+    steps:
+      - checkout
+      - run: pyenv global 3.7.0
+      - run: make setup
+      - run: sudo sysctl -w vm.max_map_count=262144
+      - run:
+          command: |
+            make generate;
+            if [[ $(git diff) ]]; then
+              echo "Please run `make generate`";
+              git status --short;
+              git diff;
+              exit 1;
+            fi
+      - run: make test
+      - store_artifacts:
+          path: build
+          destination: build
+      - store_artifacts:
+          path: tmp/test-results
+          destination: test-results
+      - store_test_results:
+          path: tmp/test-results
+
+  build-version:
+    environment:
+      DOKKU_VERSION: v0.19.0
+    machine:
+      docker_layer_caching: false
+      image: ubuntu-1604:201903-01
+    steps:
+      - checkout
+      - run: pyenv global 3.7.0
+      - run: make setup
+      - run: sudo sysctl -w vm.max_map_count=262144
+      - run:
+          command: |
+            make generate;
+            if [[ $(git diff) ]]; then
+              echo "Please run `make generate`";
+              git status --short;
+              git diff;
+              exit 1;
+            fi
+      - run: make test
+      - store_artifacts:
+          path: build
+          destination: build
+      - store_artifacts:
+          path: tmp/test-results
+          destination: test-results
+      - store_test_results:
+          path: tmp/test-results
+
+workflows:
+  version: 2
+  build:
+    jobs:
+      - "build-master"
+      - "build-version"

.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

.gitignore

@@ -1,5 +1,2 @@
-tests/dokku
+/tmp
-tests/fixtures
-tests/bin/plugn
-tests/bin/readlink
 .vagrant

.travis.yml

@@ -1,10 +0,0 @@
-sudo: required
-dist: trusty
-language: bash
-env:
-  - DOKKU_VERSION=master DOKKU_SYSTEM_GROUP=travis DOKKU_SYSTEM_USER=travis
-  - DOKKU_VERSION=v0.7.0 DOKKU_SYSTEM_GROUP=travis DOKKU_SYSTEM_USER=travis
-  - DOKKU_VERSION=v0.6.0 DOKKU_SYSTEM_GROUP=travis DOKKU_SYSTEM_USER=travis
-  - DOKKU_VERSION=v0.5.0 DOKKU_SYSTEM_GROUP=travis DOKKU_SYSTEM_USER=travis
-  - DOKKU_VERSION=v0.4.0 DOKKU_SYSTEM_GROUP=travis DOKKU_SYSTEM_USER=travis
-script: make test

Makefile

@@ -1,22 +1,40 @@
+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)
+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
+	cd /tmp/bats && sudo ./install.sh /usr/local
+	rm -rf /tmp/bats
+endif
+
 shellcheck:
-ifeq ($(shell shellcheck > /dev/null 2>&1 ; echo $$?),127)
+ifneq ($(shell shellcheck --version >/dev/null 2>&1 ; echo $$?),0)
-ifeq ($(shell uname),Darwin)
+ifeq ($(SYSTEM_NAME),darwin)
 	brew install shellcheck
 else
 	sudo add-apt-repository 'deb http://archive.ubuntu.com/ubuntu trusty-backports main restricted universe multiverse'
+	sudo rm -rf /var/lib/apt/lists/* && sudo apt-get clean
 	sudo apt-get update -qq && sudo apt-get install -qq -y shellcheck
 endif
 endif
 
-bats:
+shfmt:
-ifeq ($(shell bats > /dev/null 2>&1 ; echo $$?),127)
+ifneq ($(shell shfmt --version >/dev/null 2>&1 ; echo $$?),0)
-ifeq ($(shell uname),Darwin)
+ifeq ($(shfmt),Darwin)
-	git clone https://github.com/sstephenson/bats.git /tmp/bats
+	brew install shfmt
-	cd /tmp/bats && sudo ./install.sh /usr/local
-	rm -rf /tmp/bats
 else
-	sudo add-apt-repository ppa:duggan/bats --yes
+	wget -qO /tmp/shfmt https://github.com/mvdan/sh/releases/download/v$(SHFMT_VERSION)/shfmt_v$(SHFMT_VERSION)_linux_amd64
-	sudo apt-get update -qq && sudo apt-get install -qq -y bats
+	chmod +x /tmp/shfmt
+	sudo mv /tmp/shfmt /usr/local/bin/shfmt
 endif
 endif
 
@@ -30,20 +48,59 @@ endif
 
 ci-dependencies: shellcheck bats readlink
 
-lint:
+lint-setup:
+	@mkdir -p tmp/test-results/shellcheck tmp/shellcheck
+	@find . -not -path '*/\.*' -type f | xargs file | grep text | awk -F ':' '{ print $$1 }' | xargs head -n1 | egrep -B1 "bash" | grep "==>" | awk '{ print $$2 }' > tmp/shellcheck/test-files
+	@cat tests/shellcheck-exclude | sed -n -e '/^# SC/p' | cut -d' ' -f2 | paste -d, -s - > tmp/shellcheck/exclude
+
+lint: lint-setup
 	# these are disabled due to their expansive existence in the codebase. we should clean it up though
-	# SC1090: Can't follow non-constant source. Use a directive to specify location.
+	@cat tests/shellcheck-exclude | sed -n -e '/^# SC/p'
-	# SC2034: Variable appears unused. Verify it or export it.
-	# SC2155: Declare and assign separately to avoid masking return values.
 	@echo linting...
-	@$(QUIET) find ./ -maxdepth 1 -not -path '*/\.*' | xargs file | egrep "shell|bash" | awk '{ print $$1 }' | sed 's/://g' | xargs shellcheck -e SC1090,SC2034,SC2155
+	@cat tmp/shellcheck/test-files | xargs shellcheck -e $(shell cat tmp/shellcheck/exclude) | tests/shellcheck-to-junit --output tmp/test-results/shellcheck/results.xml --files tmp/shellcheck/test-files --exclude $(shell cat tmp/shellcheck/exclude)
 
 unit-tests:
 	@echo running unit tests...
-	@$(QUIET) bats 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
+
+tmp/xunit-reader:
+	mkdir -p tmp
+	curl -o tmp/xunit-reader.tgz -sL https://github.com/josegonzalez/go-xunit-reader/releases/download/v$(XUNIT_READER_VERSION)/xunit-reader_$(XUNIT_READER_VERSION)_$(SYSTEM_NAME)_$(HARDWARE).tgz
+	tar xf tmp/xunit-reader.tgz -C tmp
+	chmod +x tmp/xunit-reader
+
+tmp/xunit-to-github:
+	mkdir -p tmp
+	curl -o tmp/xunit-to-github.tgz -sL https://github.com/josegonzalez/go-xunit-to-github/releases/download/v$(XUNIT_TO_GITHUB_VERSION)/xunit-to-github_$(XUNIT_TO_GITHUB_VERSION)_$(SYSTEM_NAME)_$(HARDWARE).tgz
+	tar xf tmp/xunit-to-github.tgz -C tmp
+	chmod +x tmp/xunit-to-github
 
 setup:
 	bash tests/setup.sh
 	$(MAKE) ci-dependencies
 
-test: setup lint unit-tests
+test: lint unit-tests
+
+report: tmp/xunit-reader tmp/xunit-to-github
+	tmp/xunit-reader -p 'tmp/test-results/bats/*.xml'
+	tmp/xunit-reader -p 'tmp/test-results/shellcheck/*.xml'
+ifdef TRAVIS_REPO_SLUG
+ifdef GITHUB_ACCESS_TOKEN
+ifneq ($(TRAVIS_PULL_REQUEST),false)
+	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
+
+.PHONY: clean
+clean:
+	rm -f README.md
+
+.PHONY: generate
+generate: clean README.md
+
+.PHONY: README.md
+README.md:
+	bin/generate

README.md

@@ -1,87 +1,106 @@
 # 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)
 
-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 3.6.15](https://hub.docker.com/_/mongo/).
 
-## requirements
+## Requirements
 
-- dokku 0.4.x+
+- dokku 0.12.x+
 - docker 1.8.x
 
-## installation
+## Installation
 
 ```shell
-# on 0.4.x+
+# on 0.12.x+
 sudo dokku plugin:install https://github.com/dokku/dokku-mongo.git mongo
 ```
 
-## commands
+## Commands
 
 ```
-mongo:app-links <app>          List all mongo service links for a given app
+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 <service> <bucket-name> [--use-iam]   # creates 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-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 <name>     Removes backup authentication for the mongo service
+mongo:backup-deauth <service>                      # removes backup authentication for the mongo service
-mongo:backup-schedule <name> <schedule> <bucket> Schedules a backup of the mongo service
+mongo:backup-schedule <service> <schedule> <bucket-name> [--use-iam] # 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-schedule-cat <service>                # cat the contents of the configured backup cronfile for the service
-mongo:backup-set-encryption <name> <encryption_key> Sets up GPG encryption for future backups of the mongo service
+mongo:backup-set-encryption <service> <passphrase> # sets encryption for all future backups of mongo service
-mongo:backup-unschedule <name> Unschedules the backup of the mongo service
+mongo:backup-unschedule <service>                  # unschedules the backup of the mongo service
-mongo:backup-unset-encryption <name> Removes backup encryption for future backups of the mongo service
+mongo:backup-unset-encryption <service>            # unsets 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:clone <service> <new-service> [--clone-flags...] # create container <new-name> then copy data from <name> into <new-name>
-mongo:connect <name>           Connect via telnet to a mongo service
+mongo:connect <service>                            # connect to the service via the mongo connection tool
-mongo:connect-admin <name>     Connect via telnet to a mongo service as admin user
+mongo:connect-admin <service>                      # connect via mongo to a mongo service as admin user
-mongo:create <name>            Create a mongo service with environment variables
+mongo:create <service> [--create-flags...]         # create a mongo service
-mongo:destroy <name>           Delete the service, delete the data and stop its container if there are no links left
+mongo:destroy <service> [-f|--force]               # delete the mongo service/data/container if there are no links left
-mongo:enter <name> [command]   Enter or run a command in a running mongo service container
+mongo:enter <service>                              # enter or run a command in a running mongo service container
-mongo:exists <service>         Check if the mongo service exists
+mongo:exists <service>                             # check if the mongo service exists
-mongo:export <name> > <file>   Export a dump of the mongo service database
+mongo:export <service>                             # 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:expose <service> <ports...>                  # 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:import <service>                             # import a dump into the mongo service database
-mongo:info <name>              Print the connection information
+mongo:info <service> [--single-info-flag]          # print the service information
-mongo:link <name> <app>        Link the mongo service to the app
+mongo:link <service> <app> [--link-flags...]       # link the mongo service to the app
-mongo:linked <name> <app>      Check if the mongo service is linked to an app
+mongo:linked <service> <app>                       # check if the mongo service is linked to an app
-mongo:list                     List all mongo services
+mongo:links <service>                              # list all apps linked to the mongo service
-mongo:logs <name> [-t]         Print the most recent log(s) for this service
+mongo:list                                         # list all mongo services
-mongo:promote <name> <app>     Promote service <name> as MONGO_URL in <app>
+mongo:logs <service> [-t|--tail]                   # print the most recent log(s) for this service
-mongo:restart <name>           Graceful shutdown and restart of the mongo service container
+mongo:promote <service> <app>                      # promote service <service> as MONGO_URL in <app>
-mongo:start <name>             Start a previously stopped mongo service
+mongo:restart <service>                            # graceful shutdown and restart of the mongo service container
-mongo:stop <name>              Stop a running mongo service
+mongo:start <service>                              # start a previously stopped mongo service
-mongo:unexpose <name>          Unexpose a previously exposed mongo service
+mongo:stop <service>                               # stop a running mongo service
-mongo:unlink <name> <app>      Unlink the mongo service from the app
+mongo:unexpose <service>                           # unexpose a previously exposed mongo service
-mongo:upgrade <name>           Upgrade service <service> to the specified version
+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
+# usage
-dokku mongo:create lolipop
+dokku mongo:create <service> [--create-flags...]
+```
 
-# you can also specify the image and image
+Create a mongo service named lolipop:
-# version to use for the service
-# it *must* be compatible with the
-# official mongo image
-export MONGO_IMAGE="mongo"
-export MONGO_IMAGE_VERSION="3.0.5"
-dokku mongo:create lolipop
 
-# you can also specify custom environment
+```shell
-# variables to start the mongo service
+dokku mongo:create lolipop
-# in semi-colon separated form
+```
+
+You can also specify the image and image version to use for the service. It *must* be compatible with the ${plugin_image} image.
+
+```shell
+export MONGO_IMAGE="${PLUGIN_IMAGE}"
+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.
+
+```shell
 export MONGO_CUSTOM_ENV="USER=alpha;HOST=beta"
 dokku mongo:create lolipop
+```
 
-# by default we use the wiredTiger storage solution
+### print the service information
-# 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
 
-# get connection information as follows
+```shell
+# usage
+dokku mongo:info <service> [--single-info-flag]
+```
+
+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,153 +111,494 @@ 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
+### list all mongo services
-# filesystem changes will not be saved to disk
-dokku mongo:enter lolipop
 
-# you may also run a command directly against the service
+```shell
-# filesystem changes will not be saved to disk
+# usage
-dokku mongo:enter lolipop ls -lah /
+dokku mongo:list 
+```
 
-# a mongo service can be linked to a
+List all services:
-# 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
 
-# the following environment variables will be set automatically by docker (not
+```shell
-# on the app itself, so they won’t be listed when calling dokku config)
+dokku mongo:list
-#
+```
-#   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`.
 
-# another service can be linked to your app
+### print the most recent log(s) for this service
-dokku mongo:link other_service playground
 
-# since DATABASE_URL is already in use, another environment variable will be
+```shell
-# generated automatically
+# usage
-#
+dokku mongo:logs <service> [-t|--tail]
-#   DOKKU_MONGO_BLUE_URL=mongodb://other_service:ANOTHER_PASSWORD@dokku-mongo-other-service:27017/other_service
+```
 
-# you can then promote the new service to be the primary one
+You can tail logs for a particular service:
-# NOTE: this will restart your app
-dokku mongo:promote other_service playground
 
-# this will replace MONGO_URL with the url from other_service and generate
+```shell
-# 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
-
-# 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
 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
+By default, logs will not be tailed, but you can do this with the --tail flag:
-
-It's possible to change the protocol for MONGO_URL by setting
-the environment variable MONGO_DATABASE_SCHEME on the app:
 
+```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...]
+```
+
+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
+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):
-mongo2://lolipop:SOME_PASSWORD@dokku-mongo-lolipop:27017/lolipop
 
-CAUTION: Changing MONGO_DATABASE_SCHEME after linking will cause dokku to
+```
-believe the mongo is not linked when attempting to use `dokku mongo:unlink`
+DOKKU_MONGO_LOLIPOP_NAME=/lolipop/DATABASE
-or `dokku mongo:promote`.
+DOKKU_MONGO_LOLIPOP_PORT=tcp://172.17.0.1:27017
-You should be able to fix this by
+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
+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:
-- Unlink the service
-- Change MONGO_DATABASE_SCHEME to the desired setting
-- Relink the service
 
-## 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 ${PLUGIN_DATASTORE_PORTS[@]}
+```
+
+### 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...]
+```
+
+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...]
+```
+
+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
+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.
-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:
- 
+
-```
+```shell
-# setup s3 backup authentication with different region
 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]
+```
+
+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 a gpg passphrase 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 a gpg encryption key 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]
+```
+
+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.
 
-Please ensure the proper images are in place when `docker pull` is disabled.
+Please ensure the proper images are in place when `docker pull` is disabled.

Vagrantfile

@@ -1,8 +1,8 @@
 # -*- mode: ruby -*-
 # vi: set ft=ruby :
 
-BOX_NAME = ENV["BOX_NAME"] || "bento/ubuntu-14.04"
+BOX_NAME = ENV["BOX_NAME"] || "bento/ubuntu-18.04"
-BOX_MEMORY = ENV["BOX_MEMORY"] || "512"
+BOX_MEMORY = ENV["BOX_MEMORY"] || "2048"
 DOKKU_VERSION = "master"
 
 Vagrant.configure(2) do |config|
@@ -10,9 +10,6 @@ Vagrant.configure(2) do |config|
   config.ssh.forward_agent = true
 
   config.vm.provider :virtualbox do |vb|
-    # Ubuntu's Raring 64-bit cloud image is set to a 32-bit Ubuntu OS type by
-    # default in Virtualbox and thus will not boot. Manually override that.
-    vb.customize ["modifyvm", :id, "--ostype", "Ubuntu_64"]
     vb.customize ["modifyvm", :id, "--memory", BOX_MEMORY]
   end
 
@@ -23,7 +20,7 @@ Vagrant.configure(2) do |config|
   config.vm.define "default", primary: true do |vm|
     vm.vm.synced_folder File.dirname(__FILE__), "/vagrant"
 
-    vm.vm.provision :shell, :inline => "apt-get update > /dev/null && apt-get install -y -qq git software-properties-common"
+    vm.vm.provision :shell, :inline => "apt -q update && apt -y -qq install git software-properties-common"
     vm.vm.provision :shell, :inline => "cd /vagrant && DOKKU_VERSION=#{DOKKU_VERSION} make setup"
     vm.vm.provision :shell, :inline => "cd /vagrant && DOKKU_TRACE=1 DOKKU_VERSION=#{DOKKU_VERSION} make test"
   end

bin/generate

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

commands

@@ -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"
 

common-functions

@@ -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"
+  declare SERVICE="$1"
-  # some datastores do not like special characters in database names
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
-  # so we need to normalize them out
+
-  echo "$DATABASE" | tr .- _
+  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,37 +89,66 @@ 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"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local LINKS_FILE="$SERVICE_ROOT/LINKS"
 
-  mkdir -p "$SERVICE_ROOT" || dokku_log_fail "Unable to create service directory"
+  if [[ ! -f "$LINKS_FILE" ]]; then
-  touch "$LINKS_FILE"
+    return
+  fi
+
   sed -i.bak "/^$APP\$/d" "$LINKS_FILE" && rm "$LINKS_FILE.bak"
   sort "$LINKS_FILE" -u -o "$LINKS_FILE"
 }
 
-service_dns_hostname() {
+retry-docker-command() {
-  declare desc="Retrieves the alias of a service"
+  local ID="$1" COMMAND="$2"
-  declare SERVICE="$1"
+  local i=0 success=false
-  local SERVICE_NAME="$(get_service_name "$SERVICE")"
+  until [ $i -ge 100 ]; do
-  echo "$SERVICE_NAME" | tr ._ -
+    set +e
+    docker exec -it "$ID" sh -c "$COMMAND" 2>/dev/null
+    exit_code=$?
+    set -e
+    if [[ "$exit_code" == 0 ]]; then
+      success=true
+      break
+    fi
+    i=$((i + 1))
+    sleep 1
+  done
+  if [[ $i -gt 0 ]]; then
+    dokku_log_verbose "Container command retried ${i} time(s): ${COMMAND}"
+  fi
+  [[ "$success" == "true" ]] || dokku_log_fail "Failed to run command: ${COMMAND}"
 }
 
 service_alternative_alias() {
   declare desc="Retrieves an alternative alias for a service"
   declare EXISTING_CONFIG="$1"
   local COLORS=(AQUA BLACK BLUE FUCHSIA GRAY GREEN LIME MAROON NAVY OLIVE PURPLE RED SILVER TEAL WHITE YELLOW)
-  local ALIAS;
+  local ALIAS
 
   for COLOR in "${COLORS[@]}"; do
     ALIAS="${PLUGIN_ALT_ALIAS}_${COLOR}"
     local IN_USE=$(echo "$EXISTING_CONFIG" | grep "${ALIAS}_URL")
-    if [[ -n $IN_USE ]]; then
+    if [[ -z "$IN_USE" ]]; then
-      unset ALIAS
+      break
     fi
+    unset ALIAS
   done
   echo "$ALIAS"
 }
@@ -123,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
@@ -156,10 +191,10 @@ service_backup() {
   TMPDIR=$(mktemp -d)
   trap 'rm -rf "$TMPDIR" > /dev/null' RETURN INT TERM EXIT
 
-  docker inspect "$ID" &> /dev/null || dokku_log_fail "Service container does not exist"
+  docker inspect "$ID" &>/dev/null || dokku_log_fail "Service container does not exist"
   is_container_status "$ID" "Running" || dokku_log_fail "Service container is not running"
 
-  (service_export "$SERVICE" > "${TMPDIR}/export")
+  (service_export "$SERVICE" >"${TMPDIR}/export")
 
   # Build parameter list for s3backup tool
   BACKUP_PARAMETERS="$BACKUP_PARAMETERS -e BUCKET_NAME=$BUCKET_NAME"
@@ -183,7 +218,7 @@ service_backup() {
   fi
 
   # shellcheck disable=SC2086
-  docker run $BACKUP_PARAMETERS dokkupaas/s3backup:0.8.0
+  docker run --rm $BACKUP_PARAMETERS "$PLUGIN_S3BACKUP_IMAGE"
 }
 
 service_backup_auth() {
@@ -191,20 +226,20 @@ service_backup_auth() {
   declare SERVICE="$1" AWS_ACCESS_KEY_ID="$2" AWS_SECRET_ACCESS_KEY="$3" AWS_DEFAULT_REGION="$4" AWS_SIGNATURE_VERSION="$5" ENDPOINT_URL="$6"
   local SERVICE_BACKUP_ROOT="$PLUGIN_DATA_ROOT/$SERVICE/backup"
 
-  mkdir -p "$SERVICE_BACKUP_ROOT"
+  mkdir "$SERVICE_BACKUP_ROOT"
-  echo "$AWS_ACCESS_KEY_ID" > "$SERVICE_BACKUP_ROOT/AWS_ACCESS_KEY_ID"
+  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_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
 }
 
@@ -228,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"
@@ -246,22 +281,22 @@ 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"
   local SERVICE_ROOT="${PLUGIN_DATA_ROOT}/${SERVICE}"
   local SERVICE_BACKUP_ENCRYPTION_ROOT="${SERVICE_ROOT}/backup-encryption/"
 
-  mkdir -p "$SERVICE_BACKUP_ENCRYPTION_ROOT"
+  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() {
@@ -277,12 +312,27 @@ service_container_rm() {
   declare desc="Stops a service and removes the running container"
   declare SERVICE="$1"
   local SERVICE_NAME="$(get_service_name "$SERVICE")"
+  local ID
 
   service_stop "$SERVICE"
-  dokku_log_verbose_quiet "Removing container"
+  ID=$(docker ps -aq --no-trunc --filter "name=^/$SERVICE_NAME$" --format '{{ .ID }}') || true
-  if ! docker rm "$SERVICE_NAME" > /dev/null 2>&1; then
+  # this may be 'true' in tests...
-    dokku_log_fail "Unable to remove container for service $SERVICE" 
+  if [[ -z "$ID" ]] || [[ "$ID" == "true" ]]; then
+    return 0
   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
+    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() {
@@ -291,7 +341,7 @@ service_enter() {
   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=""
@@ -307,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
 }
@@ -316,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
 
@@ -345,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#*: }")"
@@ -403,12 +453,11 @@ service_link() {
   fi
 
   [[ -n $LINK ]] && dokku_log_fail "Already linked as $LINK"
-  mkdir -p "$SERVICE_ROOT" || dokku_log_fail "Unable to create service directory"
   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"
@@ -420,29 +469,42 @@ service_link() {
 }
 
 service_linked_apps() {
-  declare desc="Lists all applications linked to a service"
+  declare desc="Lists all apps linked to a service for info output"
   declare SERVICE="$1"
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local LINKS_FILE="$SERVICE_ROOT/LINKS"
 
   touch "$LINKS_FILE"
-  [[ -z $(< "$LINKS_FILE") ]] && echo '-' && return 0
+  [[ -z $(<"$LINKS_FILE") ]] && echo '-' && return 0
 
-  tr '\n' ' ' < "$LINKS_FILE"
+  tr '\n' ' ' <"$LINKS_FILE"
+}
+
+service_links() {
+  declare desc="Lists all apps linked to a service"
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local LINKS_FILE="$SERVICE_ROOT/LINKS"
+
+  touch "$LINKS_FILE"
+  [[ -z $(<"$LINKS_FILE") ]] && return 0
+
+  cat "$LINKS_FILE"
 }
 
 service_list() {
   declare desc="Lists all services and their status"
-  local SERVICES=$(ls "$PLUGIN_DATA_ROOT" 2> /dev/null)
+  local SERVICES=$(ls "$PLUGIN_DATA_ROOT" 2>/dev/null)
+
   if [[ -z $SERVICES ]]; then
     dokku_log_warn "There are no $PLUGIN_SERVICE services"
-  else
+    return
-    LIST="NAME,VERSION,STATUS,EXPOSED PORTS,LINKS\n"
-    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,
   fi
+
+  dokku_log_info2_quiet "$PLUGIN_SERVICE services"
+  for SERVICE in $SERVICES; do
+    echo "$SERVICE"
+  done
 }
 
 service_logs() {
@@ -457,65 +519,101 @@ 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
-  docker logs $DOKKU_LOGS_ARGS "$ID" 2> /dev/null
+  docker logs $DOKKU_LOGS_ARGS "$ID" 2>&1
 }
 
 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" ;;
+      "--custom-env") set -- "$@" "-C" ;;
-      "--image")          set -- "$@" "-i" ;;
+      "--database") set -- "$@" "-d" ;;
-      "--image-version")  set -- "$@" "-I" ;;
+      "--image-version") set -- "$@" "-I" ;;
-      "--password")       set -- "$@" "-p" ;;
+      "--image") set -- "$@" "-i" ;;
-      "--root-password")  set -- "$@" "-r" ;;
+      "--memory") set -- "$@" "-m" ;;
-
+      "--password") set -- "$@" "-p" ;;
-      "--alias")          set -- "$@" "-a" ;;
+      "--querystring") set -- "$@" "-q" ;;
-      "--database")       set -- "$@" "-d" ;;
+      "--restart-apps") set -- "$@" "-R" ;;
-      "--memory")         set -- "$@" "-m" ;;
+      "--root-password") set -- "$@" "-r" ;;
-      "--querystring")    set -- "$@" "-q" ;;
+      "--user") set -- "$@" "-u" ;;
-      "--user")           set -- "$@" "-u" ;;
+      *) set -- "$@" "$arg" ;;
-      *)                  set -- "$@" "$arg"
     esac
   done
 
   OPTIND=1
-  while getopts "a:c:C:d:i:I:m:p:q:r:u:" opt; do
+  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}"
+        SERVICE_ALIAS="${OPTARG^^}"
-         ;;
+        export SERVICE_ALIAS="${SERVICE_ALIAS%_URL}"
-      c) export PLUGIN_CONFIG_OPTIONS=$OPTARG
+        ;;
-         ;;
+      c)
-      C) export SERVICE_CUSTOM_ENV=$OPTARG
+        export PLUGIN_CONFIG_OPTIONS=$OPTARG
-         ;;
+        ;;
-      d) export SERVICE_DATABASE=$OPTARG
+      C)
-         ;;
+        export SERVICE_CUSTOM_ENV=$OPTARG
-      i) export PLUGIN_IMAGE=$OPTARG
+        ;;
-         ;;
+      d)
-      I) export PLUGIN_IMAGE_VERSION=$OPTARG
+        export SERVICE_DATABASE=$OPTARG
-         ;;
+        ;;
-      m) export SERVICE_MEMORY=$OPTARG
+      i)
-         ;;
+        export PLUGIN_IMAGE=$OPTARG
-      p) export SERVICE_PASSWORD=$OPTARG
+        ;;
-         ;;
+      I)
-      q) export SERVICE_QUERYSTRING=${OPTARG#"?"}
+        export PLUGIN_IMAGE_VERSION=$OPTARG
-         ;;
+        ;;
-      r) export SERVICE_ROOT_PASSWORD=$OPTARG
+      m)
-         ;;
+        export SERVICE_MEMORY=$OPTARG
-      u) export SERVICE_USER=$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() {
@@ -548,8 +646,8 @@ service_port_pause() {
     return
   fi
 
-  docker stop "$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
+  docker rm "$EXPOSED_NAME" >/dev/null 2>&1 || true
   if [[ "$LOG_FAIL" == "true" ]]; then
     dokku_log_info1 "Service $SERVICE unexposed"
   fi
@@ -586,10 +684,10 @@ service_port_unpause() {
     PORTS=($(cat "$PORT_FILE"))
   fi
 
-  echo "${PORTS[@]}" > "$PORT_FILE"
+  echo "${PORTS[@]}" >"$PORT_FILE"
 
   # shellcheck disable=SC2046
-  docker run -d --link "$SERVICE_NAME:$PLUGIN_COMMAND_PREFIX" --name "$EXPOSED_NAME" $(docker_ports_options "${PORTS[@]}") --restart always --label dokku=ambassador --label "dokku.ambassador=$PLUGIN_COMMAND_PREFIX" 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
@@ -629,9 +727,8 @@ service_set_alias() {
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local ALIAS_FILE="$SERVICE_ROOT/ALIAS"
 
-  mkdir -p "$SERVICE_ROOT" || dokku_log_fail "Unable to create service directory"
   touch "$ALIAS_FILE"
-  echo "$ALIAS" > "$ALIAS_FILE"
+  echo "$ALIAS" >"$ALIAS_FILE"
 }
 
 service_status() {
@@ -641,13 +738,7 @@ service_status() {
   local ID="$(cat "$SERVICE_ROOT/ID")"
   local CONTAINER_STATUS
 
-  is_container_status "$ID" "Dead" && echo "dead" && return 0
+  CONTAINER_STATUS=$(docker inspect -f "{{.State.Status}}" "$ID" 2>/dev/null || true)
-  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)
   [[ -n "$CONTAINER_STATUS" ]] && echo "$CONTAINER_STATUS" && return 0
   echo "missing" && return 0
 }
@@ -655,14 +746,14 @@ service_status() {
 service_stop() {
   declare desc="Stops a running service"
   declare SERVICE="$1"
-  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE";
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
   local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  local ID=$(docker ps -f status=running | grep -e "$SERVICE_NAME$" | awk '{print $1}') || true
+  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
@@ -682,7 +773,7 @@ service_unlink() {
 
   remove_from_links_file "$SERVICE" "$APP"
 
-  if declare -f -F add_passed_docker_option > /dev/null; then
+  if declare -f -F add_passed_docker_option >/dev/null; then
     # shellcheck disable=SC2034
     local passed_phases=(build deploy run)
     remove_passed_docker_option passed_phases[@] "--link $SERVICE_NAME:$SERVICE_DNS_HOSTNAME"
@@ -698,7 +789,7 @@ service_version() {
   declare desc="Displays the running version for an image"
   declare SERVICE="$1"
   local SERVICE_NAME="$(get_service_name "$SERVICE")"
-  docker inspect -f '{{.Config.Image}}' "$SERVICE_NAME" 2> /dev/null || true
+  docker inspect -f '{{.Config.Image}}' "$SERVICE_NAME" 2>/dev/null || true
 }
 
 update_plugin_scheme_for_app() {
@@ -713,7 +804,17 @@ update_plugin_scheme_for_app() {
 verify_service_name() {
   declare desc="Verifies that a service exists"
   declare SERVICE="$1"
-  [[ ! -n "$SERVICE" ]] && dokku_log_fail "(verify_service_name) SERVICE must not be null"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "(verify_service_name) SERVICE must not be null"
   [[ ! -d "$PLUGIN_DATA_ROOT/$SERVICE" ]] && dokku_log_fail "$PLUGIN_SERVICE service $SERVICE does not exist"
   return 0
 }
+
+write_database_name() {
+  declare desc="Writes a sanitized database name"
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+
+  # some datastores do not like special characters in database names
+  # so we need to normalize them out
+  echo "$SERVICE" | tr .- _ > "$SERVICE_ROOT/DATABASE_NAME"
+}

config

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 export MONGO_IMAGE=${MONGO_IMAGE:="mongo"}
-export MONGO_IMAGE_VERSION=${MONGO_IMAGE_VERSION:="3.4.9"}
+export MONGO_IMAGE_VERSION=${MONGO_IMAGE_VERSION:="3.6.15"}
-export MONGO_ROOT=${MONGO_ROOT:="/var/lib/dokku/services/mongo"}
+export MONGO_ROOT=${MONGO_ROOT:="$DOKKU_LIB_ROOT/services/mongo"}
 export MONGO_HOST_ROOT=${MONGO_HOST_ROOT:=$MONGO_ROOT}
 
 export PLUGIN_UNIMPLEMENTED_SUBCOMMANDS=()
@@ -25,8 +25,9 @@ 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 MONGO_CONFIG_OPTIONS=${MONGO_CONFIG_OPTIONS:=" --storageEngine wiredTiger --auth "}
+
+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"

functions

@@ -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"
@@ -8,24 +9,25 @@ if [[ -f "$PLUGIN_AVAILABLE_PATH/docker-options/functions" ]]; then
   source "$PLUGIN_AVAILABLE_PATH/docker-options/functions"
 fi
 
-# non-generic functions
-
 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() {
   local SERVICE="$1"
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  is_valid_service_name "$SERVICE" || dokku_log_fail "Please specify a valid name for the service. Valid characters are: [A-Za-z0-9_]+"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   [[ ! -d "$PLUGIN_DATA_ROOT/$SERVICE" ]] || dokku_log_fail "$PLUGIN_SERVICE service $SERVICE already exists"
-  SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"; LINKS_FILE="$SERVICE_ROOT/LINKS"
+  SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  LINKS_FILE="$SERVICE_ROOT/LINKS"
 
   service_parse_args "${@:2}"
 
@@ -43,6 +45,7 @@ service_create() {
   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"
   touch "$LINKS_FILE"
+
   ROOTPASSWORD=$(openssl rand -hex 16)
   PASSWORD=$(openssl rand -hex 16)
   if [[ -n "$SERVICE_PASSWORD" ]]; then
@@ -53,24 +56,25 @@ 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 "$ROOTPASSWORD" >"$SERVICE_ROOT/ROOTPASSWORD"
-  echo "$PASSWORD" > "$SERVICE_ROOT/PASSWORD"
+  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"
   service_create_container "$SERVICE"
 }
 
@@ -79,22 +83,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 ROOTPASSWORD="$(service_root_password "$SERVICE")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  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)
+  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"
+  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:'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:'$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 +108,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 +123,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,19 +137,23 @@ 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 | 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 | grep -e "$SERVICE_NAME$" | awk '{print $1}') || true
+  local PREVIOUS_ID=$(docker ps -aq --no-trunc --filter "status=exited" --filter "name=^/$SERVICE_NAME$" --format '{{ .ID }}') || true
-  local ROOTPASSWORD="$(cat "$SERVICE_ROOT/ROOTPASSWORD")"
+  local ROOTPASSWORD="$(service_root_password "$SERVICE")"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
+  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
@@ -154,8 +165,8 @@ service_start() {
 
 service_url() {
   local SERVICE="$1"
-  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
-  local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
   local SERVICE_DNS_HOSTNAME="$(service_dns_hostname "$SERVICE")"
-  echo "$PLUGIN_SCHEME://$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"
 }

help-functions

@@ -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,27 +22,27 @@ fn-help() {
       exit "$EXIT_CODE"
     fi
   done
-  popd > /dev/null 2>&1
+  popd >/dev/null 2>&1
 
   exit "$DOKKU_NOT_IMPLEMENTED_EXIT"
 }
 
 fn-help-all() {
   declare CMD="$1" SUBCOMMAND="$2"
-  local CMD_OUTPUT BLUE BOLD FULL_OUTPUT NORMAL 
+  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="$(tput bold)"
+    BOLD="$(fn-help-fancy-tput bold)"
-    NORMAL="\033[m"
+    NORMAL="$(fn-help-fancy-color "\033[m")"
-    BLUE="\033[0;34m"
+    BLUE="$(fn-help-fancy-color "\033[0;34m")"
-    CYAN="\033[1;36m"
+    CYAN="$(fn-help-fancy-color "\033[1;36m")"
     if [[ -n "$SUBCOMMAND" ]] && [[ "$SUBCOMMAND" != "--all" ]]; then
       fn-help-contents-subcommand "$SUBCOMMAND" "$FULL_OUTPUT"
       return "$?"
     fi
 
-    echo -e "${BOLD}usage${NORMAL}: dokku $PLUGIN_COMMAND_PREFIX[:COMMAND]"
+    echo -e "${BOLD}usage${NORMAL}: dokku ${PLUGIN_COMMAND_PREFIX}[:COMMAND]"
     echo ''
     echo -e "${BOLD}List your $PLUGIN_COMMAND_PREFIX services.${NORMAL}"
     echo ''
@@ -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
@@ -76,12 +77,12 @@ 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 UNCLEAN_FILE="${TMPDIR}/cmd-unclean" CLEAN_FILE="${TMPDIR}/cmd-clean"
   local BOLD CMD_OUTPUT CYAN EXAMPLE LIGHT_GRAY NORMAL
   trap 'rm -rf "$TMPDIR" > /dev/null' RETURN INT TERM EXIT
 
   rm -rf "$UNCLEAN_FILE" "$CLEAN_FILE"
-  cat "$SUBCOMMAND_ROOT/$SUBCOMMAND" > "$UNCLEAN_FILE"
+  cat "$SUBCOMMAND_ROOT/$SUBCOMMAND" >"$UNCLEAN_FILE"
 
   fn-help-subcommand-sanitize "$UNCLEAN_FILE" "$CLEAN_FILE"
   if ! is_implemented_command "$SUBCOMMAND"; then
@@ -95,12 +96,12 @@ fn-help-contents-subcommand() {
   desc="$(grep desc "$CLEAN_FILE" | head -1)"
   eval "$desc"
 
-  BLUE="\033[0;34m"
+  BLUE="$(fn-help-fancy-color "\033[0;34m")"
-  BOLD="$(tput bold)"
+  BOLD="$(fn-help-fancy-tput bold)"
-  CYAN="\033[1;36m"
+  CYAN="$(fn-help-fancy-color "\033[1;36m")"
-  NORMAL="\033[m"
+  NORMAL="$(fn-help-fancy-color "\033[m")"
-  LIGHT_GRAY="\033[2;37m"
+  LIGHT_GRAY="$(fn-help-fancy-color "\033[2;37m")"
-  LIGHT_RED="\033[1;31m"
+  LIGHT_RED="$(fn-help-fancy-color "\033[1;31m")"
   CMD_OUTPUT="$(echo -e "    ${PLUGIN_COMMAND_PREFIX}${cmd_line}, ${LIGHT_GRAY}${desc}${NORMAL}")"
   if [[ "$FULL_OUTPUT" != "true" ]]; then
     echo "$CMD_OUTPUT"
@@ -139,10 +140,30 @@ fn-help-contents-subcommand() {
   return 0
 }
 
+fn-help-fancy-tput() {
+  declare desc="A wrapper around tput"
+
+  if [[ -n "$DOKKU_NO_COLOR" ]] || [[ "$TERM" == "unknown" ]] || [[ "$TERM" == "dumb" ]]; then
+    return
+  fi
+
+  tput "$@"
+}
+
+fn-help-fancy-color() {
+  declare desc="A wrapper around colors"
+
+  if [[ -n "$DOKKU_NO_COLOR" ]] || [[ "$TERM" == "unknown" ]] || [[ "$TERM" == "dumb" ]]; then
+    return
+  fi
+
+  echo "$@"
+}
+
 fn-help-list-example() {
   # shellcheck disable=SC2034
   declare desc="return $PLUGIN_COMMAND_PREFIX plugin help content"
-  cat<<help_list
+  cat <<help_list
       NAME, VERSION, STATUS, EXPOSED PORTS, LINKS
       service-name, $PLUGIN_COMMAND_PREFIX:$PLUGIN_IMAGE_VERSION, running, -, app-name
 help_list
@@ -153,8 +174,8 @@ fn-help-subcommand-args() {
   local argline arglist args argpos BLUE NORMAL
 
   if [[ "$FULL_OUTPUT" == "true" ]]; then
-    BLUE="\033[0;34m"
+    BLUE="$(fn-help-fancy-color "\033[0;34m")"
-    NORMAL="\033[m"
+    NORMAL="$(fn-help-fancy-color "\033[m")"
   fi
   argline=$(grep declare "$FUNC_FILE" | grep -v "declare desc" | head -1 || true)
   arglist=($(echo -e "${argline// /"\n"}" | awk -F= '/=/{print ""$1""}'))
@@ -170,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}"
@@ -199,12 +220,12 @@ fn-help-subcommand-example() {
     return 0
   fi
 
-  BOLD="$(tput bold)"
+  BOLD="$(fn-help-fancy-tput bold)"
   LAST_LINE=""
-  LIGHT_GRAY="\033[2;37m"
+  LIGHT_GRAY="$(fn-help-fancy-color "\033[2;37m")"
-  OTHER_GRAY="\033[7;37m"
+  OTHER_GRAY="$(fn-help-fancy-color "\033[7;37m")"
   NEWLINE=""
-  NORMAL="\033[m"
+  NORMAL="$(fn-help-fancy-color "\033[m")"
   _fn-help-apply-shell-expansion "$EXAMPLE" | while read -r line; do
     line="$(echo "$line" | cut -c 4-)"
     if [[ "$line" == export* ]] || [[ "$line" == dokku* ]]; then
@@ -234,10 +255,10 @@ fn-help-subcommand-list-args() {
     return 0
   fi
 
-  NORMAL="\033[m"
+  NORMAL="$(fn-help-fancy-color "\033[m")"
-  LIGHT_GRAY="\033[2;37m"
+  LIGHT_GRAY="$(fn-help-fancy-color "\033[2;37m")"
 
-  _fn-help-apply-shell-expansion "$FLAGS" | while read -r line; do 
+  _fn-help-apply-shell-expansion "$FLAGS" | while read -r line; do
     echo -e "$(echo "$line" | cut -d',' -f1),${LIGHT_GRAY}$(echo "$line" | cut -d',' -f2-)${NORMAL}"
   done
 }
@@ -251,10 +272,10 @@ fn-help-subcommand-list-flags() {
     return 0
   fi
 
-  NORMAL="\033[m"
+  NORMAL="$(fn-help-fancy-color "\033[m")"
-  LIGHT_GRAY="\033[2;37m"
+  LIGHT_GRAY="$(fn-help-fancy-color "\033[2;37m")"
 
-  _fn-help-apply-shell-expansion "$FLAGS" | while read -r line; do 
+  _fn-help-apply-shell-expansion "$FLAGS" | while read -r line; do
     echo -e "$(echo "$line" | cut -d',' -f1),${LIGHT_GRAY}$(echo "$line" | cut -d',' -f2-)${NORMAL}"
   done
 }
@@ -275,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() {

install

@@ -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 "$PLUGIN_BUSYBOX_IMAGE"
-  pull-docker-image "dokkupaas/wait:0.2"
+  pull-docker-image "$PLUGIN_AMBASSADOR_IMAGE"
-  pull-docker-image "dokkupaas/s3backup:0.8.0"
+  pull-docker-image "$PLUGIN_S3BACKUP_IMAGE"
-  pull-docker-image "busybox:latest"
+  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}-*

plugin.toml

@@ -1,4 +1,4 @@
 [plugin]
 description = "dokku mongo service plugin"
-version = "1.4.0"
+version = "1.11.2"
 [plugin.config]

pre-delete

@@ -1,6 +1,8 @@
 #!/usr/bin/env bash
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_BASE_PATH/common/functions"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 
 PLUGIN_BASE_PATH="$PLUGIN_PATH"
 if [[ -n $DOKKU_API_VERSION ]]; then
@@ -10,7 +12,10 @@ source "$PLUGIN_BASE_PATH/common/functions"
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/functions"
 
 APP="$1"
-for SERVICE in "$PLUGIN_DATA_ROOT"/*; do
+pushd "$PLUGIN_DATA_ROOT" >/dev/null
+for SERVICE in *; do
+  dokku_log_verbose_quiet "Unlinking from $SERVICE"
   remove_from_links_file "$(basename "$SERVICE")" "$APP"
 done
+popd >/dev/null 2>&1 || pushd "/tmp" >/dev/null
 exit 0

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"}
 

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,11 +12,12 @@ 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"
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   [[ -z "$BUCKET_NAME" ]] && dokku_log_fail "Please specify an aws bucket for the backup"
   verify_service_name "$SERVICE"
   service_backup "$SERVICE" "$BUCKET_NAME" "$USE_IAM_OPTIONAL_FLAG"

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,11 +21,12 @@ 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"
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   [[ -z "$AWS_ACCESS_KEY_ID" ]] && dokku_log_fail "Please specify an aws access key id"
   [[ -z "$AWS_SECRET_ACCESS_KEY" ]] && dokku_log_fail "Please specify an aws secret access key"
   verify_service_name "$SERVICE"

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,11 +10,12 @@ 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"
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_backup_deauth "$SERVICE"
 }

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,11 +16,12 @@ 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"
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   [[ -z "$SCHEDULE" ]] && dokku_log_fail "Please specify a schedule for the backup"
   [[ -z "$BUCKET_NAME" ]] && dokku_log_fail "Please specify an aws bucket for the backup"
   verify_service_name "$SERVICE"

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,10 +10,11 @@ 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 name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_backup_schedule_cat "$SERVICE"
 }

subcommands/backup-set-encryption

@@ -1,23 +1,25 @@
 #!/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 encryption key for backups
+  #E set a GPG passphrase for backups
   #E dokku $PLUGIN_COMMAND_PREFIX:backup-set-encryption lolipop
   #A service, service to run command against
-  #A encryption-key, a GPG encryption key
+  #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=("$@")
-  declare SERVICE="$1" ENCRYPTION_KEY="$2"
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" PASSPHRASE="$2"
   is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
-  [[ -z "$ENCRYPTION_KEY" ]] && dokku_log_fail "Please specify a GPG encryption key"
+  [[ -z "$PASSPHRASE" ]] && dokku_log_fail "Please specify a GPG backup passphrase"
   verify_service_name "$SERVICE"
-  service_backup_set_encryption "$SERVICE" "$ENCRYPTION_KEY"
+  service_backup_set_encryption "$SERVICE" "$PASSPHRASE"
 }
 
 service-backup-set-encryption-cmd "$@"

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,11 +10,12 @@ 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"
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_backup_unschedule "$SERVICE"
 }

subcommands/backup-unset-encryption

@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
@@ -9,11 +10,12 @@ service-backup-unset-encryption-cmd() {
   #E dokku $PLUGIN_COMMAND_PREFIX:backup-unset-encryption lolipop
   #A service, service to run command against
   declare desc="unsets encryption for future backups of the $PLUGIN_SERVICE service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:backup-unset-encryption" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  local cmd="$PLUGIN_COMMAND_PREFIX:backup-unset-encryption" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
   declare SERVICE="$1"
   is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_backup_unset_encryption "$SERVICE"
 }

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"
 
@@ -9,17 +10,18 @@ service-clone-cmd() {
   #E dokku $PLUGIN_COMMAND_PREFIX:clone lolipop lolipop-2
   #A service, service to run command against
   #A new-service, name of new service
-  #F -c|--custom-env "USER=alpha;HOST=beta", semi-colon delimited environment variables to start the service with
+  #F -C|--custom-env "USER=alpha;HOST=beta", semi-colon delimited environment variables to start the service with
   #F -i|--image IMAGE, the image name to start the service with
-  #F -i|--image-version IMAGE_VERSION, the image version to start the service with
+  #F -I|--image-version IMAGE_VERSION, the image version to start the service with
   #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=("$@")
-  declare SERVICE="$1" NEW_SERVICE="$2" CLONE_FLAGS_LIST="${@:3}"
+  [[ ${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"
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   [[ -z "$NEW_SERVICE" ]] && dokku_log_fail "Please specify a name for the new service"
   verify_service_name "$SERVICE"
 
@@ -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=$(service_version "$SERVICE" | grep -o "^.*:" | sed -r "s/://g")
-  PLUGIN_IMAGE_VERSION=$(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"
 }
 

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,11 +10,12 @@ 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"
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_connect "$SERVICE"
 }

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 name for the service"
+  [[ -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"

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,19 +13,20 @@ 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
   #A service, service to run command against
-  #F -c|--custom-env "USER=alpha;HOST=beta", semi-colon delimited environment variables to start the service with
+  #F -C|--custom-env "USER=alpha;HOST=beta", semi-colon delimited environment variables to start the service with
   #F -i|--image IMAGE, the image name to start the service with
-  #F -i|--image-version IMAGE_VERSION, the image version to start the service with
+  #F -I|--image-version IMAGE_VERSION, the image version to start the service with
   #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=("$@")
-  declare SERVICE="$1" CREATE_FLAGS_LIST="${@:2}"
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" CREATE_FLAGS_LIST=("${@:2}")
 
   service_create "$SERVICE" "${@:2}"
 }

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 name for the service"
+  [[ -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,20 +41,11 @@ service-destroy-cmd() {
   fi
 
   dokku_log_info2_quiet "Deleting $SERVICE"
-  if [[ -n $(docker ps -aq -f name="$SERVICE_NAME") ]]; then
+  service_backup_unschedule "$SERVICE"
-    dokku_log_verbose_quiet "Deleting container data"
+  service_container_rm "$SERVICE"
-    service_stop "$SERVICE"
-    sleep 1
-
-    dokku_log_verbose_quiet "Removing container"
-    docker rm -v "$SERVICE_NAME" > /dev/null
-    sleep 1
-  else
-    dokku_log_verbose_quiet "No container exists for $SERVICE"
-  fi
 
   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/config:/config" "$PLUGIN_BUSYBOX_IMAGE" chmod 777 -R /config /data
   rm -rf "$SERVICE_ROOT"
 
   dokku_log_info2 "$PLUGIN_SERVICE container deleted: $SERVICE"

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"

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,10 +10,11 @@ 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 name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   dokku_log_info1 "Service $SERVICE exists"
 }

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,11 +12,12 @@ 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"
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_export "$SERVICE"
 }

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,10 +11,11 @@ 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=("$@")
-  declare SERVICE="$1" PORTS_LIST="${@:2}"
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" PORTS_LIST=("${@:2}")
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_port_expose "$SERVICE" "${@:2}"
 }

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,11 +10,12 @@ 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"
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_import "$SERVICE"
 }

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,11 +30,12 @@ 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"
+  declare desc="print the service information"
-  local cmd="$PLUGIN_COMMAND_PREFIX:info" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  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 name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_info "$SERVICE" "$INFO_FLAG"
 }

subcommands/link

@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
@@ -42,11 +43,12 @@ 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=("$@")
-  declare SERVICE="$1" APP="$2" LINK_FLAGS_LIST="${@:3}"
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" APP="$2" LINK_FLAGS_LIST=("${@:3}")
   APP=${APP:="$DOKKU_APP_NAME"}
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   [[ -z "$APP" ]] && dokku_log_fail "Please specify an app to run the command on"
   verify_app_name "$APP"
   verify_service_name "$SERVICE"

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,11 +11,12 @@ 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"}
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   [[ -z "$APP" ]] && dokku_log_fail "Please specify an app to run the command on"
   verify_app_name "$APP"
   verify_service_name "$SERVICE"

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 "$@"

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
 }

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,10 +13,11 @@ 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 name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_logs "$SERVICE" "$TAIL_FLAG"
 }

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,11 +24,12 @@ 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"}
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   [[ -z "$APP" ]] && dokku_log_fail "Please specify an app to run the command on"
   verify_service_name "$SERVICE"
   verify_app_name "$APP"

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,10 +10,11 @@ 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 name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_stop "$SERVICE"
   service_start "$SERVICE"

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,10 +10,11 @@ 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 name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_start "$SERVICE"
 }

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,10 +10,11 @@ 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 name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_stop "$SERVICE"
 }

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,10 +10,11 @@ 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 name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
   service_port_unexpose "$SERVICE"
 }

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,11 +12,12 @@ 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"}
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   [[ -z "$APP" ]] && dokku_log_fail "Please specify an app to run the command on"
   verify_service_name "$SERVICE"
   verify_app_name "$APP"

subcommands/upgrade

@@ -1,26 +1,28 @@
 #!/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"
 
 service-upgrade-cmd() {
   #E you can upgrade an existing service to a new image or image-version
   #E dokku $PLUGIN_COMMAND_PREFIX:upgrade lolipop
   #A service, service to run command against
-  #F -c|--custom-env "USER=alpha;HOST=beta", semi-colon delimited environment variables to start the service with
+  #F -C|--custom-env "USER=alpha;HOST=beta", semi-colon delimited environment variables to start the service with
   #F -i|--image IMAGE, the image name to start the service with
-  #F -i|--image-version IMAGE_VERSION, the image version to start the service with
+  #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=("$@")
-  declare SERVICE="$1" CLONE_FLAGS_LIST="${@:2}"
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" UPGRADE_FLAGS_LIST=("${@:2}")
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
   verify_service_name "$SERVICE"
 
   local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
-  local ID="$(cat "$SERVICE_ROOT/ID")"
-  is_container_status "$ID" "Running" || dokku_log_fail "Service ${SERVICE} container is not running"
 
   service_parse_args "${@:2}"
 
@@ -28,10 +30,33 @@ service-upgrade-cmd() {
     dokku_log_fail "Unable to proceed with upgrade, image ${PLUGIN_IMAGE}:${PLUGIN_IMAGE_VERSION} does not exist"
   fi
 
-  dokku_log_info2 "Upgrading $SERVICE to $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION"
+  local NEW_PLUGIN_IMAGE_TAG="$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION"
+  if [[ "$(service_version "$SERVICE")" == "$NEW_PLUGIN_IMAGE_TAG" ]]; then
+    dokku_log_info1 "Service $SERVICE already running $NEW_PLUGIN_IMAGE_TAG"
+    return
+  fi
+
+  dokku_log_info2 "Upgrading $SERVICE to $NEW_PLUGIN_IMAGE_TAG"
+  if [[ "$SERVICE_RESTART_APPS" == "true" ]]; then
+    dokku_log_info2 "Stopping all linked services"
+    for app in $(service_linked_apps "$SERVICE"); do
+      [[ "$app" == "-" ]] && continue
+      ps_stop "$app"
+    done
+  fi
+
   dokku_log_info2 "Stopping $SERVICE"
   service_container_rm "$SERVICE"
   service_start "$SERVICE" "${@:2}"
+
+  if [[ "$SERVICE_RESTART_APPS" == "true" ]]; then
+    dokku_log_info2 "Starting all linked services"
+    for app in $(service_linked_apps "$SERVICE"); do
+      [[ "$app" == "-" ]] && continue
+      ps_start "$app"
+    done
+  fi
+
   dokku_log_info2 "Done"
 }
 

tests/bin/at-least-version

@@ -1,38 +0,0 @@
-#!/usr/bin/env bash
-set -eo pipefail; [[ $TRACE ]] && set -x
-
-semver-parse-into() {
-  declare VERSION="$1"
-  local RE='[^0-9]*\([0-9]*\)[.]\([0-9]*\)[.]\([0-9]*\)'
-  local MAJOR="$(echo "$VERSION" | sed -e "s#$RE#\1#")"
-  local MINOR="$(echo "$VERSION" | sed -e "s#$RE#\2#")"
-  local PATCH="$(echo "$VERSION" | sed -e "s#$RE#\3#")"
-  echo "${MAJOR} ${MINOR} ${PATCH}"
-}
-
-main() {
-  declare MIN_VERSION="$1" CHECK_VERSION="$2"
-  local IS_AT_LEAST_VERSION=false
-  local MAJOR_MIN MINOR_MIN PATCH_MIN MAJOR_CHECK MINOR_CHECK PATCH_CHECK PARSED_MIN PARSED_CHECK
-
-  PARSED_MIN="$(semver-parse-into "$MIN_VERSION")"
-  PARSED_CHECK="$(semver-parse-into "$CHECK_VERSION")"
-  MAJOR_MIN="$(echo "$PARSED_MIN" | cut -d' ' -f1)"
-  MINOR_MIN="$(echo "$PARSED_MIN" | cut -d' ' -f2)"
-  PATCH_MIN="$(echo "$PARSED_MIN" | cut -d' ' -f3)"
-  MAJOR_CHECK="$(echo "$PARSED_CHECK" | cut -d' ' -f1)"
-  MINOR_CHECK="$(echo "$PARSED_CHECK" | cut -d' ' -f2)"
-  PATCH_CHECK="$(echo "$PARSED_CHECK" | cut -d' ' -f3)"
-
-  if [[ "$MAJOR_CHECK" -gt "$MAJOR_MIN" ]]; then
-    IS_AT_LEAST_VERSION=true
-  elif [[ "$MAJOR_CHECK" -eq "$MAJOR_MIN" ]] && [[ "$MINOR_CHECK" -gt "$MINOR_MIN" ]]; then
-    IS_AT_LEAST_VERSION=true
-  elif [[ "$MAJOR_CHECK" -eq "$MAJOR_MIN" ]] && [[ "$MINOR_CHECK" -eq "$MINOR_MIN" ]] && [[ "$PATCH_CHECK" -ge "$PATCH_MIN" ]]; then
-    IS_AT_LEAST_VERSION=true
-  fi
-
-  echo "$IS_AT_LEAST_VERSION"
-}
-
-main "$@"

tests/bin/docker

@@ -1,101 +0,0 @@
-#!/usr/bin/env bash
-# shellcheck source=../../config
-# shellcheck disable=SC1091
-source "$(dirname "$0")/../../config"
-
-if [[ $ECHO_DOCKER_COMMAND == "true" ]]; then
-  echo "$(basename "$0") $*"
-  exit 0
-fi
-
-case "$1" in
-  exec)
-    echo "exec called with $@"
-    ;;
-  images)
-    echo "REPOSITORY                           TAG                 IMAGE ID            CREATED             VIRTUAL SIZE"
-    echo "elasticsearch                        2.3.5               89ed89918502        2 days ago          522.1 MB"
-    echo "frodenas/couchdb                     1.6                 cb9a62e007eb        2 days ago          537 MB"
-    echo "dokkupaas/docker-grafana-graphite    3.0.1               75dcd48a5eef        2 days ago          936.4 MB"
-    echo "mariadb                              10.1.16             f2485761e714        2 days ago          302.2 MB"
-    echo "memcached                            1.4.31              8a05b51f8876        2 days ago          132.4 MB"
-    echo "mongo                                3.4.9               12eadb136159        2 days ago          291.1 MB"
-    echo "mysql                                5.7.12              57d56ac47bed        2 days ago          321.3 MB"
-    echo "nats                                 0.9.4               9216d5a4eec8        2 days ago          109.3 MB"
-    echo "postgres                             9.5.4               6412eb70175e        2 days ago          265.7 MB"
-    echo "rabbitmq                             3.6.5-management    327b803301e9        2 days ago          143.5 MB"
-    echo "redis                                3.2.3               9216d5a4eec8        2 days ago          109.3 MB"
-    echo "rethinkdb                            2.3.4               f27010a550ec        2 days ago          196.3 MB"
-    echo "svendowideit/ambassador              latest              0d2200edc53e        2 days ago          7.241 MB"
-    ;;
-  inspect)
-    if [[ $@ = *"IPAddress"* ]]; then
-      echo "172.17.0.34"
-      exit 0
-    fi
-
-    if [[ $@ =~ \{\{.Config.Image\}\} ]]; then
-      echo "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION"
-      exit 0
-    fi
-
-    if [[ $@ =~ \{\{\.State\..*\}\} ]]; then
-      if [[ $@ =~ \{\{\.State\.Running\}\} ]]; then
-        echo "true"
-      else
-        echo "false"
-      fi
-      exit 0
-    fi
-
-    # running
-    echo "true"
-    ;;
-  kill)
-    echo "testid"
-    ;;
-  logs)
-    echo "$PLUGIN_SERVICE $PLUGIN_IMAGE_VERSION"
-    ;;
-  ps)
-    if [[ $@ = *"no-trunc"* ]]; then
-      echo "1479bbd60ade8a92617d2aeb4935bd3ff3179bd0fd71c22c3102c421f4bc221f"
-      exit 0
-    else
-      echo 'CONTAINER ID        IMAGE                      COMMAND                CREATED             STATUS                         PORTS               NAMES'
-      echo '4eeaae231d5e        elasticsearch:2.3.5                        "/docker-entrypoint."      11 seconds ago       Up 10 seconds       9200/tcp, 9300/tcp                         dokku.elasticsearch.l'
-      echo '2b20a383226d        frodenas/couchdb:1.6                       "/scripts/run.sh"          11 seconds ago       Up 10 seconds       5984/tcp                                   dokku.couchdb.l'
-      echo '76a0e7154483        dokkupaas/docker-grafana-graphite:3.0.1    "/usr/bin/supervisor"      11 seconds ago       Up 10 seconds       80/tcp, 2003/tcp, 8126/tcp, 8125/udp       dokku.graphite.l'
-      echo '94df08fe5550        mariadb:10.1.16                            "/docker-entrypoint."      11 seconds ago       Up 10 seconds       3306/tcp                                   dokku.mariadb.l'
-      echo 'ef27fec191ba        memcached:1.4.31                           "/entrypoint.sh memc"      11 seconds ago       Up 10 seconds       11211/tcp                                  dokku.memcached.l'
-      echo 'c0f74fc90377        mongo:3.2.9                                "/entrypoint.sh mong"      11 seconds ago       Up 10 seconds       27017/tcp                                  dokku.mongo.l'
-      echo '0f33b1c86da9        mysql:5.7.12                               "/entrypoint.sh mysq"      11 seconds ago       Up 10 seconds       3306/tcp                                   dokku.mysql.l'
-      echo '9f10b6dc12d5        nats:0.9.4                                 "/entrypoint.sh redi"      11 seconds ago       Up 10 seconds       4222/tcp                                   dokku.nats.l'
-      echo '7f899b723c08        postgres:9.5.4                             "/docker-entrypoint."      11 seconds ago       Up 10 seconds       5432/tcp                                   dokku.postgres.l'
-      echo '5e50a462661e        rabbitmq:3.6.5-management                  "/docker-entrypoint."      11 seconds ago       Up 10 seconds       5672/tcp, 15672/tcp                        dokku.rabbitmq.l'
-      echo 'c39ca00fa3c6        redis:3.2.3                                "/entrypoint.sh redi"      11 seconds ago       Up 10 seconds       6379/tcp                                   dokku.redis.l'
-      echo 'dc98c2939a80        rethinkdb:2.3.4                            "rethinkdb --bind al"      11 seconds ago       Up 10 seconds       8080/tcp, 28015/tcp, 29015/tcp             dokku.rethinkdb.l'
-    fi
-    ;;
-  pull)
-    exit 0
-    ;;
-  restart)
-    echo "testid"
-    ;;
-  rm)
-    echo "testid"
-    ;;
-  run)
-    echo "testid"
-    ;;
-  start)
-    echo "testid"
-    ;;
-  stop)
-    echo "testid"
-    ;;
-  *)
-    exit "$DOKKU_NOT_IMPLEMENTED_EXIT"
-    ;;
-esac

tests/bin/id

@@ -1,2 +0,0 @@
-#!/usr/bin/env bash
-echo "dokku"

tests/bin/lsb_release

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-if [[ "$(uname)" == "Darwin" ]]; then
-  echo "Darwin"
-else
-  echo "Ubuntu"
-fi

tests/bin/mongo

@@ -1,2 +0,0 @@
-#!/usr/bin/env bash
-exit 0

tests/bin/sudo

@@ -1,2 +0,0 @@
-#!/usr/bin/env bash
-exit 0

tests/hook_pre_delete.bats

@@ -2,15 +2,14 @@
 load test_helper
 
 setup() {
-  dokku apps:create my_app >&2
+  dokku apps:create my_app
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
   dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app >&2
 }
 
 teardown() {
   dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app >&2
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
-  rm -rf "$DOKKU_ROOT/my_app"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:hook:pre-delete) removes app from links file when destroying app" {

tests/service_clone.bats

@@ -2,34 +2,37 @@
 load test_helper
 
 setup() {
-  export ECHO_DOCKER_COMMAND="false"
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
 }
 
 teardown() {
-  export ECHO_DOCKER_COMMAND="false"
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:clone) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:clone"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
+  assert_failure
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:clone) error when service does not exist" {
   run dokku "$PLUGIN_COMMAND_PREFIX:clone" not_existing_service new_service
   assert_contains "${lines[*]}" "service not_existing_service does not exist"
+  assert_failure
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:clone) error when new service isn't provided" {
   run dokku "$PLUGIN_COMMAND_PREFIX:clone" l
   assert_contains "${lines[*]}" "Please specify a name for the new service"
+  assert_failure
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:clone) error when new service already exists" {
   dokku "$PLUGIN_COMMAND_PREFIX:create" new_service
   run dokku "$PLUGIN_COMMAND_PREFIX:clone" l new_service
   assert_contains "${lines[*]}" "service new_service already exists"
+  assert_failure
+
   dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" new_service
 }
 
@@ -38,5 +41,7 @@ teardown() {
   [[ -f $PLUGIN_DATA_ROOT/new_service/ID ]]
   assert_contains "${lines[*]}" "Copying data from l to new_service"
   assert_contains "${lines[*]}" "Done"
-}
+  assert_success
 
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" new_service
+}

tests/service_connect.bats

@@ -2,18 +2,16 @@
 load test_helper
 
 setup() {
-  export ECHO_DOCKER_COMMAND="false"
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
 }
 
 teardown() {
-  export ECHO_DOCKER_COMMAND="false"
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:connect) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:connect"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:connect) error when service does not exist" {
@@ -22,8 +20,7 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:connect) success" {
-  export ECHO_DOCKER_COMMAND="true"
+  skip "Connect hangs indefinitely without input"
   run dokku "$PLUGIN_COMMAND_PREFIX:connect" l
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  assert_success
-  assert_output "docker exec -i -t dokku.mongo.l mongo -u l -p $password --authenticationDatabase l l"
 }

tests/service_connect_admin.bats

@@ -2,18 +2,16 @@
 load test_helper
 
 setup() {
-  export ECHO_DOCKER_COMMAND="false"
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
 }
 
 teardown() {
-  export ECHO_DOCKER_COMMAND="false"
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:connect-admin) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:connect-admin"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:connect-admin) error when service does not exist" {
@@ -22,8 +20,7 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:connect-admin) success" {
-  export ECHO_DOCKER_COMMAND="true"
+  skip "Connect hangs indefinitely without input"
   run dokku "$PLUGIN_COMMAND_PREFIX:connect-admin" l
-  password="$(cat "$PLUGIN_DATA_ROOT/l/ROOTPASSWORD")"
+  assert_success
-  assert_output "docker exec -i -t dokku.mongo.l mongo -u admin -p $password --authenticationDatabase admin l"
 }

tests/service_create.bats

@@ -4,9 +4,24 @@ load test_helper
 @test "($PLUGIN_COMMAND_PREFIX:create) success" {
   run dokku "$PLUGIN_COMMAND_PREFIX:create" l
   assert_contains "${lines[*]}" "container created: l"
+  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 name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
+}
+
+@test "($PLUGIN_COMMAND_PREFIX:create) error when there is an invalid name specified" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:create" d.erp
+  assert_failure
 }

tests/service_destroy.bats

@@ -9,7 +9,7 @@ load test_helper
 
 @test "($PLUGIN_COMMAND_PREFIX:destroy) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:destroy"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:destroy) error when container does not exist" {
@@ -21,7 +21,10 @@ load test_helper
   dokku "$PLUGIN_COMMAND_PREFIX:create" l
   dokku apps:create app
   dokku "$PLUGIN_COMMAND_PREFIX:link" l app
-  run dokku "$PLUGIN_COMMAND_PREFIX:destroy" l
+  run dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
   assert_contains "${lines[*]}" "Cannot delete linked service"
-  rm -rf "$DOKKU_ROOT/app"
+
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l app
+  run dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
+  assert_contains "${lines[*]}" "container deleted: l"
 }

tests/service_export.bats

@@ -2,18 +2,16 @@
 load test_helper
 
 setup() {
-  export ECHO_DOCKER_COMMAND="false"
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
 }
 
 teardown() {
-  export ECHO_DOCKER_COMMAND="false"
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:export) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:export"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:export) error when service does not exist" {
@@ -22,19 +20,17 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:export) success with SSH_TTY" {
-  export ECHO_DOCKER_COMMAND="true"
   export SSH_TTY=`tty`
   run dokku "$PLUGIN_COMMAND_PREFIX:export" l
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  echo "output: $output"
+  echo "status: $status"
   assert_exit_status 0
-  assert_output "docker exec dokku.mongo.l bash -c mongodump -d l -u \"l\" -p \"$password\" --authenticationDatabase \"l\" --quiet --gzip --archive 2>/dev/null"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:export) success without SSH_TTY" {
-  export ECHO_DOCKER_COMMAND="true"
   unset SSH_TTY
   run dokku "$PLUGIN_COMMAND_PREFIX:export" l
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  echo "output: $output"
+  echo "status: $status"
   assert_exit_status 0
-  assert_output "docker exec dokku.mongo.l bash -c mongodump -d l -u \"l\" -p \"$password\" --authenticationDatabase \"l\" --quiet --gzip --archive 2>/dev/null"
 }

tests/service_expose.bats

@@ -2,16 +2,16 @@
 load test_helper
 
 setup() {
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:expose) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:expose"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:expose) error when service does not exist" {

tests/service_import.bats

@@ -2,36 +2,37 @@
 load test_helper
 
 setup() {
-  export ECHO_DOCKER_COMMAND="false"
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  echo "data" | tee "/tmp/fake.dump.tar"
-  echo "data" > "$PLUGIN_DATA_ROOT/fake.dump.tar"
 }
 
 teardown() {
-  export ECHO_DOCKER_COMMAND="false"
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  rm -f "/tmp/fake.dump.tar"
-  rm -f "$PLUGIN_DATA_ROOT/fake.dump.tar"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:import) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:import"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
+  assert_failure
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:import) error when service does not exist" {
   run dokku "$PLUGIN_COMMAND_PREFIX:import" not_existing_service
   assert_contains "${lines[*]}" "service not_existing_service does not exist"
+  assert_failure
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:import) error when data is not provided" {
   run dokku "$PLUGIN_COMMAND_PREFIX:import" l
   assert_contains "${lines[*]}" "No data provided on stdin"
+  assert_failure
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:import) success" {
-  export ECHO_DOCKER_COMMAND="true"
+  skip "The fake dump is hard to work with in tests"
-  run dokku "$PLUGIN_COMMAND_PREFIX:import" l < "$PLUGIN_DATA_ROOT/fake.dump.tar"
+  run dokku "$PLUGIN_COMMAND_PREFIX:import" l < "/tmp/fake.dump.tar"
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  echo "output: $output"
-  assert_output "docker exec -i dokku.mongo.l bash -c mongorestore -u \"l\" -p \"$password\" --authenticationDatabase \"l\" --gzip --archive --nsFrom '\$db\$.\$coll\$' --nsTo 'l.\$coll\$'"
+  echo "status: $status"
+  assert_success
 }
-

tests/service_info.bats

@@ -2,16 +2,16 @@
 load test_helper
 
 setup() {
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:info) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:info"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:info) error when service does not exist" {
@@ -21,21 +21,21 @@ teardown() {
 
 @test "($PLUGIN_COMMAND_PREFIX:info) success" {
   run dokku "$PLUGIN_COMMAND_PREFIX:info" l
-  local password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  local password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
   assert_contains "${lines[*]}" "mongodb://l:$password@dokku-mongo-l:27017/l"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:info) replaces underscores by dash in hostname" {
   dokku "$PLUGIN_COMMAND_PREFIX:create" test_with_underscores
   run dokku "$PLUGIN_COMMAND_PREFIX:info" test_with_underscores
-  local password="$(cat "$PLUGIN_DATA_ROOT/test_with_underscores/PASSWORD")"
+  local password="$(sudo cat "$PLUGIN_DATA_ROOT/test_with_underscores/PASSWORD")"
   assert_contains "${lines[*]}" "mongodb://test_with_underscores:$password@dokku-mongo-test-with-underscores:27017/test_with_underscores"
   dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" test_with_underscores
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:info) success with flag" {
   run dokku "$PLUGIN_COMMAND_PREFIX:info" l --dsn
-  local password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  local password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
   assert_output "mongodb://l:$password@dokku-mongo-l:27017/l"
 
   run dokku "$PLUGIN_COMMAND_PREFIX:info" l --config-dir

tests/service_link.bats

@@ -2,46 +2,69 @@
 load test_helper
 
 setup() {
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
-  dokku apps:create my_app >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" m
+  dokku apps:create my_app
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" m
-  rm -rf "$DOKKU_ROOT/my_app"
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
+  dokku --force apps:destroy my_app
 }
 
+
 @test "($PLUGIN_COMMAND_PREFIX:link) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:link"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  echo "output: $output"
+  echo "status: $status"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
+  assert_failure
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) error when the app argument is missing" {
   run dokku "$PLUGIN_COMMAND_PREFIX:link" l
+  echo "output: $output"
+  echo "status: $status"
   assert_contains "${lines[*]}" "Please specify an app to run the command on"
+  assert_failure
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) error when the app does not exist" {
   run dokku "$PLUGIN_COMMAND_PREFIX:link" l not_existing_app
+  echo "output: $output"
+  echo "status: $status"
   assert_contains "${lines[*]}" "App not_existing_app does not exist"
+  assert_failure
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) error when the service does not exist" {
   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"
+  assert_failure
 }
 
 @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
+  echo "output: $output"
+  echo "status: $status"
   assert_contains "${lines[*]}" "Already linked as MONGO_URL"
+  assert_failure
+
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) exports MONGO_URL to app" {
-  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)
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  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
 }
 
@@ -49,14 +72,22 @@ teardown() {
   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_"
+  assert_contains "${lines[*]}" "DOKKU_MONGO_AQUA_URL"
+  assert_success
+
+  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
+  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
 }
 
@@ -64,8 +95,9 @@ teardown() {
   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="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  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
 }
 
@@ -73,13 +105,15 @@ teardown() {
   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
 }
 
 @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)
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  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
 }

tests/service_list.bats

@@ -2,35 +2,21 @@
 load test_helper
 
 setup() {
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:list) with no exposed ports, no linked apps" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:list"
+  run dokku --quiet "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "l     mongo:3.4.9  running  -              -"
+  assert_output "l"
-}
-
-@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
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:list) when there are no services" {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  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 >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }

tests/service_logs.bats

@@ -2,33 +2,41 @@
 load test_helper
 
 setup() {
-  export ECHO_DOCKER_COMMAND="false"
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
 }
 
 teardown() {
-  export ECHO_DOCKER_COMMAND="false"
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:logs) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:logs"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  echo "output: $output"
+  echo "status: $status"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
+  assert_failure
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:logs) error when service does not exist" {
   run dokku "$PLUGIN_COMMAND_PREFIX:logs" not_existing_service
+  echo "output: $output"
+  echo "status: $status"
   assert_contains "${lines[*]}" "service not_existing_service does not exist"
+  assert_failure
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:logs) success when not tailing" {
-  export ECHO_DOCKER_COMMAND="true"
+  skip "This may fail if there is no log output"
   run dokku "$PLUGIN_COMMAND_PREFIX:logs" l
-  assert_contains "docker logs --tail 100 testid"
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:logs) success when tailing" {
-  export ECHO_DOCKER_COMMAND="true"
+  skip "This will hang as it waits for log output"
   run dokku "$PLUGIN_COMMAND_PREFIX:logs" l -t
-  assert_contains "docker logs --follow testid"
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
 }

tests/service_promote.bats

@@ -2,20 +2,20 @@
 load test_helper
 
 setup() {
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
-  dokku apps:create my_app >&2
+  dokku apps:create my_app
   dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
 }
 
 teardown() {
   dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
-  rm -rf "$DOKKU_ROOT/my_app"
+  dokku --force apps:destroy my_app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:promote"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) error when the app argument is missing" {
@@ -39,7 +39,7 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) changes MONGO_URL" {
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  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)
@@ -47,14 +47,14 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) creates new config url when needed" {
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  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
   assert_contains "${lines[*]}" "DOKKU_MONGO_"
 }
 @test "($PLUGIN_COMMAND_PREFIX:promote) uses MONGO_DATABASE_SCHEME variable" {
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  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)

tests/service_restart.bats

@@ -2,16 +2,16 @@
 load test_helper
 
 setup() {
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:restart) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:restart"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:restart) error when service does not exist" {

tests/service_start.bats

@@ -2,16 +2,16 @@
 load test_helper
 
 setup() {
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:start) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:start"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:start) error when service does not exist" {

tests/service_stop.bats

@@ -2,16 +2,16 @@
 load test_helper
 
 setup() {
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:stop) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:stop"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:stop) error when service does not exist" {

tests/service_unexpose.bats

@@ -2,16 +2,16 @@
 load test_helper
 
 setup() {
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unexpose) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:unexpose"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unexpose) error when service does not exist" {

tests/service_unlink.bats

@@ -2,18 +2,18 @@
 load test_helper
 
 setup() {
-  dokku apps:create my_app >&2
+  dokku apps:create my_app
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
-  rm -rf "$DOKKU_ROOT/my_app"
+  dokku --force apps:destroy my_app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) error when there are no arguments" {
   run dokku "$PLUGIN_COMMAND_PREFIX:unlink"
-  assert_contains "${lines[*]}" "Please specify a name for the service"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) error when the app argument is missing" {
@@ -40,19 +40,8 @@ teardown() {
   dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app >&2
   dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
 
-  check_value=""
+  check_value="Docker options build: Docker options deploy: --restart=on-failure:10 Docker options run:"
-  report_action="docker-options"
+  options=$(dokku --quiet docker-options:report my_app | xargs)
-  if [[ "$(dokku version)" == "master" ]]; then
-    check_value="Docker options build: Docker options deploy: --restart=on-failure:10 Docker options run:"
-    report_action="docker-options:report"
-  elif [[ "$(at-least-version 0.8.1 "$(dokku version)")" == "true" ]]; then
-    check_value="Docker options build: Docker options deploy: --restart=on-failure:10 Docker options run:"
-    report_action="docker-options:report"
-  elif [[ "$(at-least-version 0.7.0 "$(dokku version)")" == "true" ]]; then
-    check_value="Deploy options: --restart=on-failure:10"
-  fi
-
-  options=$(dokku $report_action my_app | xargs)
   assert_equal "$options" "$check_value"
 }
 

tests/setup.sh

@@ -1,33 +1,30 @@
 #!/usr/bin/env bash
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+set -eo pipefail
-source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/test_helper.bash"
+[[ $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 -
 
-BIN_STUBS="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/bin"
+sudo mkdir -p /etc/nginx
+sudo curl https://raw.githubusercontent.com/dokku/dokku/master/tests/dhparam.pem -o /etc/nginx/dhparam.pem
 
-if [[ ! -d $DOKKU_ROOT ]]; then
+echo "dokku dokku/skip_key_file boolean true" | sudo debconf-set-selections
-  git clone https://github.com/progrium/dokku.git $DOKKU_ROOT > /dev/null
+wget https://raw.githubusercontent.com/dokku/dokku/master/bootstrap.sh
+if [[ "$DOKKU_VERSION" == "master" ]]; then
+  sudo bash bootstrap.sh
+else
+  sudo DOKKU_TAG="$DOKKU_VERSION" bash bootstrap.sh
 fi
-
-cd $DOKKU_ROOT
 echo "Dokku version $DOKKU_VERSION"
-git checkout $DOKKU_VERSION > /dev/null
-if grep go-build Makefile > /dev/null; then
-  mv "$BIN_STUBS/docker" "$BIN_STUBS/docker-stub"
-  make go-build
-  mv "$BIN_STUBS/docker-stub" "$BIN_STUBS/docker"
-fi
-cd -
 
+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"
-rm -rf $DOKKU_ROOT/plugins/$PLUGIN_COMMAND_PREFIX
+sudo rm -rf "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX"
-mkdir -p $DOKKU_ROOT/plugins/$PLUGIN_COMMAND_PREFIX $DOKKU_ROOT/plugins/$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"
-find ./ -maxdepth 1 -type f -exec cp '{}' $DOKKU_ROOT/plugins/$PLUGIN_COMMAND_PREFIX \;
+sudo find ./ -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" \;
-find ./subcommands -maxdepth 1 -type f -exec cp '{}' $DOKKU_ROOT/plugins/$PLUGIN_COMMAND_PREFIX/subcommands \;
+[[ -d "./scripts" ]] && sudo find ./scripts -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/scripts" \;
-echo "$DOKKU_VERSION" > $DOKKU_ROOT/VERSION
+[[ -d "./subcommands" ]] && sudo find ./subcommands -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" \;
-
+sudo mkdir -p "$PLUGIN_CONFIG_ROOT" "$PLUGIN_DATA_ROOT"
-if [[ ! -f $BIN_STUBS/plugn ]]; then
+sudo dokku plugin:enable "$PLUGIN_COMMAND_PREFIX"
-  wget -O- "$PLUGN_URL" | tar xzf - -C "$BIN_STUBS"
+sudo dokku plugin:install
-  plugn init
-  find "$DOKKU_ROOT/plugins" -mindepth 1 -maxdepth 1 -type d ! -name 'available' ! -name 'enabled' -exec ln -s {} "$DOKKU_ROOT/plugins/available" \;
-  find "$DOKKU_ROOT/plugins" -mindepth 1 -maxdepth 1 -type d ! -name 'available' ! -name 'enabled' -exec ln -s {} "$DOKKU_ROOT/plugins/enabled" \;
-fi

tests/shellcheck-exclude

@@ -0,0 +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

tests/shellcheck-to-junit

@@ -0,0 +1,205 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from __future__ import print_function
+import argparse
+import collections
+import datetime
+import re
+import socket
+import sys
+
+from xml.etree import ElementTree
+
+
+def CDATA(text=None):
+    element = ElementTree.Element('![CDATA[')
+    element.text = text
+    return element
+
+
+def _serialize_xml(write, elem, qnames, namespaces,short_empty_elements, **kwargs):
+
+    if elem.tag == '![CDATA[':
+        write("\n<{}{}]]>\n".format(elem.tag, elem.text))
+        if elem.tail:
+            write(ElementTree._escape_cdata(elem.tail))
+    else:
+        return ElementTree._original_serialize_xml(write, elem, qnames, namespaces,short_empty_elements, **kwargs)
+
+
+ElementTree._original_serialize_xml = ElementTree._serialize_xml
+ElementTree._serialize_xml = ElementTree._serialize['xml'] = _serialize_xml
+
+
+def read_in():
+    lines = sys.stdin.readlines()
+    for i in range(len(lines)):
+        lines[i] = lines[i].rstrip()
+    return lines
+
+
+def process_lines(lines):
+    files = {}
+    current_file = None
+    previous_line = None
+    line_no = None
+    new_issues = []
+    code = None
+
+    RE_VIOLATION = re.compile(r"\^-- (SC[\w]+): (.*)")
+    RE_VIOLATION_NEW = re.compile(r"\^[-]+\^ (SC[\w]+): (.*)")
+
+    for line in lines:
+        # start a new block
+        if line == '':
+            if current_file is not None:
+                file_data = files.get(current_file, {})
+                files[current_file] = file_data
+
+                issue_data = file_data.get(line_no, {})
+                issue_data['code'] = code
+                files[current_file][line_no] = issue_data
+
+                issues = issue_data.get('issues', [])
+                issues.extend(new_issues)
+                issue_data['issues'] = issues
+
+                files[current_file][line_no] = issue_data
+
+            code = None
+            current_file = None
+            line_no = None
+        elif line.startswith('In ./') and not previous_line:
+            current_file = line.split(' ')[1].replace('./', '')
+            line_no = line.split(' ')[3]
+            new_issues = []
+            code = None
+        elif code is None and len(new_issues) == 0:
+            code = line
+        else:
+            match = RE_VIOLATION.match(line.strip())
+            if not match:
+                match = RE_VIOLATION_NEW.match(line.strip())
+
+            if not match:
+                if 'https://www.shellcheck.net/wiki/SC' in line:
+                    continue
+                if 'For more information:' == line:
+                    continue
+                print('Error: Issue parsing line "{0}"'.format(line.strip()))
+            else:
+                new_issues.append({
+                    'shellcheck_id': match.group(1),
+                    'message': match.group(2),
+                    'original_message': line
+                })
+
+        previous_line = line
+
+    return files
+
+
+def output_junit(files, args):
+    timestamp = datetime.datetime.now().replace(microsecond=0).isoformat()
+    failures = 0
+    for file, data in files.items():
+        for line, issue_data in data.items():
+            code = issue_data.get('code')
+            for issue in issue_data.get('issues', []):
+                failures += 1
+
+    tests = 0
+    if args.files:
+        with open(args.files, 'r') as f:
+            tests = len(f.readlines())
+
+    root = ElementTree.Element("testsuite",
+                               name="shellcheck",
+                               tests="{0}".format(tests),
+                               failures="{0}".format(failures),
+                               errors="0",
+                               skipped="0",
+                               timestamp=timestamp,
+                               time="0",
+                               hostname=socket.gethostname())
+
+    properties = ElementTree.SubElement(root, "properties")
+    if args.exclude:
+        ElementTree.SubElement(properties,
+                               "property",
+                               name="exclude",
+                               value=args.exclude)
+
+    if args.files:
+        with open(args.files, 'r') as f:
+            lines = f.readlines()
+            for i in range(len(lines)):
+                file = lines[i].rstrip().replace('./', '')
+                data = files.get(file, None)
+                if data:
+                    for line, issue_data in data.items():
+                        code = issue_data.get('code')
+                        for issue in issue_data.get('issues', []):
+                            testcase = ElementTree.SubElement(root,
+                                                              "testcase",
+                                                              classname=file,
+                                                              name=file,
+                                                              time="0")
+                            shellcheck_id = issue.get('shellcheck_id')
+                            message = 'line {0}: {1}'.format(
+                              line, issue.get('message'))
+                            original_message = issue.get('original_message')
+                            e = ElementTree.Element("failure",
+                                                    type=shellcheck_id,
+                                                    message=message)
+                            cdata = CDATA("\n".join([code, original_message]))
+                            e.append(cdata)
+                            testcase.append(e)
+                ElementTree.SubElement(root,
+                                       "testcase",
+                                       classname=file,
+                                       name=file,
+                                       time="0")
+
+    ElementTree.SubElement(root, "system-out")
+    ElementTree.SubElement(root, "system-err")
+
+    content = ElementTree.tostring(root, encoding='UTF-8', method='xml')
+    if args.output:
+        with open(args.output, 'w') as f:
+            try:
+                f.write(content)
+            except TypeError:
+                f.write(content.decode("utf-8"))
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Process shellcheck output to junit.')
+    parser.add_argument('--output',
+                        dest='output',
+                        action='store',
+                        default=None,
+                        help='file to write shellcheck output')
+    parser.add_argument('--files',
+                        dest='files',
+                        action='store',
+                        default=None,
+                        help='a file containing a list of all files processed by shellcheck')
+    parser.add_argument('--exclude',
+                        dest='exclude',
+                        action='store',
+                        default=None,
+                        help='a comma-separated list of rules being excluded by shellcheck')
+    args = parser.parse_args()
+
+    lines = read_in()
+    files = process_lines(lines)
+    files = collections.OrderedDict(sorted(files.items()))
+    output_junit(files, args)
+    for line in lines:
+        print(line)
+
+
+if __name__ == '__main__':
+    main()

tests/test_helper.bash

@@ -1,32 +1,13 @@
 #!/usr/bin/env bash
-export DOKKU_QUIET_OUTPUT=1
+export DOKKU_LIB_ROOT="/var/lib/dokku"
-export DOKKU_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/dokku"
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-export DOKKU_VERSION=${DOKKU_VERSION:-"master"}
-export PATH="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/bin:$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/dokku:$PATH"
-export PLUGIN_COMMAND_PREFIX="mongo"
-export PLUGIN_PATH="$DOKKU_ROOT/plugins"
-export PLUGIN_ENABLED_PATH="$PLUGIN_PATH"
-export PLUGIN_AVAILABLE_PATH="$PLUGIN_PATH"
-export PLUGIN_CORE_AVAILABLE_PATH="$PLUGIN_PATH"
-export MONGO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/fixtures"
-export PLUGIN_DATA_ROOT="$MONGO_ROOT"
-export PLUGIN_CONFIG_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
-export DOKKU_LIB_PATH="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/lib-root"
-if [[ "$(uname)" == "Darwin" ]]; then
-  export PLUGN_URL="https://github.com/dokku/plugn/releases/download/v0.3.0/plugn_0.3.0_darwin_x86_64.tgz"
-else
-  export PLUGN_URL="https://github.com/dokku/plugn/releases/download/v0.3.0/plugn_0.3.0_linux_x86_64.tgz"
-fi
-
-mkdir -p "$PLUGIN_DATA_ROOT"
-rm -rf "${PLUGIN_DATA_ROOT:?}"/*
-
-mkdir -p "$PLUGIN_CONFIG_ROOT"
-rm -rf "${PLUGIN_CONFIG_ROOT:?}"/*
 
 flunk() {
-  { if [ "$#" -eq 0 ]; then cat -
+  {
-    else echo "$*"
+    if [ "$#" -eq 0 ]; then
+      cat -
+    else
+      echo "$*"
     fi
   }
   return 1
@@ -34,16 +15,22 @@ flunk() {
 
 assert_equal() {
   if [ "$1" != "$2" ]; then
-    { echo "expected: $1"
+    {
+      echo "expected: $1"
       echo "actual:   $2"
     } | flunk
   fi
 }
 
+# ShellCheck doesn't know about $status from Bats
+# shellcheck disable=SC2154
 assert_exit_status() {
-  assert_equal "$status" "$1"
+  assert_equal "$1" "$status"
 }
 
+# ShellCheck doesn't know about $status from Bats
+# shellcheck disable=SC2154
+# shellcheck disable=SC2120
 assert_success() {
   if [ "$status" -ne 0 ]; then
     flunk "command failed with exit status $status"
@@ -72,10 +59,14 @@ assert_contains() {
   fi
 }
 
+# ShellCheck doesn't know about $output from Bats
+# shellcheck disable=SC2154
 assert_output() {
   local expected
-  if [ $# -eq 0 ]; then expected="$(cat -)"
+  if [ $# -eq 0 ]; then
-  else expected="$1"
+    expected="$(cat -)"
+  else
+    expected="$1"
   fi
   assert_equal "$expected" "$output"
 }