Release 1.32.2

chore(deps): bump redis from 7.0.9 to 7.0.10

.devcontainer/20_init_plugin

@@ -0,0 +1,24 @@
+#!/bin/bash
+set -eo pipefail
+
+log-info() {
+  declare desc="Log info formatter"
+  echo "    $*" 1>&2
+}
+
+log-fail() {
+  declare desc="Log fail formatter"
+  echo "!   $*" 1>&2
+  exit 1
+}
+
+main() {
+  dokku plugin:install
+
+  # built in the Dockerfile
+  PLUGIN_NAME="$(source /tmp/.env && echo "$PLUGIN_NAME")"
+  PLUGIN_VARIABLE="$(source /tmp/.env && echo "$PLUGIN_VARIABLE")"
+  echo "export ${PLUGIN_VARIABLE}_HOST_ROOT=${SERVICE_HOST_ROOT}/$PLUGIN_NAME" >/etc/default/dokku
+}
+
+main "$@"

.devcontainer/Dockerfile

@@ -0,0 +1,26 @@
+FROM dokku/dokku:latest
+
+RUN apt-get update
+RUN apt-get install --no-install-recommends -y build-essential file nano && \
+  apt-get clean autoclean && \
+  apt-get autoremove --yes && \
+  rm -rf /var/lib/apt/lists/* && \
+  mkdir -p /mnt/dokku/home/dokku /mnt/dokku/var/lib/dokku/config /mnt/dokku/var/lib/dokku/data /mnt/dokku/var/lib/dokku/services && \
+  chown -R dokku:dokku /mnt/dokku/home/dokku /mnt/dokku/var/lib/dokku/config /mnt/dokku/var/lib/dokku/data /mnt/dokku/var/lib/dokku/services && \
+  echo "dokku.me" > /home/dokku/VHOST
+
+ADD https://raw.githubusercontent.com/dokku/dokku/master/tests/dhparam.pem /mnt/dokku/etc/nginx/dhparam.pem
+
+COPY .devcontainer/20_init_plugin /etc/my_init.d/20_init_plugin
+COPY .devcontainer/bin/ /usr/local/bin/
+
+COPY . .
+
+RUN source /tmp/config && \
+  echo "export ${PLUGIN_DISABLE_PULL_VARIABLE}=true" > /tmp/.env && \
+  echo "export PLUGIN_NAME=${PLUGIN_COMMAND_PREFIX}" >> /tmp/.env && \
+  echo "export PLUGIN_VARIABLE=${PLUGIN_VARIABLE}" >> /tmp/.env
+
+RUN source /tmp/.env && \
+  dokku plugin:install file:///tmp --name $PLUGIN_NAME && \
+  make ci-dependencies

.devcontainer/bin/copy-file

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+main() {
+  PLUGIN_NAME="$(source /tmp/.env && echo "$PLUGIN_NAME")"
+  cp "$1" "/var/lib/dokku/plugins/enabled/$PLUGIN_NAME/$1"
+}
+
+main "$@"

.devcontainer/devcontainer.json

@@ -0,0 +1,16 @@
+{
+  "build": {
+    "dockerfile": "Dockerfile",
+    "context": ".."
+  },
+  "containerEnv": {
+    "SERVICE_HOST_ROOT": "${localWorkspaceFolder}/tmp/data"
+  },
+  "initializeCommand": ["mkdir", "-p", "tmp/data"],
+  "mounts": [
+    "source=/var/run/docker.sock,target=/var/run/docker.sock,type=bind",
+    "source=${localWorkspaceFolder}/tmp/data/,target=/var/lib/dokku/services/,type=bind"
+  ],
+  "overrideCommand": false,
+  "runArgs": ["--init"]
+}

.github/dependabot.yml

@@ -0,0 +1,12 @@
+---
+version: 2
+updates:
+  - package-ecosystem: "docker"
+    directory: "/"
+    schedule:
+      interval: "daily"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: daily
+    open-pull-requests-limit: 10

.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

.github/workflows/ci.yml

@@ -0,0 +1,100 @@
+---
+name: CI
+
+# yamllint disable-line rule:truthy
+on:
+  pull_request:
+    branches:
+      - '*'
+  push:
+    branches:
+      - master
+
+concurrency:
+  group: build-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  unit-tests-master:
+    name: unit-tests
+    runs-on: ubuntu-20.04
+    env:
+      DOKKU_VERSION: master
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.7.x'
+
+      - run: make setup
+
+      - run: sudo sysctl -w vm.max_map_count=262144
+
+      - run: |
+          git fetch -q origin master
+          changed=$(git --no-pager diff --name-only $GITHUB_SHA..origin/master)
+          if [ $changed = "Dockerfile" ]; then
+            echo "Please run 'make generate' to update the image version in the README.md"
+          else
+            make generate
+            if ! git diff --quiet README.md; then
+              echo "Please run 'make generate'"
+              git status --short
+              git --no-pager diff README.md
+              exit 1
+            fi
+          fi
+
+      - run: make test
+
+      - uses: actions/upload-artifact@v3
+        if: failure()
+        with:
+          name: tmp/test-results
+          path: test-results
+
+  unit-tests-0_19_0:
+    name: unit-tests-0.19.0
+    runs-on: ubuntu-20.04
+    env:
+      DOKKU_TAG: v0.19.0
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.7.x'
+
+      - run: make setup
+
+      - run: sudo sysctl -w vm.max_map_count=262144
+
+      - run: |
+          git fetch -q origin master
+          changed=$(git --no-pager diff --name-only $GITHUB_SHA..origin/master)
+          if [ $changed = "Dockerfile" ]; then
+            echo "Please run 'make generate' to update the image version in the README.md"
+          else
+            make generate
+            if ! git diff --quiet README.md; then
+              echo "Please run 'make generate'"
+              git status --short
+              git --no-pager diff README.md
+              exit 1
+            fi
+          fi
+
+      - run: make test
+
+      - uses: actions/upload-artifact@v3
+        if: failure()
+        with:
+          name: tmp/test-results
+          path: test-results

.github/workflows/tagged-release.yml

@@ -0,0 +1,19 @@
+---
+name: "tagged-release"
+
+# yamllint disable-line rule:truthy
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  tagged-release:
+    name: tagged-release
+    runs-on: ubuntu-20.04
+
+    steps:
+      - uses: "marvinpinto/action-automatic-releases@v1.2.1"
+        with:
+          repo_token: "${{ secrets.GITHUB_TOKEN }}"
+          prerelease: false

.gitignore

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

.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

Dockerfile

@@ -0,0 +1 @@
+FROM redis:7.0.10

LICENSE.txt

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

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/bats-core/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)
-ifeq ($(shell uname),Darwin)
+ifneq ($(shell shellcheck --version >/dev/null 2>&1 ; echo $$?),0)
+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:
-ifeq ($(shell bats > /dev/null 2>&1 ; echo $$?),127)
-ifeq ($(shell uname),Darwin)
-	git clone https://github.com/sstephenson/bats.git /tmp/bats
-	cd /tmp/bats && sudo ./install.sh /usr/local
-	rm -rf /tmp/bats
+shfmt:
+ifneq ($(shell shfmt --version >/dev/null 2>&1 ; echo $$?),0)
+ifeq ($(shfmt),Darwin)
+	brew install shfmt
 else
-	sudo add-apt-repository ppa:duggan/bats --yes
-	sudo apt-get update -qq && sudo apt-get install -qq -y bats
+	wget -qO /tmp/shfmt https://github.com/mvdan/sh/releases/download/v$(SHFMT_VERSION)/shfmt_v$(SHFMT_VERSION)_linux_amd64
+	chmod +x /tmp/shfmt
+	sudo mv /tmp/shfmt /usr/local/bin/shfmt
 endif
 endif
 
@@ -30,20 +48,46 @@ 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.
-	# SC2034: Variable appears unused. Verify it or export it.
-	# SC2155: Declare and assign separately to avoid masking return values.
+	@cat tests/shellcheck-exclude | sed -n -e '/^# SC/p'
 	@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 --report-formatter junit --timing -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
 
 setup:
 	bash tests/setup.sh
 	$(MAKE) ci-dependencies
 
-test: setup lint unit-tests
+test: lint unit-tests
+
+report: tmp/xunit-reader
+	tmp/xunit-reader -p 'tmp/test-results/bats/*.xml'
+	tmp/xunit-reader -p 'tmp/test-results/shellcheck/*.xml'
+
+.PHONY: clean
+clean:
+	rm -f README.md
+
+.PHONY: generate
+generate: clean README.md
+
+.PHONY: README.md
+README.md:
+	bin/generate

README.md

@@ -1,235 +1,746 @@
-# dokku redis [![Build Status](https://img.shields.io/travis/dokku/dokku-redis.svg?branch=master "Build Status")](https://travis-ci.org/dokku/dokku-redis) [![IRC Network](https://img.shields.io/badge/irc-freenode-blue.svg "IRC Freenode")](https://webchat.freenode.net/?channels=dokku)
+# dokku redis [![Build Status](https://img.shields.io/github/actions/workflow/status/dokku/dokku-redis/ci.yml?branch=master&style=flat-square "Build Status")](https://github.com/dokku/dokku-redis/actions/workflows/ci.yml?query=branch%3Amaster) [![IRC Network](https://img.shields.io/badge/irc-libera-blue.svg?style=flat-square "IRC Libera")](https://webchat.libera.chat/?channels=dokku)
 
-Official redis plugin for dokku. Currently defaults to installing [redis 4.0.11](https://hub.docker.com/_/redis/).
+Official redis plugin for dokku. Currently defaults to installing [redis 7.0.9](https://hub.docker.com/_/redis/).
 
-## requirements
+## Requirements
 
-- dokku 0.4.x+
+- dokku 0.19.x+
 - docker 1.8.x
 
-## installation
+## Installation
 
 ```shell
-# on 0.4.x+
+# on 0.19.x+
 sudo dokku plugin:install https://github.com/dokku/dokku-redis.git redis
 ```
 
-## commands
+## Commands
 
 ```
-redis:app-links <app>          List all redis service links for a given app
-redis:backup <name> <bucket> (--use-iam) Create a backup of the redis service to an existing s3 bucket
-redis:backup-auth <name> <aws_access_key_id> <aws_secret_access_key> (<aws_default_region>) (<aws_signature_version>) (<endpoint_url>) Sets up authentication for backups on the redis service
-redis:backup-deauth <name>     Removes backup authentication for the redis service
-redis:backup-schedule <name> <schedule> <bucket> Schedules a backup of the redis service
-redis:backup-schedule-cat <name> Cat the contents of the configured backup cronfile for the service
-redis:backup-set-encryption <name> <encryption_key> Sets up GPG encryption for future backups of the redis service
-redis:backup-unschedule <name> Unschedules the backup of the redis service
-redis:backup-unset-encryption <name> Removes backup encryption for future backups of the redis service
-redis:clone <name> <new-name>  Create container <new-name> then copy data from <name> into <new-name>
-redis:connect <name>           Connect via redis-cli to a redis service
-redis:create <name>            Create a redis service with environment variables
-redis:destroy <name>           Delete the service, delete the data and stop its container if there are no links left
-redis:enter <name> [command]   Enter or run a command in a running redis service container
-redis:exists <service>         Check if the redis service exists
-redis:export <name> > <file>   Export a dump of the redis service database
-redis:expose <name> [port]     Expose a redis service on custom port if provided (random port otherwise)
-redis:import <name> <file>     Import a dump into the redis service database
-redis:info <name>              Print the connection information
-redis:link <name> <app>        Link the redis service to the app
-redis:linked <name> <app>      Check if the redis service is linked to an app
-redis:list                     List all redis services
-redis:logs <name> [-t]         Print the most recent log(s) for this service
-redis:promote <name> <app>     Promote service <name> as REDIS_URL in <app>
-redis:restart <name>           Graceful shutdown and restart of the redis service container
-redis:start <name>             Start a previously stopped redis service
-redis:stop <name>              Stop a running redis service
-redis:unexpose <name>          Unexpose a previously exposed redis service
-redis:unlink <name> <app>      Unlink the redis service from the app
-redis:upgrade <name>           Upgrade service <service> to the specified version
+redis:app-links <app>                              # list all redis service links for a given app
+redis:backup <service> <bucket-name> [--use-iam]   # create a backup of the redis service to an existing s3 bucket
+redis:backup-auth <service> <aws-access-key-id> <aws-secret-access-key> <aws-default-region> <aws-signature-version> <endpoint-url> # set up authentication for backups on the redis service
+redis:backup-deauth <service>                      # remove backup authentication for the redis service
+redis:backup-schedule <service> <schedule> <bucket-name> [--use-iam] # schedule a backup of the redis service
+redis:backup-schedule-cat <service>                # cat the contents of the configured backup cronfile for the service
+redis:backup-set-encryption <service> <passphrase> # set encryption for all future backups of redis service
+redis:backup-unschedule <service>                  # unschedule the backup of the redis service
+redis:backup-unset-encryption <service>            # unset encryption for future backups of the redis service
+redis:clone <service> <new-service> [--clone-flags...] # create container <new-name> then copy data from <name> into <new-name>
+redis:connect <service>                            # connect to the service via the redis connection tool
+redis:create <service> [--create-flags...]         # create a redis service
+redis:destroy <service> [-f|--force]               # delete the redis service/data/container if there are no links left
+redis:enter <service>                              # enter or run a command in a running redis service container
+redis:exists <service>                             # check if the redis service exists
+redis:export <service>                             # export a dump of the redis service database
+redis:expose <service> <ports...>                  # expose a redis service on custom host:port if provided (random port on the 0.0.0.0 interface if otherwise unspecified)
+redis:import <service>                             # import a dump into the redis service database
+redis:info <service> [--single-info-flag]          # print the service information
+redis:link <service> <app> [--link-flags...]       # link the redis service to the app
+redis:linked <service> <app>                       # check if the redis service is linked to an app
+redis:links <service>                              # list all apps linked to the redis service
+redis:list                                         # list all redis services
+redis:logs <service> [-t|--tail] <tail-num-optional> # print the most recent log(s) for this service
+redis:pause <service>                              # pause a running redis service
+redis:promote <service> <app>                      # promote service <service> as REDIS_URL in <app>
+redis:restart <service>                            # graceful shutdown and restart of the redis service container
+redis:set <service> <key> <value>                  # set or clear a property for a service
+redis:start <service>                              # start a previously stopped redis service
+redis:stop <service>                               # stop a running redis service
+redis:unexpose <service>                           # unexpose a previously exposed redis service
+redis:unlink <service> <app>                       # unlink the redis service from the app
+redis:upgrade <service> [--upgrade-flags...]       # upgrade service <service> to the specified versions
 ```
 
-## usage
+## Usage
+
+Help for any commands can be displayed by specifying the command as an argument to redis:help. Plugin help output in conjunction with any files in the `docs/` folder is used to generate the plugin documentation. Please consult the `redis:help` command for any undocumented commands.
+
+### Basic Usage
+
+### create a redis service
 
 ```shell
-# create a redis service named lolipop
-dokku redis:create lolipop
+# usage
+dokku redis:create <service> [--create-flags...]
+```
 
-# you can also specify the image and image
-# version to use for the service
-# it *must* be compatible with the
-# official redis image
+flags:
+
+- `-c|--config-options "--args --go=here"`: extra arguments to pass to the container create command (default: `None`)
+- `-C|--custom-env "USER=alpha;HOST=beta"`: semi-colon delimited environment variables to start the service with
+- `-i|--image IMAGE`: the image name to start the service with
+- `-I|--image-version IMAGE_VERSION`: the image version to start the service with
+- `-m|--memory MEMORY`: container memory limit in megabytes (default: unlimited)
+- `-N|--initial-network INITIAL_NETWORK`: the initial network to attach the service to
+- `-p|--password PASSWORD`: override the user-level service password
+- `-P|--post-create-network NETWORKS`: a comman-separated list of networks to attach the service container to after service creation
+- `-r|--root-password PASSWORD`: override the root-level service password
+- `-S|--post-start-network NETWORKS`: a comman-separated list of networks to attach the service container to after service start
+- `-s|--shm-size SHM_SIZE`: override shared memory size for redis docker container
+
+Create a redis service named lollipop:
+
+```shell
+dokku redis:create lollipop
+```
+
+You can also specify the image and image version to use for the service. It *must* be compatible with the redis image.
+
+```shell
 export REDIS_IMAGE="redis"
-export REDIS_IMAGE_VERSION="2.8.21"
-dokku redis:create lolipop
+export REDIS_IMAGE_VERSION="${PLUGIN_IMAGE_VERSION}"
+dokku redis:create lollipop
+```
 
-# you can also specify custom environment
-# variables to start the redis service
-# in semi-colon separated form
+You can also specify custom environment variables to start the redis service in semi-colon separated form.
+
+```shell
 export REDIS_CUSTOM_ENV="USER=alpha;HOST=beta"
-dokku redis:create lolipop
+dokku redis:create lollipop
+```
 
-# get connection information as follows
-dokku redis:info lolipop
+### print the service information
 
-# you can also retrieve a specific piece of service info via flags
-dokku redis:info lolipop --config-dir
-dokku redis:info lolipop --data-dir
-dokku redis:info lolipop --dsn
-dokku redis:info lolipop --exposed-ports
-dokku redis:info lolipop --id
-dokku redis:info lolipop --internal-ip
-dokku redis:info lolipop --links
-dokku redis:info lolipop --service-root
-dokku redis:info lolipop --status
-dokku redis:info lolipop --version
+```shell
+# usage
+dokku redis:info <service> [--single-info-flag]
+```
 
-# a bash prompt can be opened against a running service
-# filesystem changes will not be saved to disk
-dokku redis:enter lolipop
+flags:
 
-# you may also run a command directly against the service
-# filesystem changes will not be saved to disk
-dokku redis:enter lolipop ls -lah /
+- `--config-dir`: show the service configuration directory
+- `--data-dir`: show the service data directory
+- `--dsn`: show the service DSN
+- `--exposed-ports`: show service exposed ports
+- `--id`: show the service container id
+- `--internal-ip`: show the service internal ip
+- `--initial-network`: show the initial network being connected to
+- `--links`: show the service app links
+- `--post-create-network`: show the networks to attach to after service container creation
+- `--post-start-network`: show the networks to attach to after service container start
+- `--service-root`: show the service root directory
+- `--status`: show the service running status
+- `--version`: show the service image version
 
-# a redis service can be linked to a
-# container this will use native docker
-# links via the docker-options plugin
-# here we link it to our 'playground' app
-# NOTE: this will restart your app
-dokku redis:link lolipop playground
+Get connection information as follows:
 
-# the following environment variables will be set automatically by docker (not
-# on the app itself, so they won’t be listed when calling dokku config)
-#
-#   DOKKU_REDIS_LOLIPOP_NAME=/lolipop/DATABASE
-#   DOKKU_REDIS_LOLIPOP_PORT=tcp://172.17.0.1:6379
-#   DOKKU_REDIS_LOLIPOP_PORT_6379_TCP=tcp://172.17.0.1:6379
-#   DOKKU_REDIS_LOLIPOP_PORT_6379_TCP_PROTO=tcp
-#   DOKKU_REDIS_LOLIPOP_PORT_6379_TCP_PORT=6379
-#   DOKKU_REDIS_LOLIPOP_PORT_6379_TCP_ADDR=172.17.0.1
-#
-# and the following will be set on the linked application by default
-#
-#   REDIS_URL=redis://lolipop:SOME_PASSWORD@dokku-redis-lolipop:6379
-#
-# NOTE: the host exposed here only works internally in docker containers. If
-# you want your container to be reachable from outside, you should use `expose`.
+```shell
+dokku redis:info lollipop
+```
 
-# another service can be linked to your app
+You can also retrieve a specific piece of service info via flags:
+
+```shell
+dokku redis:info lollipop --config-dir
+dokku redis:info lollipop --data-dir
+dokku redis:info lollipop --dsn
+dokku redis:info lollipop --exposed-ports
+dokku redis:info lollipop --id
+dokku redis:info lollipop --internal-ip
+dokku redis:info lollipop --initial-network
+dokku redis:info lollipop --links
+dokku redis:info lollipop --post-create-network
+dokku redis:info lollipop --post-start-network
+dokku redis:info lollipop --service-root
+dokku redis:info lollipop --status
+dokku redis:info lollipop --version
+```
+
+### list all redis services
+
+```shell
+# usage
+dokku redis:list 
+```
+
+List all services:
+
+```shell
+dokku redis:list
+```
+
+### print the most recent log(s) for this service
+
+```shell
+# usage
+dokku redis:logs <service> [-t|--tail] <tail-num-optional>
+```
+
+flags:
+
+- `-t|--tail [<tail-num>]`: do not stop when end of the logs are reached and wait for additional output
+
+You can tail logs for a particular service:
+
+```shell
+dokku redis:logs lollipop
+```
+
+By default, logs will not be tailed, but you can do this with the --tail flag:
+
+```shell
+dokku redis:logs lollipop --tail
+```
+
+The default tail setting is to show all logs, but an initial count can also be specified:
+
+```shell
+dokku redis:logs lollipop --tail 5
+```
+
+### link the redis service to the app
+
+```shell
+# usage
+dokku redis:link <service> <app> [--link-flags...]
+```
+
+flags:
+
+- `-a|--alias "BLUE_DATABASE"`: an alternative alias to use for linking to an app via environment variable
+- `-q|--querystring "pool=5"`: ampersand delimited querystring arguments to append to the service link
+- `-n|--no-restart "false"`: whether or not to restart the app on link (default: true)
+
+A redis service can be linked to a container. This will use native docker links via the docker-options plugin. Here we link it to our `playground` app.
+
+> NOTE: this will restart your app
+
+```shell
+dokku redis:link lollipop playground
+```
+
+The following environment variables will be set automatically by docker (not on the app itself, so they won’t be listed when calling dokku config):
+
+```
+DOKKU_REDIS_LOLLIPOP_NAME=/lollipop/DATABASE
+DOKKU_REDIS_LOLLIPOP_PORT=tcp://172.17.0.1:6379
+DOKKU_REDIS_LOLLIPOP_PORT_6379_TCP=tcp://172.17.0.1:6379
+DOKKU_REDIS_LOLLIPOP_PORT_6379_TCP_PROTO=tcp
+DOKKU_REDIS_LOLLIPOP_PORT_6379_TCP_PORT=6379
+DOKKU_REDIS_LOLLIPOP_PORT_6379_TCP_ADDR=172.17.0.1
+```
+
+The following will be set on the linked application by default:
+
+```
+REDIS_URL=redis://:SOME_PASSWORD@dokku-redis-lollipop:6379
+```
+
+The host exposed here only works internally in docker containers. If you want your container to be reachable from outside, you should use the `expose` subcommand. Another service can be linked to your app:
+
+```shell
 dokku redis:link other_service playground
-
-# since REDIS_URL is already in use, another environment variable will be
-# generated automatically
-#
-#   DOKKU_REDIS_BLUE_URL=redis://other_service:ANOTHER_PASSWORD@dokku-redis-other-service:6379
-
-# you can then promote the new service to be the primary one
-# NOTE: this will restart your app
-dokku redis:promote other_service playground
-
-# this will replace REDIS_URL with the url from other_service and generate
-# another environment variable to hold the previous value if necessary.
-# you could end up with the following for example:
-#
-#   REDIS_URL=redis://other_service:ANOTHER_PASSWORD@dokku-redis-other-service:6379
-#   DOKKU_REDIS_BLUE_URL=redis://other_service:ANOTHER_PASSWORD@dokku-redis-other-service:6379
-#   DOKKU_REDIS_SILVER_URL=redis://lolipop:SOME_PASSWORD@dokku-redis-lolipop:6379/lolipop
-
-# you can also unlink a redis service
-# NOTE: this will restart your app and unset related environment variables
-dokku redis:unlink lolipop playground
-
-# you can tail logs for a particular service
-dokku redis:logs lolipop
-dokku redis:logs lolipop -t # to tail
-
-# you can dump the database
-dokku redis:export lolipop > lolipop.rdb
-
-# you can import a dump
-dokku redis:import lolipop < database.rdb
-
-# you can clone an existing database to a new one
-dokku redis:clone lolipop new_database
-
-# finally, you can destroy the container
-dokku redis:destroy lolipop
 ```
 
-## Changing database adapter
+It is possible to change the protocol for `REDIS_URL` by setting the environment variable `REDIS_DATABASE_SCHEME` on the app. Doing so will after linking will cause the plugin to think the service is not linked, and we advise you to unlink before proceeding.
 
-It's possible to change the protocol for REDIS_URL by setting
-the environment variable REDIS_DATABASE_SCHEME on the app:
-
-```
+```shell
 dokku config:set playground REDIS_DATABASE_SCHEME=redis2
-dokku redis:link lolipop playground
+dokku redis:link lollipop playground
 ```
 
-Will cause REDIS_URL to be set as
-redis2://lolipop:SOME_PASSWORD@dokku-redis-lolipop:6379/lolipop
+This will cause `REDIS_URL` to be set as:
 
-CAUTION: Changing REDIS_DATABASE_SCHEME after linking will cause dokku to
-believe the redis is not linked when attempting to use `dokku redis:unlink`
-or `dokku redis:promote`.
-You should be able to fix this by
+```
+redis2://:SOME_PASSWORD@dokku-redis-lollipop:6379
+```
 
-- Changing REDIS_URL manually to the new value.
+### unlink the redis service from the app
 
-OR
+```shell
+# usage
+dokku redis:unlink <service> <app>
+```
 
-- Set REDIS_DATABASE_SCHEME back to its original setting
-- Unlink the service
-- Change REDIS_DATABASE_SCHEME to the desired setting
-- Relink the service
+flags:
 
-## Backups
+- `-n|--no-restart "false"`: whether or not to restart the app on unlink (default: true)
+
+You can unlink a redis service:
+
+> NOTE: this will restart your app and unset related environment variables
+
+```shell
+dokku redis:unlink lollipop playground
+```
+
+### set or clear a property for a service
+
+```shell
+# usage
+dokku redis:set <service> <key> <value>
+```
+
+Set the network to attach after the service container is started:
+
+```shell
+dokku redis:set lollipop post-create-network custom-network
+```
+
+Set multiple networks:
+
+```shell
+dokku redis:set lollipop post-create-network custom-network,other-network
+```
+
+Unset the post-create-network value:
+
+```shell
+dokku redis:set lollipop post-create-network
+```
+
+### Service Lifecycle
+
+The lifecycle of each service can be managed through the following commands:
+
+### connect to the service via the redis connection tool
+
+```shell
+# usage
+dokku redis:connect <service>
+```
+
+Connect to the service via the redis connection tool:
+
+> NOTE: disconnecting from ssh while running this command may leave zombie processes due to moby/moby#9098
+
+```shell
+dokku redis:connect lollipop
+```
+
+### enter or run a command in a running redis service container
+
+```shell
+# usage
+dokku redis:enter <service>
+```
+
+A bash prompt can be opened against a running service. Filesystem changes will not be saved to disk.
+
+> NOTE: disconnecting from ssh while running this command may leave zombie processes due to moby/moby#9098
+
+```shell
+dokku redis:enter lollipop
+```
+
+You may also run a command directly against the service. Filesystem changes will not be saved to disk.
+
+```shell
+dokku redis:enter lollipop touch /tmp/test
+```
+
+### expose a redis service on custom host:port if provided (random port on the 0.0.0.0 interface if otherwise unspecified)
+
+```shell
+# usage
+dokku redis:expose <service> <ports...>
+```
+
+Expose the service on the service's normal ports, allowing access to it from the public interface (`0.0.0.0`):
+
+```shell
+dokku redis:expose lollipop 6379
+```
+
+Expose the service on the service's normal ports, with the first on a specified ip adddress (127.0.0.1):
+
+```shell
+dokku redis:expose lollipop 127.0.0.1:6379
+```
+
+### unexpose a previously exposed redis service
+
+```shell
+# usage
+dokku redis:unexpose <service>
+```
+
+Unexpose the service, removing access to it from the public interface (`0.0.0.0`):
+
+```shell
+dokku redis:unexpose lollipop
+```
+
+### promote service <service> as REDIS_URL in <app>
+
+```shell
+# usage
+dokku redis:promote <service> <app>
+```
+
+If you have a redis service linked to an app and try to link another redis service another link environment variable will be generated automatically:
+
+```
+DOKKU_REDIS_BLUE_URL=redis://:ANOTHER_PASSWORD@dokku-redis-other-service:6379/other_service
+```
+
+You can promote the new service to be the primary one:
+
+> NOTE: this will restart your app
+
+```shell
+dokku redis:promote other_service playground
+```
+
+This will replace `REDIS_URL` with the url from other_service and generate another environment variable to hold the previous value if necessary. You could end up with the following for example:
+
+```
+REDIS_URL=redis://:ANOTHER_PASSWORD@dokku-redis-other-service:6379/other_service
+DOKKU_REDIS_BLUE_URL=redis://:ANOTHER_PASSWORD@dokku-redis-other-service:6379/other_service
+DOKKU_REDIS_SILVER_URL=redis://:SOME_PASSWORD@dokku-redis-lollipop:6379/lollipop
+```
+
+### start a previously stopped redis service
+
+```shell
+# usage
+dokku redis:start <service>
+```
+
+Start the service:
+
+```shell
+dokku redis:start lollipop
+```
+
+### stop a running redis service
+
+```shell
+# usage
+dokku redis:stop <service>
+```
+
+Stop the service and removes the running container:
+
+```shell
+dokku redis:stop lollipop
+```
+
+### pause a running redis service
+
+```shell
+# usage
+dokku redis:pause <service>
+```
+
+Pause the running container for the service:
+
+```shell
+dokku redis:pause lollipop
+```
+
+### graceful shutdown and restart of the redis service container
+
+```shell
+# usage
+dokku redis:restart <service>
+```
+
+Restart the service:
+
+```shell
+dokku redis:restart lollipop
+```
+
+### upgrade service <service> to the specified versions
+
+```shell
+# usage
+dokku redis:upgrade <service> [--upgrade-flags...]
+```
+
+flags:
+
+- `-c|--config-options "--args --go=here"`: extra arguments to pass to the container create command (default: `None`)
+- `-C|--custom-env "USER=alpha;HOST=beta"`: semi-colon delimited environment variables to start the service with
+- `-i|--image IMAGE`: the image name to start the service with
+- `-I|--image-version IMAGE_VERSION`: the image version to start the service with
+- `-N|--initial-network INITIAL_NETWORK`: the initial network to attach the service to
+- `-P|--post-create-network NETWORKS`: a comman-separated list of networks to attach the service container to after service creation
+- `-R|--restart-apps "true"`: whether or not to force an app restart (default: false)
+- `-S|--post-start-network NETWORKS`: a comman-separated list of networks to attach the service container to after service start
+- `-s|--shm-size SHM_SIZE`: override shared memory size for redis docker container
+
+You can upgrade an existing service to a new image or image-version:
+
+```shell
+dokku redis:upgrade lollipop
+```
+
+### Service Automation
+
+Service scripting can be executed using the following commands:
+
+### list all redis service links for a given app
+
+```shell
+# usage
+dokku redis:app-links <app>
+```
+
+List all redis services that are linked to the `playground` app.
+
+```shell
+dokku redis:app-links playground
+```
+
+### create container <new-name> then copy data from <name> into <new-name>
+
+```shell
+# usage
+dokku redis:clone <service> <new-service> [--clone-flags...]
+```
+
+flags:
+
+- `-c|--config-options "--args --go=here"`: extra arguments to pass to the container create command (default: `None`)
+- `-C|--custom-env "USER=alpha;HOST=beta"`: semi-colon delimited environment variables to start the service with
+- `-i|--image IMAGE`: the image name to start the service with
+- `-I|--image-version IMAGE_VERSION`: the image version to start the service with
+- `-m|--memory MEMORY`: container memory limit in megabytes (default: unlimited)
+- `-N|--initial-network INITIAL_NETWORK`: the initial network to attach the service to
+- `-p|--password PASSWORD`: override the user-level service password
+- `-P|--post-create-network NETWORKS`: a comman-separated list of networks to attach the service container to after service creation
+- `-r|--root-password PASSWORD`: override the root-level service password
+- `-S|--post-start-network NETWORKS`: a comman-separated list of networks to attach the service container to after service start
+- `-s|--shm-size SHM_SIZE`: override shared memory size for redis docker container
+
+You can clone an existing service to a new one:
+
+```shell
+dokku redis:clone lollipop lollipop-2
+```
+
+### check if the redis service exists
+
+```shell
+# usage
+dokku redis:exists <service>
+```
+
+Here we check if the lollipop redis service exists.
+
+```shell
+dokku redis:exists lollipop
+```
+
+### check if the redis service is linked to an app
+
+```shell
+# usage
+dokku redis:linked <service> <app>
+```
+
+Here we check if the lollipop redis service is linked to the `playground` app.
+
+```shell
+dokku redis:linked lollipop playground
+```
+
+### list all apps linked to the redis service
+
+```shell
+# usage
+dokku redis:links <service>
+```
+
+List all apps linked to the `lollipop` redis service.
+
+```shell
+dokku redis:links lollipop
+```
+
+### Data Management
+
+The underlying service data can be imported and exported with the following commands:
+
+### import a dump into the redis service database
+
+```shell
+# usage
+dokku redis:import <service>
+```
+
+Import a datastore dump:
+
+```shell
+dokku redis:import lollipop < data.dump
+```
+
+### export a dump of the redis service database
+
+```shell
+# usage
+dokku redis:export <service>
+```
+
+By default, datastore output is exported to stdout:
+
+```shell
+dokku redis:export lollipop
+```
+
+You can redirect this output to a file:
+
+```shell
+dokku redis:export lollipop > data.dump
+```
+
+### Backups
 
 Datastore backups are supported via AWS S3 and S3 compatible services like [minio](https://github.com/minio/minio).
 
-You may skip the `backup-auth` step if your dokku install is running within EC2
-and has access to the bucket via an IAM profile. In that case, use the `--use-iam`
-option with the `backup` command.
+You may skip the `backup-auth` step if your dokku install is running within EC2 and has access to the bucket via an IAM profile. In that case, use the `--use-iam` option with the `backup` command.
 
 Backups can be performed using the backup commands:
 
-```
-# setup s3 backup authentication
-dokku redis:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY
+### set up authentication for backups on the redis service
 
-# remove s3 authentication
-dokku redis:backup-deauth lolipop
-
-# backup the `lolipop` service to the `BUCKET_NAME` bucket on AWS
-dokku redis:backup lolipop BUCKET_NAME
-
-# schedule a backup
-# CRON_SCHEDULE is a crontab expression, eg. "0 3 * * *" for each day at 3am
-dokku redis:backup-schedule lolipop CRON_SCHEDULE BUCKET_NAME
-
-# cat the contents of the configured backup cronfile for the service
-dokku redis:backup-schedule-cat lolipop
-
-# remove the scheduled backup from cron
-dokku redis:backup-unschedule lolipop
+```shell
+# usage
+dokku redis:backup-auth <service> <aws-access-key-id> <aws-secret-access-key> <aws-default-region> <aws-signature-version> <endpoint-url>
 ```
 
-Backup auth can also be set up for different regions, signature versions and endpoints (e.g. for minio):
+Setup s3 backup authentication:
 
-```
-# setup s3 backup authentication with different region
-dokku redis:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION
- 
-# setup s3 backup authentication with different signature version and endpoint
-dokku redis:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION AWS_SIGNATURE_VERSION ENDPOINT_URL
- 
-# more specific example for minio auth
-dokku redis:backup-auth lolipop MINIO_ACCESS_KEY_ID MINIO_SECRET_ACCESS_KEY us-east-1 s3v4 https://YOURMINIOSERVICE
+```shell
+dokku redis:backup-auth lollipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY
 ```
 
-## Disabling `docker pull` calls
+Setup s3 backup authentication with different region:
 
-If you wish to disable the `docker pull` calls that the plugin triggers, you may set the `REDIS_DISABLE_PULL` environment variable to `true`. Once disabled, you will need to pull the service image you wish to deploy as shown in the `stderr` output.
+```shell
+dokku redis:backup-auth lollipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION
+```
 
-Please ensure the proper images are in place when `docker pull` is disabled.
+Setup s3 backup authentication with different signature version and endpoint:
+
+```shell
+dokku redis:backup-auth lollipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION AWS_SIGNATURE_VERSION ENDPOINT_URL
+```
+
+More specific example for minio auth:
+
+```shell
+dokku redis:backup-auth lollipop MINIO_ACCESS_KEY_ID MINIO_SECRET_ACCESS_KEY us-east-1 s3v4 https://YOURMINIOSERVICE
+```
+
+### remove backup authentication for the redis service
+
+```shell
+# usage
+dokku redis:backup-deauth <service>
+```
+
+Remove s3 authentication:
+
+```shell
+dokku redis:backup-deauth lollipop
+```
+
+### create a backup of the redis service to an existing s3 bucket
+
+```shell
+# usage
+dokku redis:backup <service> <bucket-name> [--use-iam]
+```
+
+flags:
+
+- `-u|--use-iam`: use the IAM profile associated with the current server
+
+Backup the `lollipop` service to the `my-s3-bucket` bucket on `AWS`:`
+
+```shell
+dokku redis:backup lollipop my-s3-bucket --use-iam
+```
+
+Restore a backup file (assuming it was extracted via `tar -xf backup.tgz`):
+
+```shell
+dokku redis:import lollipop < backup-folder/export
+```
+
+### set encryption for all future backups of redis service
+
+```shell
+# usage
+dokku redis:backup-set-encryption <service> <passphrase>
+```
+
+Set the GPG-compatible passphrase for encrypting backups for backups:
+
+```shell
+dokku redis:backup-set-encryption lollipop
+```
+
+### unset encryption for future backups of the redis service
+
+```shell
+# usage
+dokku redis:backup-unset-encryption <service>
+```
+
+Unset the `GPG` encryption passphrase for backups:
+
+```shell
+dokku redis:backup-unset-encryption lollipop
+```
+
+### schedule a backup of the redis service
+
+```shell
+# usage
+dokku redis:backup-schedule <service> <schedule> <bucket-name> [--use-iam]
+```
+
+flags:
+
+- `-u|--use-iam`: use the IAM profile associated with the current server
+
+Schedule a backup:
+
+> 'schedule' is a crontab expression, eg. "0 3 * * *" for each day at 3am
+
+```shell
+dokku redis:backup-schedule lollipop "0 3 * * *" my-s3-bucket
+```
+
+Schedule a backup and authenticate via iam:
+
+```shell
+dokku redis:backup-schedule lollipop "0 3 * * *" my-s3-bucket --use-iam
+```
+
+### cat the contents of the configured backup cronfile for the service
+
+```shell
+# usage
+dokku redis:backup-schedule-cat <service>
+```
+
+Cat the contents of the configured backup cronfile for the service:
+
+```shell
+dokku redis:backup-schedule-cat lollipop
+```
+
+### unschedule the backup of the redis service
+
+```shell
+# usage
+dokku redis:backup-unschedule <service>
+```
+
+Remove the scheduled backup from cron:
+
+```shell
+dokku redis:backup-unschedule lollipop
+```
+
+### Disabling `docker image pull` calls
+
+If you wish to disable the `docker image pull` calls that the plugin triggers, you may set the `REDIS_DISABLE_PULL` environment variable to `true`. Once disabled, you will need to pull the service image you wish to deploy as shown in the `stderr` output.
+
+Please ensure the proper images are in place when `docker image pull` is disabled.

Vagrantfile

@@ -1,8 +1,8 @@
 # -*- mode: ruby -*-
 # vi: set ft=ruby :
 
-BOX_NAME = ENV["BOX_NAME"] || "bento/ubuntu-14.04"
-BOX_MEMORY = ENV["BOX_MEMORY"] || "512"
+BOX_NAME = ENV["BOX_NAME"] || "bento/ubuntu-20.04"
+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,539 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import print_function
+import os
+import re
+
+
+def compile(service, version, variable, alias, image, scheme, ports, sponsors, options, unimplemented, dokku_version):
+    prefix = "\n\n".join([
+        header(service),
+        description(service, image, version),
+    ])
+
+    if len(sponsors) > 0:
+        prefix += "\n\n"
+        prefix += sponsors_section(service, sponsors)
+
+    return (
+        "\n\n".join(
+            [
+                prefix,
+                requirements_section(dokku_version),
+                installation_section(service, dokku_version),
+                commands_section(service, variable, alias, image, scheme, ports, unimplemented),
+                usage_section(service, variable, alias, image, scheme, ports, options, unimplemented),
+            ]
+        )
+        .replace("\n\n\n\n\n", "\n")
+        .replace("\n\n\n\n", "\n")
+        .replace("\n\n\n", "\n\n")
+    )
+
+
+def header(service):
+    return " ".join(
+        [
+            f"# dokku {service}",
+            f'[![Build Status](https://img.shields.io/github/actions/workflow/status/dokku/dokku-{service}/ci.yml?branch=master&style=flat-square "Build Status")](https://github.com/dokku/dokku-{service}/actions/workflows/ci.yml?query=branch%3Amaster)',
+            f'[![IRC Network](https://img.shields.io/badge/irc-libera-blue.svg?style=flat-square "IRC Libera")](https://webchat.libera.chat/?channels=dokku)',
+        ]
+    )
+
+
+def description(service, full_image, version):
+    base = "_"
+    image = full_image
+    if "/" in full_image:
+        base = "r/" + full_image.split("/")[0]
+        image = full_image.split("/")[1]
+
+    return f"Official {service} plugin for dokku. Currently defaults to installing [{full_image} {version}](https://hub.docker.com/{base}/{image}/)."
+
+
+def sponsors_section(service, sponsors):
+    if len(sponsors) == 0:
+        return ""
+
+    sponsor_data = ["## Sponsors", "", f"The {service} plugin was generously sponsored by the following:", ""]
+    sponsor_data.extend([f"- [{s}](https://github.com/{s})" for s in sponsors])
+
+    return "\n".join(
+        sponsor_data
+    )
+
+
+def requirements_section(dokku_version):
+    return "\n".join(
+        ["## Requirements", "", f"- dokku {dokku_version}", "- docker 1.8.x",]
+    )
+
+
+def installation_section(service, dokku_version):
+    return "\n".join(
+        [
+            "## Installation",
+            "",
+            "```shell",
+            f"# on {dokku_version}",
+            f"sudo dokku plugin:install https://github.com/dokku/dokku-{service}.git {service}",
+            "```",
+        ]
+    )
+
+
+def commands_section(service, variable, alias, image, scheme, ports, unimplemented):
+    content = [
+        "## Commands",
+        "",
+        "```",
+    ]
+
+    subcommands = os.listdir("subcommands")
+    subcommands.sort()
+
+    command_list = []
+    descriptions = []
+    for filename in subcommands:
+        if filename in unimplemented:
+            continue
+        data = command_data(filename, service, variable, alias, image, scheme, ports)
+        description = data["description"]
+        arguments = data["arguments_string"]
+
+        command_list.append(f"{service}:{filename} {arguments}")
+        descriptions.append(description)
+
+    maxlen = max(map(len, command_list))
+    if maxlen > 50:
+        maxlen = 50
+    for command, description in zip(command_list, descriptions):
+        space_count = maxlen - len(command)
+        content.append("{0}{1} # {2}".format(command, " " * space_count, description))
+
+    content.append("```")
+    return "\n".join(content)
+
+
+def usage_section(service, variable, alias, image, scheme, ports, options, unimplemented):
+    return "\n\n".join(
+        [
+            "## Usage",
+            f"Help for any commands can be displayed by specifying the command as an argument to {service}:help. Plugin help output in conjunction with any files in the `docs/` folder is used to generate the plugin documentation. Please consult the `{service}:help` command for any undocumented commands.",
+            usage_intro(service, variable, alias, image, scheme, ports, options, unimplemented),
+            usage_lifecycle(service, variable, alias, image, scheme, ports, options, unimplemented),
+            usage_automation(service, variable, alias, image, scheme, ports, options, unimplemented),
+            usage_data_management(service, variable, alias, image, scheme, ports, options, unimplemented),
+            usage_backup(service, variable, alias, image, scheme, ports, options, unimplemented),
+            usage_docker_pull(service, variable, alias, image, scheme, ports, options, unimplemented),
+        ]
+    )
+
+
+def usage_intro(service, variable, alias, image, scheme, ports, options, unimplemented):
+    commands = ["create", "info", "list", "logs", "link", "unlink", "set"]
+    content = ["### Basic Usage"]
+
+    return fetch_commands_content(
+        service, variable, alias, image, scheme, ports, options, unimplemented, commands, content
+    )
+
+
+def usage_lifecycle(service, variable, alias, image, scheme, ports, options, unimplemented):
+    commands = [
+        "connect",
+        "enter",
+        "expose",
+        "unexpose",
+        "promote",
+        "start",
+        "stop",
+        "pause",
+        "restart",
+        "upgrade",
+    ]
+    content = [
+        "### Service Lifecycle",
+        "",
+        "The lifecycle of each service can be managed through the following commands:",
+        "",
+    ]
+
+    return fetch_commands_content(
+        service, variable, alias, image, scheme, ports, options, unimplemented, commands, content
+    )
+
+
+def usage_automation(service, variable, alias, image, scheme, ports, options, unimplemented):
+    commands = ["app-links", "clone", "exists", "linked", "links"]
+    content = [
+        "### Service Automation",
+        "",
+        "Service scripting can be executed using the following commands:",
+        "",
+    ]
+
+    return fetch_commands_content(
+        service, variable, alias, image, scheme, ports, options, unimplemented, commands, content
+    )
+
+
+def usage_data_management(service, variable, alias, image, scheme, ports, options, unimplemented):
+    commands = ["import", "export"]
+    content = [
+        "### Data Management",
+        "",
+        "The underlying service data can be imported and exported with the following commands:",
+        "",
+    ]
+
+    return fetch_commands_content(
+        service, variable, alias, image, scheme, ports, options, unimplemented, commands, content
+    )
+
+
+def usage_backup(service, variable, alias, image, scheme, ports, options, unimplemented):
+    commands = [
+        "backup-auth",
+        "backup-deauth",
+        "backup",
+        "backup-set-encryption",
+        "backup-unset-encryption",
+        "backup-schedule",
+        "backup-schedule-cat",
+        "backup-unschedule",
+    ]
+    content = [
+        "### Backups",
+        "",
+        "Datastore backups are supported via AWS S3 and S3 compatible services like [minio](https://github.com/minio/minio).",
+        "",
+        "You may skip the `backup-auth` step if your dokku install is running within EC2 and has access to the bucket via an IAM profile. In that case, use the `--use-iam` option with the `backup` command.",
+        "",
+        "Backups can be performed using the backup commands:",
+        "",
+    ]
+
+    return fetch_commands_content(
+        service, variable, alias, image, scheme, ports, options, unimplemented, commands, content
+    )
+
+
+def usage_docker_pull(service, variable, alias, image, scheme, ports, options, unimplemented):
+    service_prefix = service.upper()
+    return "\n".join(
+        [
+            "### Disabling `docker image pull` calls",
+            "",
+            f"If you wish to disable the `docker image 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 image pull` is disabled.",
+        ]
+    )
+
+
+def fetch_commands_content(
+    service, variable, alias, image, scheme, ports, options, unimplemented, commands, content
+):
+    i = 0
+    for command in commands:
+        output = command_help(command, service, variable, alias, image, scheme, ports, options, unimplemented)
+        if output == "":
+            continue
+        content.append(output)
+        i += 1
+
+    if i == 0:
+        return ""
+
+    return "\n".join(content)
+
+
+def parse_args(line):
+    line = line.strip()
+    arguments = []
+    for arg in re.findall("([A-Z_]+)", line):
+        arg = arg.replace("_", "-").lower()
+        if arg.endswith("optional-flag"):
+            arg = arg.replace("-optional-flag", "")
+            arguments.append(f"[--{arg}]")
+        elif arg.endswith("-flag"):
+            if arg == "info-flag":
+                arguments.append(f"[--single-info-flag]")
+            else:
+                arg = arg.replace("-flag", "")
+                first_letter = arg[0]
+                arguments.append(f"[-{first_letter}|--{arg}]")
+        elif arg.endswith("-flags-list"):
+            arg = arg.replace("-list", "")
+            arguments.append(f"[--{arg}...]")
+        elif arg.endswith("list"):
+            arg = arg.replace("-list", "")
+            arguments.append(f"<{arg}...>")
+        else:
+            arguments.append(f"<{arg}>")
+    return " ".join(arguments)
+
+
+def command_help(command, service, variable, alias, image, scheme, ports, options, unimplemented):
+    if command in unimplemented:
+        return ""
+
+    data = command_data(command, service, variable, alias, image, scheme, ports)
+    content = [
+        f"### {data['description']}",
+        "",
+        "```shell",
+        "# usage",
+        f"dokku {service}:{command} {data['arguments_string']}",
+        "```",
+    ]
+
+    # if len(data["arguments"]) > 0:
+    #     content.append("")
+    #     content.append("arguments:")
+    #     content.append("")
+    # for argument in data["arguments"]:
+    #     content.append(f"- {argument}")
+
+    if len(data["flags"]) > 0:
+        content.append("")
+        content.append("flags:")
+        content.append("")
+    for flag in data["flags"]:
+        if "--config-options" in flag and options != "":
+            flag = f"{flag} (default: `{options}`)"
+        content.append(f"- {flag}")
+
+    if len(data["examples"]) > 0:
+        content.append("")
+        content.append(data["examples"])
+
+    doc_file = os.path.join("docs", f"{command}.md")
+    if os.path.isfile(doc_file):
+        content.append("")
+        with open(doc_file) as f:
+            content.append(f.read())
+
+    return "\n" + "\n".join(content)
+
+
+def command_data(command, service, variable, alias, image, scheme, ports):
+    description = None
+    arguments = []
+    arguments_string = ""
+    example_lines = []
+    flags = []
+    with open(os.path.join("subcommands", command)) as f:
+        for line in f.readlines():
+            line = line.strip()
+            line = line.replace("$PLUGIN_SERVICE", service)
+            line = line.replace("$PLUGIN_COMMAND_PREFIX", service)
+            line = line.replace("${PLUGIN_COMMAND_PREFIX}", service)
+            line = line.replace("${PLUGIN_VARIABLE}", variable)
+            line = line.replace("${PLUGIN_DEFAULT_ALIAS}", alias)
+            line = line.replace("${PLUGIN_IMAGE}", image)
+            line = line.replace("${PLUGIN_SCHEME}", scheme)
+            line = line.replace("${PLUGIN_DATASTORE_PORTS[0]}", ports[0])
+            line = line.replace("${PLUGIN_DATASTORE_PORTS[@]}", " ".join(ports))
+
+            if "declare desc" in line:
+                description = re.search('"(.+)"', line).group(1)
+            elif "$1" in line:
+                arguments_string = parse_args(line)
+            elif line.startswith("#A "):
+                argument = line.replace("#A ", "")
+                parts = [a.strip() for a in argument.split(",", 1)]
+                arguments.append(f"`{parts[0]}`: {parts[1]}")
+            elif line.startswith("#F "):
+                flag = line.replace("#F ", "")
+                parts = [a.strip() for a in flag.split(",", 1)]
+                flags.append(f"`{parts[0]}`: {parts[1]}")
+            elif line.startswith("#E "):
+                example_lines.append(line.replace("#E ", ""))
+
+    examples = []
+    sentence_lines = []
+    command_lines = []
+    codeblock_lines = []
+    blockquote_lines = []
+    for line in example_lines:
+        if line.startswith("export") or line.startswith("dokku"):
+            if len(blockquote_lines) > 0:
+                examples.append("\n" + process_blockquote(blockquote_lines))
+                blockquote_lines = []
+            if len(codeblock_lines) > 0:
+                examples.append("\n" + process_codeblock(codeblock_lines))
+                codeblock_lines = []
+            if len(sentence_lines) > 0:
+                examples.append("\n" + process_sentence(sentence_lines))
+                sentence_lines = []
+
+            command_lines.append(line)
+        elif line.startswith("    "):
+            if len(blockquote_lines) > 0:
+                examples.append("\n" + process_blockquote(blockquote_lines))
+                blockquote_lines = []
+            if len(command_lines) > 0:
+                examples.append("\n" + process_command(command_lines))
+                command_lines = []
+            if len(sentence_lines) > 0:
+                examples.append("\n" + process_sentence(sentence_lines))
+                sentence_lines = []
+
+            codeblock_lines.append(line.strip())
+        elif line.startswith(">"):
+            if len(codeblock_lines) > 0:
+                examples.append("\n" + process_codeblock(codeblock_lines))
+                codeblock_lines = []
+            if len(command_lines) > 0:
+                examples.append("\n" + process_command(command_lines))
+                command_lines = []
+            if len(sentence_lines) > 0:
+                examples.append("\n" + process_sentence(sentence_lines))
+                sentence_lines = []
+
+            blockquote_lines.append(line)
+        else:
+            if len(blockquote_lines) > 0:
+                examples.append("\n" + process_blockquote(blockquote_lines))
+                blockquote_lines = []
+            if len(codeblock_lines) > 0:
+                examples.append("\n" + process_codeblock(codeblock_lines))
+                codeblock_lines = []
+            if len(command_lines) > 0:
+                examples.append("\n" + process_command(command_lines))
+                command_lines = []
+
+            sentence_lines.append(line)
+
+    if len(blockquote_lines) > 0:
+        examples.append("\n" + process_blockquote(blockquote_lines))
+        blockquote_lines = []
+    if len(codeblock_lines) > 0:
+        examples.append("\n" + process_codeblock(codeblock_lines))
+        codeblock_lines = []
+    if len(command_lines) > 0:
+        examples.append("\n" + process_command(command_lines))
+        command_lines = []
+    if len(sentence_lines) > 0:
+        examples.append("\n" + process_sentence(sentence_lines))
+        sentence_lines = []
+
+    return {
+        "description": description,
+        "arguments_string": arguments_string,
+        "arguments": arguments,
+        "flags": flags,
+        "examples": "\n".join(examples).strip(),
+    }
+
+
+def process_sentence(sentence_lines):
+    sentence_lines = " ".join(sentence_lines)
+    sentences = ". ".join(
+        upperfirst(i.strip()) for i in sentence_lines.split(". ")
+    ).strip()
+    if not sentences.endswith(".") and not sentences.endswith(":"):
+        sentences += ":"
+
+    text = []
+    for sentence in sentences.split(". "):
+        parts = []
+        for word in sentence.strip().split(" "):
+            if word.isupper() and len(word) > 1:
+                for ending in [':', '.']:
+                    if word.endswith(ending):
+                        word = '`{0}`{1}'.format(word[:-1], ending)
+                else:
+                    word = '`{0}`'.format(word)
+            parts.append(word)
+        text.append(" ".join(parts))
+
+    text = ". ".join(text)
+
+    # some cleanup
+    text = text.replace("(0.0.0.0)", "(`0.0.0.0`)")
+    text = text.replace("'", "`")
+    text = text.replace("`s", "'s")
+    text = text.replace("``", "`")
+    text = text.strip(" ")
+
+    return text
+
+
+def upperfirst(x):
+    return x[:1].upper() + x[1:]
+
+
+def process_blockquote(blockquote_lines):
+    return "\n".join(blockquote_lines)
+
+
+def process_command(command_lines):
+    command_lines = "\n".join(command_lines)
+    return f"```shell\n{command_lines}\n```"
+
+
+def process_codeblock(codeblock_lines):
+    codeblock_lines = "\n".join(codeblock_lines)
+    return f"```\n{codeblock_lines}\n```"
+
+
+def main():
+    service = None
+    version = None
+    variable = None
+    image = None
+    alias = None
+    options = None
+    unimplemented = []
+
+    with open("Dockerfile") as f:
+        for line in f.readlines():
+          if "FROM " in line:
+              image, version = line.split(" ")[1].split(":")
+              image = image.strip()
+              version = version.strip()
+
+    with open("config") as f:
+        for line in f.readlines():
+            if "PLUGIN_COMMAND_PREFIX=" in line:
+                service = re.search('"(.+)"', line).group(1)
+            if "PLUGIN_DEFAULT_ALIAS=" in line:
+                alias = re.search('"(.+)"', line).group(1)
+            if "PLUGIN_VARIABLE=" in line:
+                variable = re.search('"(.+)"', line).group(1)
+            if "PLUGIN_SCHEME=" in line:
+                scheme = re.search('"(.+)"', line).group(1)
+            if "PLUGIN_DATASTORE_PORTS=" in line:
+                ports = re.search("\((.+)\)", line).group(1).split(" ")
+            if "PLUGIN_UNIMPLEMENTED_SUBCOMMANDS=" in line:
+                match = re.search("\((.+)\)", line)
+                if match is not None:
+                    unimplemented = [s.strip('"') for s in match.group(1).split(" ")]
+
+    with open("config") as f:
+        for line in f.readlines():
+            if f"{variable}_CONFIG_OPTIONS" in line:
+                match = re.search('"(.+)"', line)
+                if match is not None:
+                    options = match.group(1)
+
+    sponsors = []
+    with open("plugin.toml") as f:
+        for line in f.readlines():
+            if line.startswith("sponsors"):
+                sponsors = re.search("\[([\"\w\s,_-]+)\]", line).group(1)
+                sponsors = [s.strip("\"") for s in sponsors.split(",")]
+
+    text = compile(service, version, variable, alias, image, scheme, ports, sponsors, options, unimplemented, "0.19.x+")
+
+    base_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+    readme_file = os.path.join(base_path, "README.md")
+    with open(readme_file, "w") as f:
+        f.write(text + "\n")
+
+
+if __name__ == "__main__":
+    main()

commands

@@ -1,8 +1,10 @@
 #!/usr/bin/env bash
 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
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
+
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/help-functions"
 

config

@@ -1,8 +1,10 @@
 #!/usr/bin/env bash
-export REDIS_IMAGE=${REDIS_IMAGE:="redis"}
-export REDIS_IMAGE_VERSION=${REDIS_IMAGE_VERSION:="4.0.11"}
-export REDIS_ROOT=${REDIS_ROOT:="/var/lib/dokku/services/redis"}
-export REDIS_HOST_ROOT=${REDIS_HOST_ROOT:=$REDIS_ROOT}
+_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+export REDIS_IMAGE=${REDIS_IMAGE:="$(awk -F '[ :]' '{print $2}' "${_DIR}/Dockerfile")"}
+export REDIS_IMAGE_VERSION=${REDIS_IMAGE_VERSION:="$(awk -F '[ :]' '{print $3}' "${_DIR}/Dockerfile")"}
+export REDIS_ROOT=${REDIS_ROOT:="$DOKKU_LIB_ROOT/services/redis"}
+export DOKKU_LIB_HOST_ROOT=${DOKKU_LIB_HOST_ROOT:=$DOKKU_LIB_ROOT}
+export REDIS_HOST_ROOT=${REDIS_HOST_ROOT:="$DOKKU_LIB_HOST_ROOT/services/redis"}
 
 export PLUGIN_UNIMPLEMENTED_SUBCOMMANDS=()
 export PLUGIN_COMMAND_PREFIX="redis"
@@ -21,10 +23,14 @@ export PLUGIN_SCHEME="redis"
 export PLUGIN_SERVICE="Redis"
 export PLUGIN_VARIABLE="REDIS"
 export PLUGIN_BASE_PATH="$PLUGIN_PATH"
+export PLUGIN_CONFIG_SUFFIX="config"
 if [[ -n $DOKKU_API_VERSION ]]; then
   export PLUGIN_BASE_PATH="$PLUGIN_ENABLED_PATH"
 fi
 
-if [[ -d "$PLUGIN_DATA_ROOT/*" ]]; then
-  rm -rf "${PLUGIN_DATA_ROOT:?}/*"
-fi
+export PLUGIN_BUSYBOX_IMAGE="busybox:1.34.1-uclibc"
+export PLUGIN_AMBASSADOR_IMAGE="dokku/ambassador:0.5.0"
+export PLUGIN_S3BACKUP_IMAGE="dokku/s3backup:0.14.0"
+export PLUGIN_WAIT_IMAGE="dokku/wait:0.6.0"
+
+export REDIS_CONFIG_OPTIONS=${REDIS_CONFIG_OPTIONS:=""}

docs/README.md

@@ -0,0 +1,4 @@
+# Extra Documentation
+
+The documentation in this folder is supplemental to using this plugin. It is injected automatically into the plugin's readme during documentation generation.
+

functions

@@ -1,15 +1,15 @@
 #!/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_CORE_AVAILABLE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/property-functions"
 source "$PLUGIN_AVAILABLE_PATH/config/functions"
 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"
@@ -18,52 +18,54 @@ service_connect() {
   local SERVICE_TTY_OPTS
   has_tty && SERVICE_TTY_OPTS="-t"
 
-  docker exec -i $SERVICE_TTY_OPTS "$SERVICE_NAME" redis-cli -a "$PASSWORD"
+  "$DOCKER_BIN" container exec --env=LANG=C.UTF-8 --env=LC_ALL=C.UTF-8 -i $SERVICE_TTY_OPTS "$SERVICE_NAME" redis-cli -a "$PASSWORD"
 }
 
 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}"
 
   if ! service_image_exists "$SERVICE"; then
     if [[ "$PLUGIN_DISABLE_PULL" == "true" ]]; then
       dokku_log_warn "${PLUGIN_DISABLE_PULL_VARIABLE} environment variable detected. Not running pull command." 1>&2
-      dokku_log_warn "   docker pull ${IMAGE}" 1>&2
+      dokku_log_warn "   docker image pull ${IMAGE}" 1>&2
       dokku_log_warn "$PLUGIN_SERVICE service creation failed"
       exit 1
     fi
-    docker pull "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" || dokku_log_fail "$PLUGIN_SERVICE image $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION pull failed"
+    "$DOCKER_BIN" image pull "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" || dokku_log_fail "$PLUGIN_SERVICE image $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION pull failed"
   fi
 
+  plugn trigger service-action pre-create "$PLUGIN_COMMAND_PREFIX" "$SERVICE"
   mkdir -p "$SERVICE_ROOT" || dokku_log_fail "Unable to create service directory"
   mkdir -p "$SERVICE_ROOT/data" || dokku_log_fail "Unable to create service data directory"
-  mkdir -p "$SERVICE_ROOT/config" || dokku_log_fail "Unable to create service config directory"
-  if [[ -z $REDIS_CONFIG_PATH ]] ; then
-    curl -sSL "https://raw.githubusercontent.com/antirez/redis/${PLUGIN_IMAGE_VERSION:0:3}/redis.conf" > "$SERVICE_ROOT/config/redis.conf" || dokku_log_fail "Unable to download the default redis.conf to the config directory"
+  mkdir -p "$SERVICE_ROOT/$PLUGIN_CONFIG_SUFFIX" || dokku_log_fail "Unable to create service config directory"
+  touch "$LINKS_FILE"
+
+  if [[ -z $REDIS_CONFIG_PATH ]]; then
+    curl -sSL "https://raw.githubusercontent.com/antirez/redis/${PLUGIN_IMAGE_VERSION:0:3}/redis.conf" >"$SERVICE_ROOT/$PLUGIN_CONFIG_SUFFIX/redis.conf" || dokku_log_fail "Unable to download the default redis.conf to the config directory"
   else
-    cp "$REDIS_CONFIG_PATH" "$SERVICE_ROOT/config/redis.conf" || dokku_log_fail "Unable to copy the ${REDIS_CONFIG_PATH} to the config directory"
+    cp "$REDIS_CONFIG_PATH" "$SERVICE_ROOT/$PLUGIN_CONFIG_SUFFIX/redis.conf" || dokku_log_fail "Unable to copy the ${REDIS_CONFIG_PATH} to the config directory"
   fi
   PASSWORD=$(openssl rand -hex 32)
   if [[ -n "$SERVICE_PASSWORD" ]]; then
     PASSWORD="$SERVICE_PASSWORD"
     dokku_log_warn "Specified password may not be as secure as the auto-generated password"
   fi
-  echo "$PASSWORD" > "$SERVICE_ROOT/PASSWORD"
+  echo "$PASSWORD" >"$SERVICE_ROOT/PASSWORD"
   chmod 640 "$SERVICE_ROOT/PASSWORD"
-  sed -i.bak "s/# requirepass.*/requirepass ${PASSWORD}/" "$SERVICE_ROOT/config/redis.conf" && rm "$SERVICE_ROOT/config/redis.conf.bak"
-  touch "$LINKS_FILE"
+  sed -i.bak "s/# requirepass.*/requirepass ${PASSWORD}/" "$SERVICE_ROOT/$PLUGIN_CONFIG_SUFFIX/redis.conf" && rm "$SERVICE_ROOT/$PLUGIN_CONFIG_SUFFIX/redis.conf.bak"
 
-  [[ -n "$SERVICE_CUSTOM_ENV" ]] && REDIS_CUSTOM_ENV="$SERVICE_CUSTOM_ENV"
-  if [[ -n $REDIS_CUSTOM_ENV ]]; then
-    echo "$REDIS_CUSTOM_ENV" | tr ';' "\n" > "$SERVICE_ROOT/ENV"
-  else
-    echo "" > "$SERVICE_ROOT/ENV"
-  fi
+  service_commit_config "$SERVICE"
+  write_database_name "$SERVICE"
+  plugn trigger service-action post-create "$PLUGIN_COMMAND_PREFIX" "$SERVICE"
   service_create_container "$SERVICE"
+  plugn trigger service-action post-create-complete "$PLUGIN_COMMAND_PREFIX" "$SERVICE"
 }
 
 service_create_container() {
@@ -72,11 +74,79 @@ service_create_container() {
   local SERVICE_HOST_ROOT="$PLUGIN_DATA_HOST_ROOT/$SERVICE"
   local SERVICE_NAME="$(get_service_name "$SERVICE")"
 
-  ID=$(docker run --name "$SERVICE_NAME" -v "$SERVICE_HOST_ROOT/data:/data" -v "$SERVICE_HOST_ROOT/config:/usr/local/etc/redis" --env-file="$SERVICE_ROOT/ENV" -d --restart always --label dokku=service --label dokku.service=redis "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" redis-server /usr/local/etc/redis/redis.conf --bind 0.0.0.0 --sysctl vm.overcommit_memory=1)
-  echo "$ID" > "$SERVICE_ROOT/ID"
+  if [[ -f "$SERVICE_ROOT/CONFIG_OPTIONS" ]]; then
+    export CONFIG_OPTIONS="$(cat "$SERVICE_ROOT/CONFIG_OPTIONS")"
+  fi
+
+  local network_alias="$(service_dns_hostname "$SERVICE")"
+
+  rm -f "$SERVICE_ROOT/ID"
+  declare -a DOCKER_ARGS
+  DOCKER_ARGS=()
+  DOCKER_ARGS+=("--cidfile=$SERVICE_ROOT/ID")
+  DOCKER_ARGS+=("--env-file=$SERVICE_ROOT/ENV")
+  DOCKER_ARGS+=("--hostname=$SERVICE_NAME")
+  DOCKER_ARGS+=("--label=dokku.service=$PLUGIN_COMMAND_PREFIX")
+  DOCKER_ARGS+=("--label=dokku=service")
+  DOCKER_ARGS+=("--name=$SERVICE_NAME")
+  DOCKER_ARGS+=("--restart=always")
+  DOCKER_ARGS+=("--volume=$SERVICE_HOST_ROOT/$PLUGIN_CONFIG_SUFFIX:/usr/local/etc/redis")
+  DOCKER_ARGS+=("--volume=$SERVICE_HOST_ROOT/data:/data")
+
+  declare -a LINK_CONTAINER_DOCKER_ARGS
+  LINK_CONTAINER_DOCKER_ARGS=()
+  LINK_CONTAINER_DOCKER_ARGS+=("--rm")
+  LINK_CONTAINER_DOCKER_ARGS+=("--link")
+  LINK_CONTAINER_DOCKER_ARGS+=("$SERVICE_NAME:$network_alias")
+
+  [[ -f "$SERVICE_ROOT/SERVICE_MEMORY" ]] && SERVICE_MEMORY="$(cat "$SERVICE_ROOT/SERVICE_MEMORY")"
+  if [[ -n "$SERVICE_MEMORY" ]]; then
+    DOCKER_ARGS+=("--memory=${SERVICE_MEMORY}m")
+  fi
+
+  [[ -f "$SERVICE_ROOT/SHM_SIZE" ]] && SERVICE_SHM_SIZE="$(cat "$SERVICE_ROOT/SHM_SIZE")"
+  if [[ -n "$SERVICE_SHM_SIZE" ]]; then
+    DOCKER_ARGS+=("--shm-size=${SERVICE_SHM_SIZE}")
+  fi
+
+  [[ -f "$SERVICE_ROOT/IMAGE" ]] && PLUGIN_IMAGE="$(cat "$SERVICE_ROOT/IMAGE")"
+  [[ -f "$SERVICE_ROOT/IMAGE_VERSION" ]] && PLUGIN_IMAGE_VERSION="$(cat "$SERVICE_ROOT/IMAGE_VERSION")"
+
+  local network="$(fn-plugin-property-get "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "initial-network")"
+  if [[ -n "$network" ]]; then
+    DOCKER_ARGS+=("--network=${network}")
+    DOCKER_ARGS+=("--network-alias=${network_alias}")
+    LINK_CONTAINER_DOCKER_ARGS+=("--network=${network}")
+  fi
+
+  # shellcheck disable=SC2086
+  suppress_output "$DOCKER_BIN" container create "${DOCKER_ARGS[@]}" "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" redis-server /usr/local/etc/redis/redis.conf --bind 0.0.0.0 $CONFIG_OPTIONS
+
+  if [[ -n "$(fn-plugin-property-get "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "post-create-network")" ]]; then
+    dokku_log_verbose_quiet "Connecting to networks after container create"
+    while read -r line || [[ -n "$line" ]]; do
+      dokku_log_verbose_quiet "- $line"
+      "$DOCKER_BIN" network connect --alias "$network_alias" "$line" "$SERVICE_NAME"
+    done < <(fn-plugin-property-get "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "post-create-network" | tr "," "\n")
+  fi
+  suppress_output "$DOCKER_BIN" container start "$(cat "$SERVICE_ROOT/ID")"
+  service_port_reconcile_status "$SERVICE"
+
+  if [[ -n "$(fn-plugin-property-get "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "post-start-network")" ]]; then
+    dokku_log_verbose_quiet "Connecting to networks after container start"
+    while read -r line || [[ -n "$line" ]]; do
+      dokku_log_verbose_quiet "- $line"
+      "$DOCKER_BIN" network connect --alias "$network_alias" "$line" "$SERVICE_NAME"
+    done < <(fn-plugin-property-get "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "post-start-network" | tr "," "\n")
+  fi
 
   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
+  if ! suppress_output "$DOCKER_BIN" container run "${LINK_CONTAINER_DOCKER_ARGS[@]}" "$PLUGIN_WAIT_IMAGE" -c "$network_alias:$PLUGIN_DATASTORE_WAIT_PORT"; then
+    dokku_log_info2_quiet "Start of $SERVICE container output"
+    dokku_container_log_verbose_quiet "$SERVICE_NAME"
+    dokku_log_info2_quiet "End of $SERVICE container output"
+    return 1
+  fi
 
   dokku_log_info2 "$PLUGIN_SERVICE container created: $SERVICE"
   service_info "$SERVICE"
@@ -89,8 +159,16 @@ service_export() {
   local PASSWORD="$(service_password "$SERVICE")"
 
   [[ -n $SSH_TTY ]] && stty -opost
-  docker exec "$SERVICE_NAME" bash -c "echo SAVE | redis-cli -a ${PASSWORD}" > /dev/null 2>&1
-  docker exec "$SERVICE_NAME" cat /data/dump.rdb
+  LASTSAVE1=$("$DOCKER_BIN" container exec "$SERVICE_NAME" bash -c "echo LASTSAVE | redis-cli -a ${PASSWORD}")
+  "$DOCKER_BIN" container exec "$SERVICE_NAME" bash -c "echo BGSAVE | redis-cli -a ${PASSWORD}" >/dev/null 2>&1
+  LASTSAVE2=$("$DOCKER_BIN" container exec "$SERVICE_NAME" bash -c "echo LASTSAVE | redis-cli -a ${PASSWORD}")
+
+  until [[ "$LASTSAVE1" != "$LASTSAVE2" ]]; do
+    LASTSAVE2=$("$DOCKER_BIN" container exec "$SERVICE_NAME" bash -c "echo LASTSAVE | redis-cli -a ${PASSWORD}")
+    sleep 5
+  done
+
+  "$DOCKER_BIN" container exec "$SERVICE_NAME" cat /data/dump.rdb
   status=$?
   [[ -n $SSH_TTY ]] && stty opost
   exit $status
@@ -104,9 +182,11 @@ service_import() {
   if [[ -t 0 ]]; then
     dokku_log_fail "No data provided on stdin."
   fi
-  dokku "$PLUGIN_COMMAND_PREFIX:stop" "$SERVICE" > /dev/null 2>&1
-  docker run --rm -i -v "$SERVICE_HOST_ROOT/data:/data" "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" bash -c "cat > /data/dump.rdb && chown redis: /data/dump.rdb"
-  dokku "$PLUGIN_COMMAND_PREFIX:start" "$SERVICE" > /dev/null 2>&1
+  suppress_output service_container_rm "$SERVICE"
+  "$DOCKER_BIN" container run --rm -v "$SERVICE_HOST_ROOT/data:/data" "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" bash -c "rm -f /data/dump.rdb"
+  cat >"$SERVICE_HOST_ROOT/data/dump.rdb"
+  "$DOCKER_BIN" container run --rm -v "$SERVICE_HOST_ROOT/data:/data" "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" bash -c "chown redis: /data/dump.rdb"
+  suppress_output service_start "$SERVICE"
 }
 
 service_start() {
@@ -114,36 +194,39 @@ 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_BIN" container 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_BIN" container ps -aq --no-trunc --filter "status=exited" --filter "name=^/$SERVICE_NAME$" --format '{{ .ID }}') || true
 
   if [[ -n $PREVIOUS_ID ]]; then
-    docker start "$PREVIOUS_ID" > /dev/null
-    service_port_unpause "$SERVICE"
+    "$DOCKER_BIN" container start "$PREVIOUS_ID" >/dev/null
+    service_port_reconcile_status "$SERVICE"
     dokku_log_info2 "Container started"
   elif service_image_exists "$SERVICE"; then
     service_create_container "$SERVICE"
   else
-    dokku_log_verbose_quiet "Neither container nor valid configuration exists for $SERVICE"
+    if ! service_image_exists "$SERVICE"; then
+      [[ -f "$SERVICE_ROOT/IMAGE" ]] && PLUGIN_IMAGE="$(cat "$SERVICE_ROOT/IMAGE")"
+      [[ -f "$SERVICE_ROOT/IMAGE_VERSION" ]] && PLUGIN_IMAGE_VERSION="$(cat "$SERVICE_ROOT/IMAGE_VERSION")"
+      dokku_log_verbose_quiet "Missing image $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION for $SERVICE"
+    else
+      dokku_log_verbose_quiet "Neither container nor valid configuration exists for $SERVICE"
+    fi
   fi
 }
 
-service_password() {
-    local SERVICE="$1"
-    local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
-    local PASSWORD="$(cat "$SERVICE_ROOT/PASSWORD")"
-    echo "$PASSWORD"
-}
-
 service_url() {
   local SERVICE="$1"
   local PASSWORD="$(service_password "$SERVICE")"
   local SERVICE_DNS_HOSTNAME="$(service_dns_hostname "$SERVICE")"
-  echo "$PLUGIN_SCHEME://$SERVICE:$PASSWORD@$SERVICE_DNS_HOSTNAME:${PLUGIN_DATASTORE_PORTS[0]}"
+  echo "$PLUGIN_SCHEME://:$PASSWORD@$SERVICE_DNS_HOSTNAME:${PLUGIN_DATASTORE_PORTS[0]}"
 }

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,7 +22,7 @@ fn-help() {
       exit "$EXIT_CODE"
     fi
   done
-  popd > /dev/null 2>&1
+  popd >/dev/null 2>&1
 
   exit "$DOKKU_NOT_IMPLEMENTED_EXIT"
 }
@@ -31,17 +32,17 @@ fn-help-all() {
   local CMD_OUTPUT BLUE BOLD FULL_OUTPUT NORMAL
   FULL_OUTPUT=true
 
-  if [[ "$CMD" = "$PLUGIN_COMMAND_PREFIX:help" ]] || [[ "$CMD" == "$PLUGIN_COMMAND_PREFIX" ]] || [[ "$CMD" == "$PLUGIN_COMMAND_PREFIX:default" ]] ; then
-    BOLD="$(tput bold)"
-    NORMAL="\033[m"
-    BLUE="\033[0;34m"
-    CYAN="\033[1;36m"
+  if [[ "$CMD" == "$PLUGIN_COMMAND_PREFIX:help" ]] || [[ "$CMD" == "$PLUGIN_COMMAND_PREFIX" ]] || [[ "$CMD" == "$PLUGIN_COMMAND_PREFIX:default" ]]; then
+    BOLD="$(fn-help-fancy-tput bold)"
+    NORMAL="$(fn-help-fancy-color "\033[m")"
+    BLUE="$(fn-help-fancy-color "\033[0;34m")"
+    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
@@ -75,13 +76,13 @@ fn-help-contents() {
 
 fn-help-contents-subcommand() {
   declare SUBCOMMAND="$1" FULL_OUTPUT="$2"
-  local TMPDIR=$(mktemp -d)
-  local UNCLEAN_FILE="${TMPDIR}cmd-unclean" CLEAN_FILE="${TMPDIR}cmd-clean"
+  local HELP_TMPDIR=$(mktemp -d --tmpdir)
+  local UNCLEAN_FILE="${HELP_TMPDIR}/cmd-unclean" CLEAN_FILE="${HELP_TMPDIR}/cmd-clean"
   local BOLD CMD_OUTPUT CYAN EXAMPLE LIGHT_GRAY NORMAL
-  trap 'rm -rf "$TMPDIR" > /dev/null' RETURN INT TERM EXIT
+  trap 'rm -rf "$HELP_TMPDIR" > /dev/null' RETURN INT TERM EXIT
 
   rm -rf "$UNCLEAN_FILE" "$CLEAN_FILE"
-  cat "$SUBCOMMAND_ROOT/$SUBCOMMAND" > "$UNCLEAN_FILE"
+  cat "$SUBCOMMAND_ROOT/$SUBCOMMAND" >"$UNCLEAN_FILE"
 
   fn-help-subcommand-sanitize "$UNCLEAN_FILE" "$CLEAN_FILE"
   if ! is_implemented_command "$SUBCOMMAND"; then
@@ -95,12 +96,12 @@ fn-help-contents-subcommand() {
   desc="$(grep desc "$CLEAN_FILE" | head -1)"
   eval "$desc"
 
-  BLUE="\033[0;34m"
-  BOLD="$(tput bold)"
-  CYAN="\033[1;36m"
-  NORMAL="\033[m"
-  LIGHT_GRAY="\033[2;37m"
-  LIGHT_RED="\033[1;31m"
+  BLUE="$(fn-help-fancy-color "\033[0;34m")"
+  BOLD="$(fn-help-fancy-tput bold)"
+  CYAN="$(fn-help-fancy-color "\033[1;36m")"
+  NORMAL="$(fn-help-fancy-color "\033[m")"
+  LIGHT_GRAY="$(fn-help-fancy-color "\033[2;37m")"
+  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,12 +140,32 @@ 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
-      NAME, VERSION, STATUS, EXPOSED PORTS, LINKS
-      service-name, $PLUGIN_COMMAND_PREFIX:$PLUGIN_IMAGE_VERSION, running, -, app-name
+  cat <<help_list
+      $PLUGIN_SERVICE services
+      service-name
 help_list
 }
 
@@ -153,8 +174,8 @@ fn-help-subcommand-args() {
   local argline arglist args argpos BLUE NORMAL
 
   if [[ "$FULL_OUTPUT" == "true" ]]; then
-    BLUE="\033[0;34m"
-    NORMAL="\033[m"
+    BLUE="$(fn-help-fancy-color "\033[0;34m")"
+    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}"
@@ -181,6 +202,9 @@ fn-help-subcommand-args() {
     elif [[ "$arg" == *_LIST ]]; then
       arg=${arg%_*}
       args+=" <${arg//_/-}...>"
+    elif [[ "$arg" == *_OPTIONAL ]]; then
+      argName="${arg/_OPTIONAL/}"
+      args+=" [<${argName//_/-}>]"
     else
       args+=" <${arg//_/-}>"
     fi
@@ -199,12 +223,12 @@ fn-help-subcommand-example() {
     return 0
   fi
 
-  BOLD="$(tput bold)"
+  BOLD="$(fn-help-fancy-tput bold)"
   LAST_LINE=""
-  LIGHT_GRAY="\033[2;37m"
-  OTHER_GRAY="\033[7;37m"
+  LIGHT_GRAY="$(fn-help-fancy-color "\033[2;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,8 +258,8 @@ fn-help-subcommand-list-args() {
     return 0
   fi
 
-  NORMAL="\033[m"
-  LIGHT_GRAY="\033[2;37m"
+  NORMAL="$(fn-help-fancy-color "\033[m")"
+  LIGHT_GRAY="$(fn-help-fancy-color "\033[2;37m")"
 
   _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}"
@@ -251,8 +275,8 @@ fn-help-subcommand-list-flags() {
     return 0
   fi
 
-  NORMAL="\033[m"
-  LIGHT_GRAY="\033[2;37m"
+  NORMAL="$(fn-help-fancy-color "\033[m")"
+  LIGHT_GRAY="$(fn-help-fancy-color "\033[2;37m")"
 
   _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}"
@@ -275,20 +299,20 @@ 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() {
-  declare desc="Expand environment variables for a shell command"
+  declare desc="expand environment variables for a shell command"
   declare data="$1"
   declare delimiter="__apply_shell_expansion_delimiter__"
   declare command="cat <<$delimiter"$'\n'"$data"$'\n'"$delimiter"

install

@@ -1,37 +1,41 @@
 #!/usr/bin/env bash
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/common-functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/property-functions"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 
 plugin-install() {
   pull-docker-image() {
     declare IMAGE="$1"
     if [[ "$PLUGIN_DISABLE_PULL" == "true" ]]; then
       echo " !     ${PLUGIN_DISABLE_PULL_VARIABLE} environment variable detected. Not running pull command." 1>&2
-      echo " !        docker pull ${IMAGE}" 1>&2
+      echo " !        docker image pull ${IMAGE}" 1>&2
       return
     fi
-    if [[ "$(docker images -q "${IMAGE}" 2> /dev/null)" == "" ]]; then
-      docker pull "${IMAGE}"
+    if [[ "$("$DOCKER_BIN" image ls -q "${IMAGE}" 2>/dev/null)" == "" ]]; then
+      "$DOCKER_BIN" image pull "${IMAGE}"
     fi
   }
 
+  fn-plugin-property-setup "$PLUGIN_COMMAND_PREFIX"
   pull-docker-image "${PLUGIN_IMAGE}:${PLUGIN_IMAGE_VERSION}"
-  pull-docker-image "svendowideit/ambassador:latest"
-  pull-docker-image "dokkupaas/wait:0.2"
-  pull-docker-image "dokkupaas/s3backup:0.8.0"
-  pull-docker-image "busybox:latest"
+  pull-docker-image "$PLUGIN_BUSYBOX_IMAGE"
+  pull-docker-image "$PLUGIN_AMBASSADOR_IMAGE"
+  pull-docker-image "$PLUGIN_S3BACKUP_IMAGE"
+  pull-docker-image "$PLUGIN_WAIT_IMAGE"
 
   mkdir -p "$PLUGIN_DATA_ROOT" || echo "Failed to create $PLUGIN_SERVICE data directory"
-  chown dokku:dokku "$PLUGIN_DATA_ROOT"
+  chown "${DOKKU_SYSTEM_USER}:${DOKKU_SYSTEM_GROUP}" "$PLUGIN_DATA_ROOT"
 
   mkdir -p "$PLUGIN_CONFIG_ROOT" || echo "Failed to create $PLUGIN_SERVICE config directory"
-  chown dokku:dokku "$PLUGIN_CONFIG_ROOT"
+  chown "${DOKKU_SYSTEM_USER}:${DOKKU_SYSTEM_GROUP}" "$PLUGIN_CONFIG_ROOT"
 
   rm -f "/etc/sudoers.d/dokku-${PLUGIN_COMMAND_PREFIX}*"
   _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}-*
@@ -41,6 +45,25 @@ plugin-install() {
 EOL
 
   chmod 0440 "$_SUDOERS_FILE"
+
+  for SERVICE in $(fn-services-list false); do
+    local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+
+    if [[ ! -f "$SERVICE_ROOT/IMAGE" ]] || [[ ! -f "$SERVICE_ROOT/IMAGE_VERSION" ]]; then
+      local image="$(service_version "$SERVICE")"
+      if [[ "$image" == *":"* ]]; then
+        echo "${image%:*}" >"$SERVICE_ROOT/IMAGE"
+        echo "${image##*:}" >"$SERVICE_ROOT/IMAGE_VERSION"
+      fi
+    fi
+
+    chown "${DOKKU_SYSTEM_USER}:${DOKKU_SYSTEM_GROUP}" "$SERVICE_ROOT/IMAGE" "$SERVICE_ROOT/IMAGE_VERSION"
+
+    if [[ -f "$SERVICE_ROOT/${PLUGIN_VARIABLE}_CONFIG_OPTIONS" ]]; then
+      mv "$SERVICE_ROOT/${PLUGIN_VARIABLE}_CONFIG_OPTIONS" "$SERVICE_ROOT/CONFIG_OPTIONS"
+      chown "${DOKKU_SYSTEM_USER}:${DOKKU_SYSTEM_GROUP}" "$SERVICE_ROOT/CONFIG_OPTIONS"
+    fi
+  done
 }
 
 plugin-install "$@"

plugin.toml

@@ -1,4 +1,4 @@
 [plugin]
 description = "dokku redis service plugin"
-version = "1.4.4"
+version = "1.32.2"
 [plugin.config]

post-app-clone-setup

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/common-functions"
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/functions"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+
+plugin-post-app-clone-setup() {
+  declare OLD_APP_NAME="$1" NEW_APP_NAME="$2"
+
+  for SERVICE in $(fn-services-list false); do
+    if in_links_file "$SERVICE" "$OLD_APP_NAME"; then
+      add_to_links_file "$SERVICE" "$NEW_APP_NAME"
+    fi
+  done
+}
+
+plugin-post-app-clone-setup "$@"

post-app-rename-setup

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/common-functions"
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/functions"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+
+plugin-post-app-rename-setup() {
+  declare OLD_APP_NAME="$1" NEW_APP_NAME="$2"
+
+  for SERVICE in $(fn-services-list false); do
+    if in_links_file "$SERVICE" "$OLD_APP_NAME"; then
+      add_to_links_file "$SERVICE" "$NEW_APP_NAME"
+    fi
+  done
+}
+
+plugin-post-app-rename-setup "$@"

pre-delete

@@ -1,16 +1,13 @@
 #!/usr/bin/env bash
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
-
-PLUGIN_BASE_PATH="$PLUGIN_PATH"
-if [[ -n $DOKKU_API_VERSION ]]; then
-  PLUGIN_BASE_PATH="$PLUGIN_ENABLED_PATH"
-fi
-source "$PLUGIN_BASE_PATH/common/functions"
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/functions"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
 
 APP="$1"
-for SERVICE in "$PLUGIN_DATA_ROOT"/*; do
+for SERVICE in $(fn-services-list false); do
+  [[ -n "$SERVICE" ]] || continue
+  dokku_log_verbose_quiet "Unlinking from $SERVICE"
   remove_from_links_file "$(basename "$SERVICE")" "$APP"
 done
-exit 0

pre-restore

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/common-functions"
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/functions"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+
+plugin-pre-restore() {
+  declare SCHEDULER="$1" APP="$2"
+  local status
+
+  if [[ "$SCHEDULER" != "docker-local" ]]; then
+    return
+  fi
+
+  for SERVICE in $(fn-services-list false); do
+    if ! in_links_file "$SERVICE" "$APP"; then
+      continue
+    fi
+
+    status="$(service_status "$SERVICE")"
+    if [[ "$status" == "running" ]]; then
+      continue
+    fi
+
+    if [[ "$status" == "restarting" ]]; then
+      dokku_log_warn "$PLUGIN_SERVICE service $SERVICE is restarting and may cause issues with linked app $APP"
+      continue
+    fi
+
+    dokku_log_warn "$PLUGIN_SERVICE service $SERVICE is not running, issuing service start"
+    service_start "$SERVICE"
+  done
+}
+
+plugin-pre-restore "$@"

pre-start

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/common-functions"
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/functions"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+
+plugin-pre-start() {
+  declare APP="$1"
+  local status
+
+  for SERVICE in $(fn-services-list false); do
+    if ! in_links_file "$SERVICE" "$APP"; then
+      continue
+    fi
+
+    status="$(service_status "$SERVICE")"
+    if [[ "$status" == "running" ]]; then
+      continue
+    fi
+
+    if [[ "$status" == "restarting" ]]; then
+      dokku_log_warn "$PLUGIN_SERVICE service $SERVICE is restarting and may cause issues with linked app $APP"
+      continue
+    fi
+
+    dokku_log_warn "$PLUGIN_SERVICE service $SERVICE is not running, issuing service start"
+    service_start "$SERVICE"
+  done
+}
+
+plugin-pre-start "$@"

service-list

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/common-functions"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+
+plugin-service-list() {
+  declare desc="allows listing all services for use by other dokku plugins"
+  declare SERVICE_TYPE="$1"
+
+  if [[ -n "$SERVICE_TYPE" ]] && [[ "$SERVICE_TYPE" != "$PLUGIN_COMMAND_PREFIX" ]]; then
+    return
+  fi
+
+  for service in $(fn-services-list false); do
+    echo "$PLUGIN_COMMAND_PREFIX:$service"
+  done
+}
+
+plugin-service-list "$@"

subcommands/app-links

@@ -1,7 +1,8 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-app-links-cmd() {
@@ -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,21 +1,25 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-cmd() {
-  #E backup the 'lolipop' service to the 'my-s3-bucket' bucket on AWS
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup lolipop my-s3-bucket --use-iam
+  #E backup the 'lollipop' service to the 'my-s3-bucket' bucket on AWS
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup lollipop my-s3-bucket --use-iam
+  #E restore a backup file (assuming it was extracted via 'tar -xf backup.tgz')
+  #E dokku $PLUGIN_COMMAND_PREFIX:import lollipop < backup-folder/export
   #F -u|--use-iam, use the IAM profile associated with the current server
   #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
+  declare desc="create a backup of the $PLUGIN_SERVICE service to an existing s3 bucket"
+  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,30 +1,32 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-auth-cmd() {
   #E setup s3 backup authentication
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lollipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY
   #E setup s3 backup authentication with different region
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lollipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION
   #E setup s3 backup authentication with different signature version and endpoint
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lolipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION AWS_SIGNATURE_VERSION ENDPOINT_URL
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lollipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION AWS_SIGNATURE_VERSION ENDPOINT_URL
   #E more specific example for minio auth
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lolipop MINIO_ACCESS_KEY_ID MINIO_SECRET_ACCESS_KEY us-east-1 s3v4 https://YOURMINIOSERVICE
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-auth lollipop MINIO_ACCESS_KEY_ID MINIO_SECRET_ACCESS_KEY us-east-1 s3v4 https://YOURMINIOSERVICE
   #A service, service to run command against
   #A access-key-id, an amazon AWS_ACCESS_KEY_ID
   #A aws-secret-access-key, an amazon AWS_SECRET_ACCESS_KEY
   #A aws-default-region, (optional) a valid amazon S3 region
   #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
+  declare desc="set up authentication for backups on the $PLUGIN_SERVICE service"
+  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,19 +1,21 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-deauth-cmd() {
   #E remove s3 authentication
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-deauth lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-deauth lollipop
   #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
+  declare desc="remove backup authentication for the $PLUGIN_SERVICE service"
+  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,25 +1,27 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-schedule-cmd() {
   #E schedule a backup
   #E > 'schedule' is a crontab expression, eg. "0 3 * * *" for each day at 3am
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-schedule lolipop "0 3 * * *" my-s3-bucket
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-schedule lollipop "0 3 * * *" my-s3-bucket
   #E schedule a backup and authenticate via iam
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-schedule lolipop "0 3 * * *" my-s3-bucket --use-iam
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-schedule lollipop "0 3 * * *" my-s3-bucket --use-iam
   #F -u|--use-iam, use the IAM profile associated with the current server
   #A service, service to run command against
   #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
+  declare desc="schedule a backup of the $PLUGIN_SERVICE service"
+  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,18 +1,20 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-schedule-cat-cmd() {
   #E cat the contents of the configured backup cronfile for the service
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-schedule-cat lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-schedule-cat lollipop
   #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
-source "$PLUGIN_BASE_PATH/common/functions"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_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 dokku $PLUGIN_COMMAND_PREFIX:backup-set-encryption lolipop
+  #E set the GPG-compatible passphrase for encrypting backups for backups
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-set-encryption lollipop
   #A service, service to run command against
-  #A encryption-key, a GPG encryption key
-  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
-  declare SERVICE="$1" ENCRYPTION_KEY="$2"
+  #A passphrase, a GPG-compatible passphrase
+  declare desc="set encryption for all future backups of $PLUGIN_SERVICE service"
+  local cmd="$PLUGIN_COMMAND_PREFIX:backup-set-encryption" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" PASSPHRASE="$2"
   is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a name for the service"
-  [[ -z "$ENCRYPTION_KEY" ]] && dokku_log_fail "Please specify a GPG encryption key"
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
+  [[ -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,19 +1,21 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-unschedule-cmd() {
   #E remove the scheduled backup from cron
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-unschedule lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-unschedule lollipop
   #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
+  declare desc="unschedule the backup of the $PLUGIN_SERVICE service"
+  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,19 +1,21 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-backup-unset-encryption-cmd() {
-  #E unset a GPG encryption key for backups
-  #E dokku $PLUGIN_COMMAND_PREFIX:backup-unset-encryption lolipop
+  #E unset the GPG encryption passphrase for backups
+  #E dokku $PLUGIN_COMMAND_PREFIX:backup-unset-encryption lollipop
   #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
+  declare desc="unset encryption for future backups of the $PLUGIN_SERVICE service"
+  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,41 +1,52 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-clone-cmd() {
   #E you can clone an existing service to a new one
-  #E dokku $PLUGIN_COMMAND_PREFIX:clone lolipop lolipop-2
+  #E dokku $PLUGIN_COMMAND_PREFIX:clone lollipop lollipop-2
   #A service, service to run command against
   #A new-service, name of new service
+  #F -c|--config-options "--args --go=here", extra arguments to pass to the container create command
   #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 -m|--memory MEMORY, container memory limit in megabytes (default: unlimited)
+  #F -N|--initial-network INITIAL_NETWORK, the initial network to attach the service to
   #F -p|--password PASSWORD, override the user-level service password
+  #F -P|--post-create-network NETWORKS, a comman-separated list of networks to attach the service container to after service creation
   #F -r|--root-password PASSWORD, override the root-level service password
+  #F -S|--post-start-network NETWORKS, a comman-separated list of networks to attach the service container to after service start
+  #F -s|--shm-size SHM_SIZE, override shared memory size for $PLUGIN_COMMAND_PREFIX docker container
   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
-  declare SERVICE="$1" NEW_SERVICE="$2" CLONE_FLAGS_LIST="${@:3}"
+  local cmd="$PLUGIN_COMMAND_PREFIX:clone" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" NEW_SERVICE="$2" CLONE_FLAGS_LIST=("${@:3}")
   is_implemented_command "$cmd" || dokku_log_fail "Not yet implemented"
 
-  [[ -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"
+  if service_exists "$NEW_SERVICE"; then
+    dokku_log_fail "Invalid service name $NEW_SERVICE. Verify the service name is not already in use."
+  fi
 
   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"
 
-  PLUGIN_IMAGE=$(service_version "$SERVICE" |  grep -o "^.*:" | sed -r "s/://g")
-  PLUGIN_IMAGE_VERSION=$(service_version "$SERVICE" |  grep -o ":.*$" | sed -r "s/://g")
+  PLUGIN_IMAGE=$(service_version "$SERVICE" | grep -o "^.*:" | sed -r "s/://g")
+  PLUGIN_IMAGE_VERSION=$(service_version "$SERVICE" | grep -o ":.*$" | sed -r "s/://g")
 
   service_parse_args "${@:3}"
 
   dokku_log_info2 "Cloning $SERVICE to $NEW_SERVICE @ $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION"
   service_create "$NEW_SERVICE" "${@:3}"
   dokku_log_info1 "Copying data from $SERVICE to $NEW_SERVICE"
-  service_export "$SERVICE" | service_import "$NEW_SERVICE" > /dev/null 2>&1 || true
+  service_export "$SERVICE" | service_import "$NEW_SERVICE" >/dev/null 2>&1 || true
   dokku_log_info2 "Done"
 }
 

subcommands/connect

@@ -1,19 +1,22 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-connect-cmd() {
   #E connect to the service via the $PLUGIN_COMMAND_PREFIX connection tool
-  #E dokku $PLUGIN_COMMAND_PREFIX:connect lolipop
+  #E > NOTE: disconnecting from ssh while running this command may leave zombie processes due to moby/moby#9098
+  #E dokku $PLUGIN_COMMAND_PREFIX:connect lollipop
   #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/create

@@ -1,30 +1,38 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-create-cmd() {
-  #E create a $PLUGIN_COMMAND_PREFIX service named lolipop
-  #E dokku $PLUGIN_COMMAND_PREFIX:create lolipop
+  #E create a $PLUGIN_COMMAND_PREFIX service named lollipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:create lollipop
   #E you can also specify the image and image version to use for the service.
   #E it *must* be compatible with the ${PLUGIN_IMAGE} image.
-  #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 export ${PLUGIN_VARIABLE}_IMAGE="${PLUGIN_IMAGE}"
+  #E export ${PLUGIN_VARIABLE}_IMAGE_VERSION="${PLUGIN_IMAGE_VERSION}"
+  #E dokku $PLUGIN_COMMAND_PREFIX:create lollipop
   #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
+  #E export ${PLUGIN_VARIABLE}_CUSTOM_ENV="USER=alpha;HOST=beta"
+  #E dokku $PLUGIN_COMMAND_PREFIX:create lollipop
   #A service, service to run command against
+  #F -c|--config-options "--args --go=here", extra arguments to pass to the container create command
   #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 -m|--memory MEMORY, container memory limit in megabytes (default: unlimited)
+  #F -N|--initial-network INITIAL_NETWORK, the initial network to attach the service to
   #F -p|--password PASSWORD, override the user-level service password
+  #F -P|--post-create-network NETWORKS, a comman-separated list of networks to attach the service container to after service creation
   #F -r|--root-password PASSWORD, override the root-level service password
+  #F -S|--post-start-network NETWORKS, a comman-separated list of networks to attach the service container to after service start
+  #F -s|--shm-size SHM_SIZE, override shared memory size for $PLUGIN_COMMAND_PREFIX docker container
   declare desc="create a $PLUGIN_SERVICE service"
-  local cmd="$PLUGIN_COMMAND_PREFIX:create" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
-  declare SERVICE="$1" CREATE_FLAGS_LIST="${@:2}"
+  local cmd="$PLUGIN_COMMAND_PREFIX:create" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" CREATE_FLAGS_LIST=("${@:2}")
 
   service_create "$SERVICE" "${@:2}"
 }

subcommands/destroy

@@ -1,21 +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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-destroy-cmd() {
   #E destroy the service, it's data, and the running container
-  #E dokku $PLUGIN_COMMAND_PREFIX:destroy lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:destroy lollipop
   #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,22 +41,17 @@ service-destroy-cmd() {
   fi
 
   dokku_log_info2_quiet "Deleting $SERVICE"
-  if [[ -n $(docker ps -aq -f name="$SERVICE_NAME") ]]; then
-    dokku_log_verbose_quiet "Deleting container data"
-    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
+  plugn trigger service-action pre-delete "$PLUGIN_COMMAND_PREFIX" "$SERVICE"
+  service_backup_unschedule "$SERVICE"
+  service_container_rm "$SERVICE"
 
   dokku_log_verbose_quiet "Removing data"
-  docker run --rm -v "$SERVICE_HOST_ROOT/data:/data" -v "$SERVICE_HOST_ROOT/config:/config" busybox chmod 777 -R /config /data
+  "$DOCKER_BIN" container run --rm -v "$SERVICE_HOST_ROOT/data:/data" -v "$SERVICE_HOST_ROOT/$PLUGIN_CONFIG_SUFFIX:/config" "$PLUGIN_BUSYBOX_IMAGE" chmod 777 -R /config /data
   rm -rf "$SERVICE_ROOT"
 
+  fn-plugin-property-destroy "$PLUGIN_COMMAND_PREFIX" "$SERVICE"
+
+  plugn trigger service-action post-delete "$PLUGIN_COMMAND_PREFIX" "$SERVICE"
   dokku_log_info2 "$PLUGIN_SERVICE container deleted: $SERVICE"
 }
 

subcommands/enter

@@ -1,21 +1,25 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-enter-cmd() {
   #E a bash prompt can be opened against a running service.
   #E filesystem changes will not be saved to disk.
-  #E dokku $PLUGIN_COMMAND_PREFIX:enter lolipop
+  #E > NOTE: disconnecting from ssh while running this command may leave zombie processes due to moby/moby#9098
+  #E dokku $PLUGIN_COMMAND_PREFIX:enter lollipop
   #E you may also run a command directly against the service.
   #E filesystem changes will not be saved to disk.
-  #E dokku $PLUGIN_COMMAND_PREFIX:enter lolipop touch /tmp/test
+  #E dokku $PLUGIN_COMMAND_PREFIX:enter lollipop 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"
 
+  verify_service_name "$SERVICE"
   dokku_log_info1_quiet "Filesystem changes may not persist after container restarts"
   service_enter "$SERVICE" "${@:2}"
 }

subcommands/exists

@@ -1,18 +1,20 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-exists-cmd() {
-  #E here we check if the lolipop $PLUGIN_COMMAND_PREFIX service exists.
-  #E dokku $PLUGIN_COMMAND_PREFIX:exists lolipop
+  #E here we check if the lollipop $PLUGIN_COMMAND_PREFIX service exists.
+  #E dokku $PLUGIN_COMMAND_PREFIX:exists lollipop
   #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,21 +1,23 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-export-cmd() {
   #E by default, datastore output is exported to stdout
-  #E dokku $PLUGIN_COMMAND_PREFIX:export lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:export lollipop
   #E you can redirect this output to a file
-  #E dokku $PLUGIN_COMMAND_PREFIX:export lolipop > lolipop.dump
+  #E dokku $PLUGIN_COMMAND_PREFIX:export lollipop > data.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,19 +1,23 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-expose-cmd() {
   #E expose the service on the service's normal ports, allowing access to it from the public interface (0.0.0.0)
-  #E dokku $PLUGIN_COMMAND_PREFIX:expose lolipop ${PLUGIN_DATASTORE_PORTS[@]}
+  #E dokku $PLUGIN_COMMAND_PREFIX:expose lollipop ${PLUGIN_DATASTORE_PORTS[@]}
+  #E expose the service on the service's normal ports, with the first on a specified ip adddress (127.0.0.1)
+  #E dokku $PLUGIN_COMMAND_PREFIX:expose lollipop 127.0.0.1:${PLUGIN_DATASTORE_PORTS[@]}
   #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
-  declare SERVICE="$1" PORTS_LIST="${@:2}"
+  declare desc="expose a $PLUGIN_SERVICE service on custom host:port if provided (random port on the 0.0.0.0 interface if otherwise unspecified)"
+  local cmd="$PLUGIN_COMMAND_PREFIX:expose" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" PORTS_LIST=("${@:2}")
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a 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,19 +1,21 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-import-cmd() {
   #E import a datastore dump
-  #E dokku $PLUGIN_COMMAND_PREFIX:import lolipop < database.dump
+  #E dokku $PLUGIN_COMMAND_PREFIX:import lollipop < data.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,23 +1,27 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-info-cmd() {
   #E get connection information as follows:
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop
   #E you can also retrieve a specific piece of service info via flags:
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --config-dir
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --data-dir
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --dsn
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --exposed-ports
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --id
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --internal-ip
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --links
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --service-root
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --status
-  #E dokku $PLUGIN_COMMAND_PREFIX:info lolipop --version
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --config-dir
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --data-dir
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --dsn
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --exposed-ports
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --id
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --internal-ip
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --initial-network
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --links
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --post-create-network
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --post-start-network
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --service-root
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --status
+  #E dokku $PLUGIN_COMMAND_PREFIX:info lollipop --version
   #A service, service to run command against
   #F --config-dir, show the service configuration directory
   #F --data-dir, show the service data directory
@@ -25,15 +29,19 @@ service-info-cmd() {
   #F --exposed-ports, show service exposed ports
   #F --id, show the service container id
   #F --internal-ip, show the service internal ip
+  #F --initial-network, show the initial network being connected to
   #F --links, show the service app links
+  #F --post-create-network, show the networks to attach to after service container creation
+  #F --post-start-network, show the networks to attach to after service container start
   #F --service-root, show the service root directory
   #F --status, show the service running status
   #F --version, show the service image version
-  declare desc="print the connection information"
-  local cmd="$PLUGIN_COMMAND_PREFIX:info" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare desc="print the service information"
+  local cmd="$PLUGIN_COMMAND_PREFIX:info" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
   declare SERVICE="$1" INFO_FLAG="$2"
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a 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,7 +1,8 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-link-cmd() {
@@ -9,44 +10,46 @@ service-link-cmd() {
   #E this will use native docker links via the docker-options plugin.
   #E here we link it to our 'playground' app.
   #E > NOTE: this will restart your app
-  #E dokku $PLUGIN_COMMAND_PREFIX:link lolipop playground
+  #E dokku $PLUGIN_COMMAND_PREFIX:link lollipop playground
   #E the following environment variables will be set automatically by docker
   #E (not on the app itself, so they won’t be listed when calling dokku config):
   #E
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_LOLIPOP_NAME=/lolipop/DATABASE
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_LOLIPOP_PORT=tcp://172.17.0.1:${PLUGIN_DATASTORE_PORTS[0]}
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_LOLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP=tcp://172.17.0.1:${PLUGIN_DATASTORE_PORTS[0]}
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_LOLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP_PROTO=tcp
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_LOLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP_PORT=${PLUGIN_DATASTORE_PORTS[0]}
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_LOLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP_ADDR=172.17.0.1
+  #E     DOKKU_${PLUGIN_VARIABLE}_LOLLIPOP_NAME=/lollipop/DATABASE
+  #E     DOKKU_${PLUGIN_VARIABLE}_LOLLIPOP_PORT=tcp://172.17.0.1:${PLUGIN_DATASTORE_PORTS[0]}
+  #E     DOKKU_${PLUGIN_VARIABLE}_LOLLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP=tcp://172.17.0.1:${PLUGIN_DATASTORE_PORTS[0]}
+  #E     DOKKU_${PLUGIN_VARIABLE}_LOLLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP_PROTO=tcp
+  #E     DOKKU_${PLUGIN_VARIABLE}_LOLLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP_PORT=${PLUGIN_DATASTORE_PORTS[0]}
+  #E     DOKKU_${PLUGIN_VARIABLE}_LOLLIPOP_PORT_${PLUGIN_DATASTORE_PORTS[0]}_TCP_ADDR=172.17.0.1
   #E
   #E the following will be set on the linked application by default:
   #E
-  #E     ${PLUGIN_DEFAULT_ALIAS}_URL=${PLUGIN_SCHEME}://lolipop:SOME_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-lolipop:${PLUGIN_DATASTORE_PORTS[0]}/lolipop
+  #E     ${PLUGIN_DEFAULT_ALIAS}_URL=${PLUGIN_SCHEME}://:SOME_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-lollipop:${PLUGIN_DATASTORE_PORTS[0]}
   #E
   #E the host exposed here only works internally in docker containers.
   #E if you want your container to be reachable from outside, you should
   #E use the 'expose' subcommand. another service can be linked to your app:
   #E dokku $PLUGIN_COMMAND_PREFIX:link other_service playground
   #E it is possible to change the protocol for ${PLUGIN_DEFAULT_ALIAS}_URL by setting the
-  #E environment variable ${PLUGIN_DEFAULT_ALIAS}_DATABASE_SCHEME on the app. doing so will
+  #E environment variable ${PLUGIN_VARIABLE}_DATABASE_SCHEME on the app. doing so will
   #E after linking will cause the plugin to think the service is not
   #E linked, and we advise you to unlink before proceeding.
-  #E dokku config:set playground ${PLUGIN_DEFAULT_ALIAS}_DATABASE_SCHEME=${PLUGIN_SCHEME}2
-  #E dokku $PLUGIN_COMMAND_PREFIX:link lolipop playground
+  #E dokku config:set playground ${PLUGIN_VARIABLE}_DATABASE_SCHEME=${PLUGIN_SCHEME}2
+  #E dokku $PLUGIN_COMMAND_PREFIX:link lollipop playground
   #E this will cause ${PLUGIN_DEFAULT_ALIAS}_URL to be set as:
   #E
-  #E     ${PLUGIN_SCHEME}2://lolipop:SOME_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-lolipop:${PLUGIN_DATASTORE_PORTS[0]}/lolipop
+  #E     ${PLUGIN_SCHEME}2://:SOME_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-lollipop:${PLUGIN_DATASTORE_PORTS[0]}
   #A service, service to run command against
   #A app, app to run command against
   #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
+  #F -n|--no-restart "false", whether or not to restart the app on link (default: true)
   declare desc="link the $PLUGIN_SERVICE service to the app"
-  local cmd="$PLUGIN_COMMAND_PREFIX:link" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
-  declare SERVICE="$1" APP="$2" LINK_FLAGS_LIST="${@:3}"
+  local cmd="$PLUGIN_COMMAND_PREFIX:link" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" APP="$2" LINK_FLAGS_LIST=("${@:3}")
   APP=${APP:="$DOKKU_APP_NAME"}
 
-  [[ -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,20 +1,22 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-linked-cmd() {
-  #E here we check if the lolipop $PLUGIN_COMMAND_PREFIX service is linked to the 'playground' app.
-  #E dokku $PLUGIN_COMMAND_PREFIX:linked lolipop playground
+  #E here we check if the lollipop $PLUGIN_COMMAND_PREFIX service is linked to the 'playground' app.
+  #E dokku $PLUGIN_COMMAND_PREFIX:linked lollipop playground
   #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_CORE_AVAILABLE_PATH/common/functions"
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
+
+service-links-cmd() {
+  #E list all apps linked to the 'lollipop' $PLUGIN_COMMAND_PREFIX service.
+  #E dokku $PLUGIN_COMMAND_PREFIX:links lollipop
+  #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,14 +1,16 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 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,23 +1,27 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-logs-cmd() {
   #E you can tail logs for a particular service:
-  #E dokku $PLUGIN_COMMAND_PREFIX:logs lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:logs lollipop
   #E by default, logs will not be tailed, but you can do this with the --tail flag:
-  #E dokku $PLUGIN_COMMAND_PREFIX:logs lolipop --tail
+  #E dokku $PLUGIN_COMMAND_PREFIX:logs lollipop --tail
+  #E the default tail setting is to show all logs, but an initial count can also be specified
+  #E dokku $PLUGIN_COMMAND_PREFIX:logs lollipop --tail 5
   #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
+  #F -t|--tail [<tail-num>], 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
-  declare SERVICE="$1" TAIL_FLAG="$2"
+  local cmd="$PLUGIN_COMMAND_PREFIX:logs" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" TAIL_FLAG="$2" TAIL_NUM_OPTIONAL="${3:-all}"
 
-  [[ -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"
+  service_logs "$SERVICE" "$TAIL_FLAG" "$TAIL_NUM_OPTIONAL"
 }
 
 service-logs-cmd "$@"

subcommands/pause

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
+
+service-pause-cmd() {
+  #E pause the running container for the service
+  #E dokku $PLUGIN_COMMAND_PREFIX:pause lollipop
+  #A service, service to run command against
+  declare desc="pause a running $PLUGIN_SERVICE service"
+  local cmd="$PLUGIN_COMMAND_PREFIX:pause" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1"
+
+  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a valid name for the service"
+  verify_service_name "$SERVICE"
+  service_pause "$SERVICE"
+}
+
+service-pause-cmd "$@"

subcommands/promote

@@ -1,14 +1,15 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-promote-cmd() {
   #E if you have a $PLUGIN_COMMAND_PREFIX service linked to an app and try to link another $PLUGIN_COMMAND_PREFIX service
   #E another link environment variable will be generated automatically:
   #E
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_BLUE_URL=${PLUGIN_SCHEME}://other_service:ANOTHER_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-other-service:${PLUGIN_DATASTORE_PORTS[0]}/other_service
+  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_BLUE_URL=${PLUGIN_SCHEME}://:ANOTHER_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-other-service:${PLUGIN_DATASTORE_PORTS[0]}/other_service
   #E
   #E you can promote the new service to be the primary one
   #E > NOTE: this will restart your app
@@ -17,17 +18,18 @@ service-promote-cmd() {
   #E another environment variable to hold the previous value if necessary.
   #E you could end up with the following for example:
   #E
-  #E     ${PLUGIN_DEFAULT_ALIAS}_URL=${PLUGIN_SCHEME}://other_service:ANOTHER_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-other-service:${PLUGIN_DATASTORE_PORTS[0]}/other_service
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_BLUE_URL=${PLUGIN_SCHEME}://other_service:ANOTHER_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-other-service:${PLUGIN_DATASTORE_PORTS[0]}/other_service
-  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_SILVER_URL=${PLUGIN_SCHEME}://lolipop:SOME_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-lolipop:${PLUGIN_DATASTORE_PORTS[0]}/lolipop
+  #E     ${PLUGIN_DEFAULT_ALIAS}_URL=${PLUGIN_SCHEME}://:ANOTHER_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-other-service:${PLUGIN_DATASTORE_PORTS[0]}/other_service
+  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_BLUE_URL=${PLUGIN_SCHEME}://:ANOTHER_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-other-service:${PLUGIN_DATASTORE_PORTS[0]}/other_service
+  #E     DOKKU_${PLUGIN_DEFAULT_ALIAS}_SILVER_URL=${PLUGIN_SCHEME}://:SOME_PASSWORD@dokku-${PLUGIN_COMMAND_PREFIX}-lollipop:${PLUGIN_DATASTORE_PORTS[0]}/lollipop
   #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,20 +1,22 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-restart-cmd() {
   #E restart the service
-  #E dokku $PLUGIN_COMMAND_PREFIX:restart lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:restart lollipop
   #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_pause "$SERVICE"
   service_start "$SERVICE"
   dokku_log_info1 "Please call dokku ps:restart on all linked apps"
 }

subcommands/set

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/property-functions"
+source "$(cd "$(dirname "$(dirname "${BASH_SOURCE[0]}")")" && pwd)/common-functions"
+
+service-set-cmd() {
+  #E set the network to attach after the service container is started
+  #E dokku $PLUGIN_COMMAND_PREFIX:set lollipop post-create-network custom-network
+  #E set multiple networks
+  #E dokku $PLUGIN_COMMAND_PREFIX:set lollipop post-create-network custom-network,other-network
+  #E unset the post-create-network value
+  #E dokku $PLUGIN_COMMAND_PREFIX:set lollipop post-create-network
+  #A service, service to run command against
+  #A key, property name to set
+  #A value, optional property value to set or empty to unset key
+  declare desc="set or clear a property for a service"
+  local cmd="$PLUGIN_COMMAND_PREFIX:set" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" KEY="$2" VALUE="$3"
+  local VALID_KEYS=("initial-network" "post-create-network" "post-start-network")
+  verify_service_name "$SERVICE"
+
+  [[ -z "$KEY" ]] && dokku_log_fail "No key specified"
+
+  if ! fn-in-array "$KEY" "${VALID_KEYS[@]}"; then
+    dokku_log_fail "Invalid key specified, valid keys include: initial-network, post-create-network, post-start-network"
+  fi
+
+  if [[ -n "$VALUE" ]]; then
+    dokku_log_info2_quiet "Setting ${KEY} to ${VALUE}"
+    fn-plugin-property-write "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "$KEY" "$VALUE"
+  else
+    dokku_log_info2_quiet "Unsetting ${KEY}"
+    if [[ "$KEY" == "rev-env-var" ]]; then
+      fn-plugin-property-write "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "$KEY" "$VALUE"
+    else
+      fn-plugin-property-delete "$PLUGIN_COMMAND_PREFIX" "$SERVICE" "$KEY"
+    fi
+  fi
+}
+
+service-set-cmd "$@"

subcommands/start

@@ -1,18 +1,20 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-start-cmd() {
   #E start the service
-  #E dokku $PLUGIN_COMMAND_PREFIX:start lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:start lollipop
   #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,20 +1,22 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-stop-cmd() {
-  #E stop the service and the running container
-  #E dokku $PLUGIN_COMMAND_PREFIX:stop lolipop
+  #E stop the service and removes the running container
+  #E dokku $PLUGIN_COMMAND_PREFIX:stop lollipop
   #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"
+  service_container_rm "$SERVICE"
 }
 
 service-stop-cmd "$@"

subcommands/unexpose

@@ -1,18 +1,20 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-unexpose-cmd() {
   #E unexpose the service, removing access to it from the public interface (0.0.0.0)
-  #E dokku $PLUGIN_COMMAND_PREFIX:unexpose lolipop
+  #E dokku $PLUGIN_COMMAND_PREFIX:unexpose lollipop
   #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,21 +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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"
 
 service-unlink-cmd() {
   #E you can unlink a $PLUGIN_COMMAND_PREFIX service
   #E > NOTE: this will restart your app and unset related environment variables
-  #E dokku $PLUGIN_COMMAND_PREFIX:unlink lolipop playground
+  #E dokku $PLUGIN_COMMAND_PREFIX:unlink lollipop playground
   #A service, service to run command against
   #A app, app to run command against
+  #F -n|--no-restart "false", whether or not to restart the app on unlink (default: true)
   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,39 +1,59 @@
 #!/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"
+set -eo pipefail
+[[ $DOKKU_TRACE ]] && set -x
+source "$PLUGIN_CORE_AVAILABLE_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
+  #E dokku $PLUGIN_COMMAND_PREFIX:upgrade lollipop
   #A service, service to run command against
+  #F -c|--config-options "--args --go=here", extra arguments to pass to the container create command
   #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 -R|--restart-apps "true", whether to force an app restart
+  #F -N|--initial-network INITIAL_NETWORK, the initial network to attach the service to
+  #F -P|--post-create-network NETWORKS, a comman-separated list of networks to attach the service container to after service creation
+  #F -R|--restart-apps "true", whether or not to force an app restart (default: false)
+  #F -S|--post-start-network NETWORKS, a comman-separated list of networks to attach the service container to after service start
+  #F -s|--shm-size SHM_SIZE, override shared memory size for $PLUGIN_COMMAND_PREFIX docker container
   declare desc="upgrade service <service> to the specified versions"
-  local cmd="$PLUGIN_COMMAND_PREFIX:upgrade" argv=("$@"); [[ ${argv[0]} == "$cmd" ]] && shift 1
-  declare SERVICE="$1" UPGRADE_FLAG_LIST="${@:2}"
+  local cmd="$PLUGIN_COMMAND_PREFIX:upgrade" argv=("$@")
+  [[ ${argv[0]} == "$cmd" ]] && shift 1
+  declare SERVICE="$1" UPGRADE_FLAGS_LIST=("${@:2}")
 
-  [[ -z "$SERVICE" ]] && dokku_log_fail "Please specify a 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}"
 
-  if ! service_image_exists "$SERVICE"; then
-    dokku_log_fail "Unable to proceed with upgrade, image ${PLUGIN_IMAGE}:${PLUGIN_IMAGE_VERSION} does not exist"
+  if ! service_image_exists "$SERVICE" "$PLUGIN_IMAGE" "$PLUGIN_IMAGE_VERSION"; then
+    if [[ "$PLUGIN_DISABLE_PULL" == "true" ]]; then
+      dokku_log_warn "${PLUGIN_DISABLE_PULL_VARIABLE} environment variable detected. Not running pull command." 1>&2
+      dokku_log_warn "   docker image pull ${IMAGE}" 1>&2
+      dokku_log_warn "$PLUGIN_SERVICE service $SERVICE upgrade failed"
+      exit 1
+    fi
+    "$DOCKER_BIN" image pull "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" || dokku_log_fail "$PLUGIN_SERVICE image $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION pull failed"
   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
+
+  service_commit_config "$SERVICE"
+
+  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
@@ -45,6 +65,7 @@ service-upgrade-cmd() {
   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

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.2.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                                4.0.11               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:4.0.11                                "/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/sudo

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

tests/hook_pre_delete.bats

@@ -2,19 +2,19 @@
 load test_helper
 
 setup() {
-  dokku apps:create my_app >&2
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app >&2
+  dokku apps:create my-app
+  dokku "$PLUGIN_COMMAND_PREFIX:create" ls
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app >&2
 }
 
 teardown() {
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app >&2
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
-  rm -rf "$DOKKU_ROOT/my_app"
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" ls
+  dokku --force apps:destroy my-app || true
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:hook:pre-delete) removes app from links file when destroying app" {
-  [[ -n $(< "$PLUGIN_DATA_ROOT/l/LINKS") ]]
-  dokku --force apps:destroy my_app
-  [[ -z $(< "$PLUGIN_DATA_ROOT/l/LINKS") ]]
+  [[ -n $(<"$PLUGIN_DATA_ROOT/ls/LINKS") ]]
+  dokku --force apps:destroy my-app
+  [[ -z $(<"$PLUGIN_DATA_ROOT/ls/LINKS") ]]
 }

tests/link_networks.bats

@@ -0,0 +1,289 @@
+#!/usr/bin/env bats
+load test_helper
+
+setup() {
+  dokku "$PLUGIN_COMMAND_PREFIX:create" ls
+  dokku network:create custom-network
+}
+
+teardown() {
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" ls || true
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" lsa || true
+  dokku network:destroy --force custom-network
+}
+
+@test "($PLUGIN_COMMAND_PREFIX:set) set initial-network" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:set" ls initial-network custom-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:info" ls --initial-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_output "custom-network"
+  assert_success
+
+  run docker inspect dokku.$PLUGIN_COMMAND_PREFIX.ls -f '{{range $net,$v := .NetworkSettings.Networks}}{{printf "%s\n" $net}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains bridge
+  assert_output_contains custom-network 0
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:stop" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:start" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run docker inspect dokku.$PLUGIN_COMMAND_PREFIX.ls -f '{{range $net,$v := .NetworkSettings.Networks}}{{printf "%s\n" $net}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains bridge 0
+  assert_output_contains custom-network
+
+  run docker inspect dokku.$PLUGIN_COMMAND_PREFIX.ls -f '{{range $net,$v := .NetworkSettings.Networks}}{{range $k,$alias := $v.Aliases}}{{printf "alias:%s\n" $alias}}{{end}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains "alias:dokku.$PLUGIN_COMMAND_PREFIX.ls"
+  assert_output_contains "alias:dokku-$PLUGIN_COMMAND_PREFIX-ls"
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:set" ls initial-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:info" ls --initial-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_output ""
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:stop" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:start" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run docker inspect dokku.$PLUGIN_COMMAND_PREFIX.ls -f '{{range $net,$v := .NetworkSettings.Networks}}{{printf "%s\n" $net}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains bridge
+  assert_output_contains custom-network 0
+}
+
+@test "($PLUGIN_COMMAND_PREFIX:set) set post-create-network" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:set" ls post-create-network custom-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:info" ls --post-create-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_output "custom-network"
+  assert_success
+
+  run docker inspect dokku.$PLUGIN_COMMAND_PREFIX.ls -f '{{range $net,$v := .NetworkSettings.Networks}}{{printf "%s\n" $net}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains bridge
+  assert_output_contains custom-network 0
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:stop" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:start" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run docker inspect dokku.$PLUGIN_COMMAND_PREFIX.ls -f '{{range $net,$v := .NetworkSettings.Networks}}{{printf "%s\n" $net}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains custom-network
+  assert_output_contains bridge
+
+  run docker inspect dokku.$PLUGIN_COMMAND_PREFIX.ls -f '{{range $net,$v := .NetworkSettings.Networks}}{{range $k,$alias := $v.Aliases}}{{printf "alias:%s\n" $alias}}{{end}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains "alias:dokku.$PLUGIN_COMMAND_PREFIX.ls"
+  assert_output_contains "alias:dokku-$PLUGIN_COMMAND_PREFIX-ls"
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:set" ls post-create-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:info" ls --post-create-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_output ""
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:stop" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:start" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run docker inspect dokku.$PLUGIN_COMMAND_PREFIX.ls -f '{{range $net,$v := .NetworkSettings.Networks}}{{printf "%s\n" $net}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains bridge
+  assert_output_contains custom-network 0
+}
+
+@test "($PLUGIN_COMMAND_PREFIX:set) set an post-start-network" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:set" ls post-start-network custom-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:info" ls --post-start-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_output "custom-network"
+  assert_success
+
+  run docker inspect dokku.$PLUGIN_COMMAND_PREFIX.ls -f '{{range $net,$v := .NetworkSettings.Networks}}{{printf "%s\n" $net}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains bridge
+  assert_output_contains custom-network 0
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:stop" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:start" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run docker inspect dokku.$PLUGIN_COMMAND_PREFIX.ls -f '{{range $net,$v := .NetworkSettings.Networks}}{{printf "%s\n" $net}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains bridge
+  assert_output_contains custom-network
+
+  run docker inspect dokku.$PLUGIN_COMMAND_PREFIX.ls -f '{{range $net,$v := .NetworkSettings.Networks}}{{range $k,$alias := $v.Aliases}}{{printf "alias:%s\n" $alias}}{{end}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains "alias:dokku.$PLUGIN_COMMAND_PREFIX.ls"
+  assert_output_contains "alias:dokku-$PLUGIN_COMMAND_PREFIX-ls"
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:set" ls post-start-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:info" ls --post-start-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_output ""
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:stop" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:start" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run docker inspect dokku.$PLUGIN_COMMAND_PREFIX.ls -f '{{range $net,$v := .NetworkSettings.Networks}}{{printf "%s\n" $net}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains bridge
+  assert_output_contains custom-network 0
+}
+
+@test "($PLUGIN_COMMAND_PREFIX:create) flags" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:create" lsa --initial-network custom-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run docker inspect "dokku.$PLUGIN_COMMAND_PREFIX.lsa" -f '{{range $net,$v := .NetworkSettings.Networks}}{{printf "%s\n" $net}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains bridge 0
+  assert_output_contains custom-network
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:destroy" lsa --force
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:create" lsa --post-create-network custom-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run docker inspect "dokku.$PLUGIN_COMMAND_PREFIX.lsa" -f '{{range $net,$v := .NetworkSettings.Networks}}{{printf "%s\n" $net}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains bridge
+  assert_output_contains custom-network
+
+  run docker inspect dokku.$PLUGIN_COMMAND_PREFIX.lsa -f '{{range $net,$v := .NetworkSettings.Networks}}{{range $k,$alias := $v.Aliases}}{{printf "alias:%s\n" $alias}}{{end}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains "alias:dokku.$PLUGIN_COMMAND_PREFIX.lsa"
+  assert_output_contains "alias:dokku-$PLUGIN_COMMAND_PREFIX-lsa"
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:destroy" lsa --force
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:create" lsa --post-start-network custom-network
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run docker inspect "dokku.$PLUGIN_COMMAND_PREFIX.lsa" -f '{{range $net,$v := .NetworkSettings.Networks}}{{printf "%s\n" $net}}{{end}}'
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_output_contains bridge
+  assert_output_contains custom-network
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:destroy" lsa --force
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+}

tests/service_clone.bats

@@ -2,34 +2,37 @@
 load test_helper
 
 setup() {
-  export ECHO_DOCKER_COMMAND="false"
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
 
 teardown() {
-  export ECHO_DOCKER_COMMAND="false"
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }
 
 @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_contains "${lines[*]}" "Invalid service name new_service"
+  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 >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
 
 teardown() {
-  export ECHO_DOCKER_COMMAND="false"
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }
 
 @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,7 +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
-  assert_contains 'docker exec -i -t dokku.redis.l redis-cli -a'
+  assert_success
 }

tests/service_create.bats

@@ -4,9 +4,23 @@ 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"
+
+  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 >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
 
 teardown() {
-  export ECHO_DOCKER_COMMAND="false"
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }
 
 @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,20 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:export) success with SSH_TTY" {
-  export ECHO_DOCKER_COMMAND="true"
-  export SSH_TTY=`tty`
+  if [[ -n "$GITHUB_WORKFLOW" ]]; then
+    skip "No tty is available on Github Actions"
+  fi
+  export SSH_TTY=$(tty)
   run dokku "$PLUGIN_COMMAND_PREFIX:export" l
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  echo "output: $output"
+  echo "status: $status"
   assert_exit_status 0
-  assert_output "docker exec dokku.redis.l cat /data/dump.rdb"
 }
 
 @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.redis.l cat /data/dump.rdb"
 }

tests/service_expose.bats

@@ -2,29 +2,65 @@
 load test_helper
 
 setup() {
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" ls
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" ls
 }
 
 @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"
+  echo "output: $output"
+  echo "status: $status"
+  assert_failure
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:expose) error when service does not exist" {
   run dokku "$PLUGIN_COMMAND_PREFIX:expose" not_existing_service
+  echo "output: $output"
+  echo "status: $status"
+  assert_failure
   assert_contains "${lines[*]}" "service not_existing_service does not exist"
 }
 
-@test "($PLUGIN_COMMAND_PREFIX:expose) success when not providing a custom port" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:expose" l
+@test "($PLUGIN_COMMAND_PREFIX:expose) error when already exposed" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:expose" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:expose" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_failure
+  assert_contains "${lines[*]}" "Service ls already exposed on port(s)"
+
+  run sudo rm "$PLUGIN_DATA_ROOT/ls/PORT"
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:expose" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+  assert_contains "${lines[*]}" "Service ls has an untracked expose container, removing"
+}
+
+@test "($PLUGIN_COMMAND_PREFIX:expose) success when not providing custom ports" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:expose" ls
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
   [[ "${lines[*]}" =~ exposed\ on\ port\(s\)\ \[container\-\>host\]\:\ [[:digit:]]+ ]]
 }
 
-@test "($PLUGIN_COMMAND_PREFIX:expose) success when providing a custom port" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:expose" l 4242
+@test "($PLUGIN_COMMAND_PREFIX:expose) success when providing custom ports" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:expose" ls 4242
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
   assert_contains "${lines[*]}" "exposed on port(s) [container->host]: 6379->4242"
 }

tests/service_import.bats

@@ -2,35 +2,39 @@
 load test_helper
 
 setup() {
-  export ECHO_DOCKER_COMMAND="false"
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
-  echo "data" > "$PLUGIN_DATA_ROOT/fake.rdb"
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
+  curl -o "/tmp/fake.rdb" https://raw.githubusercontent.com/sripathikrishnan/redis-rdb-tools/master/tests/dumps/dictionary.rdb
 }
 
 teardown() {
-  export ECHO_DOCKER_COMMAND="false"
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
-  rm -f "$PLUGIN_DATA_ROOT/fake.rdb"
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
+  rm -f "/tmp/fake.rdb"
 }
 
 @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" {
+  if [[ -n "$GITHUB_WORKFLOW" ]]; then
+    skip "No tty is available on Github Actions"
+  fi
   run dokku "$PLUGIN_COMMAND_PREFIX:import" l
   assert_contains "${lines[*]}" "No data provided on stdin"
+  assert_failure
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:import) success" {
-  export ECHO_DOCKER_COMMAND="true"
-  run dokku "$PLUGIN_COMMAND_PREFIX:import" l < "$PLUGIN_DATA_ROOT/fake.rdb"
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  assert_output "docker run --rm -i -v $PLUGIN_DATA_ROOT/l/data:/data redis:4.0.11 bash -c cat > /data/dump.rdb && chown redis: /data/dump.rdb"
+  run dokku "$PLUGIN_COMMAND_PREFIX:import" l <"/tmp/fake.rdb"
+  echo "output: $output"
+  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,22 +21,22 @@ teardown() {
 
 @test "($PLUGIN_COMMAND_PREFIX:info) success" {
   run dokku "$PLUGIN_COMMAND_PREFIX:info" l
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  assert_contains "${lines[*]}" "redis://l:$password@dokku-redis-l:6379"
+  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  assert_contains "${lines[*]}" "redis://:$password@dokku-redis-l:6379"
 }
 
 @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
-  password="$(cat "$PLUGIN_DATA_ROOT/test_with_underscores/PASSWORD")"
-  assert_contains "${lines[*]}" "redis://test_with_underscores:$password@dokku-redis-test-with-underscores:6379"
+  password="$(sudo cat "$PLUGIN_DATA_ROOT/test_with_underscores/PASSWORD")"
+  assert_contains "${lines[*]}" "redis://:$password@dokku-redis-test-with-underscores:6379"
   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
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  assert_output "redis://l:$password@dokku-redis-l:6379"
+  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  assert_output "redis://:$password@dokku-redis-l:6379"
 
   run dokku "$PLUGIN_COMMAND_PREFIX:info" l --config-dir
   assert_success

tests/service_link.bats

@@ -2,84 +2,141 @@
 load test_helper
 
 setup() {
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
-  dokku apps:create my_app >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" ls
+  dokku "$PLUGIN_COMMAND_PREFIX:create" ms
+  dokku apps:create my-app
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
-  rm -rf "$DOKKU_ROOT/my_app"
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" ms
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" ls
+  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
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls
+  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
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls 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
+  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
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  echo "output: $output"
+  echo "status: $status"
   assert_contains "${lines[*]}" "Already linked as REDIS_URL"
+  assert_failure
+
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) exports REDIS_URL to app" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  url=$(dokku config:get my_app REDIS_URL)
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  assert_contains "$url" "redis://l:$password@dokku-redis-l:6379"
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  echo "output: $output"
+  echo "status: $status"
+  url=$(dokku config:get my-app REDIS_URL)
+  password="$(sudo cat "$PLUGIN_DATA_ROOT/ls/PASSWORD")"
+  assert_contains "$url" "redis://:$password@dokku-redis-ls:6379"
+  assert_success
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) generates an alternate config url when REDIS_URL already in use" {
-  dokku config:set my_app REDIS_URL=redis://host:6379
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  run dokku config my_app
-  assert_contains "${lines[*]}" "DOKKU_REDIS_"
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku config:set my-app REDIS_URL=redis://host:6379
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  run dokku config my-app
+  assert_contains "${lines[*]}" "DOKKU_REDIS_AQUA_URL"
+  assert_success
+
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ms my-app
+  run dokku config my-app
+  assert_contains "${lines[*]}" "DOKKU_REDIS_BLACK_URL"
+  assert_success
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ms my-app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls 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
-  assert_contains "${lines[*]}" "--link dokku.redis.l:dokku-redis-l"
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  run dokku docker-options:report my-app
+  assert_contains "${lines[*]}" "--link dokku.redis.ls:dokku-redis-ls"
+  assert_success
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) uses apps REDIS_DATABASE_SCHEME variable" {
-  dokku config:set my_app REDIS_DATABASE_SCHEME=redis2
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  url=$(dokku config:get my_app REDIS_URL)
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  assert_contains "$url" "redis2://l:$password@dokku-redis-l:6379"
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku config:set my-app REDIS_DATABASE_SCHEME=redis2
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  url=$(dokku config:get my-app REDIS_URL)
+  password="$(sudo cat "$PLUGIN_DATA_ROOT/ls/PASSWORD")"
+  assert_contains "$url" "redis2://:$password@dokku-redis-ls:6379"
+  assert_success
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:link) adds a querystring" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app --querystring "pool=5"
-  url=$(dokku config:get my_app REDIS_URL)
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app --querystring "pool=5"
+  url=$(dokku config:get my-app REDIS_URL)
   assert_contains "$url" "?pool=5"
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  assert_success
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls 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")"
-  assert_contains "$url" "redis://l:$password@dokku-redis-l:6379"
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app --alias "ALIAS"
+  url=$(dokku config:get my-app ALIAS_URL)
+  password="$(sudo cat "$PLUGIN_DATA_ROOT/ls/PASSWORD")"
+  assert_contains "$url" "redis://:$password@dokku-redis-ls:6379"
+  assert_success
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
+}
+
+@test "($PLUGIN_COMMAND_PREFIX:link) respects --no-restart" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  echo "output: $output"
+  echo "status: $status"
+  assert_output_contains "Skipping restart of linked app" 0
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app --no-restart
+  echo "output: $output"
+  echo "status: $status"
+  assert_output_contains "Skipping restart of linked app"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
 }

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"
-  assert_contains "${lines[*]}" "l     redis:4.0.11  running  -              -"
-}
-
-@test "($PLUGIN_COMMAND_PREFIX:list) with exposed ports" {
-  dokku "$PLUGIN_COMMAND_PREFIX:expose" l 4242
-  run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "l     redis:4.0.11  running  6379->4242     -"
-}
-
-@test "($PLUGIN_COMMAND_PREFIX:list) with linked app" {
-  dokku apps:create my_app
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "l     redis:4.0.11  running  -              my_app"
-  dokku --force apps:destroy my_app
+  run dokku --quiet "$PLUGIN_COMMAND_PREFIX:list"
+  assert_output "l"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:list) when there are no services" {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
   run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "There are no Redis services"
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  assert_output "${lines[*]}" "There are no $PLUGIN_SERVICE services"
+  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 >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
 
 teardown() {
-  export ECHO_DOCKER_COMMAND="false"
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
 }
 
 @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_pause.bats

@@ -0,0 +1,25 @@
+#!/usr/bin/env bats
+load test_helper
+
+setup() {
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
+}
+
+teardown() {
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
+}
+
+@test "($PLUGIN_COMMAND_PREFIX:pause) error when there are no arguments" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:pause"
+  assert_contains "${lines[*]}" "Please specify a valid name for the service"
+}
+
+@test "($PLUGIN_COMMAND_PREFIX:pause) error when service does not exist" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:pause" not_existing_service
+  assert_contains "${lines[*]}" "service not_existing_service does not exist"
+}
+
+@test "($PLUGIN_COMMAND_PREFIX:pause) success" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:pause" l
+  assert_success
+}

tests/service_promote.bats

@@ -2,20 +2,20 @@
 load test_helper
 
 setup() {
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
-  dokku apps:create my_app >&2
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:create" l
+  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
-  rm -rf "$DOKKU_ROOT/my_app"
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
+  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" {
@@ -29,35 +29,35 @@ teardown() {
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) error when the service does not exist" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:promote" not_existing_service my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:promote" not_existing_service my-app
   assert_contains "${lines[*]}" "service not_existing_service does not exist"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) error when the service is already promoted" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:promote" l my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:promote" l my-app
   assert_contains "${lines[*]}" "already promoted as REDIS_URL"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) changes REDIS_URL" {
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  dokku config:set my_app "REDIS_URL=redis://u:p@host:6379/db" "DOKKU_REDIS_BLUE_URL=redis://l:$password@dokku-redis-l:6379"
-  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my_app
-  url=$(dokku config:get my_app REDIS_URL)
-  assert_equal "$url" "redis://l:$password@dokku-redis-l:6379"
+  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  dokku config:set my-app "REDIS_URL=redis://:p@host:6379/db" "DOKKU_REDIS_BLUE_URL=redis://:$password@dokku-redis-l:6379"
+  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my-app
+  url=$(dokku config:get my-app REDIS_URL)
+  assert_equal "$url" "redis://:$password@dokku-redis-l:6379"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) creates new config url when needed" {
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  dokku config:set my_app "REDIS_URL=redis://u:p@host:6379/db" "DOKKU_REDIS_BLUE_URL=redis://l:$password@dokku-redis-l:6379"
-  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my_app
-  run dokku config my_app
+  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  dokku config:set my-app "REDIS_URL=redis://:p@host:6379/db" "DOKKU_REDIS_BLUE_URL=redis://:$password@dokku-redis-l:6379"
+  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my-app
+  run dokku config my-app
   assert_contains "${lines[*]}" "DOKKU_REDIS_"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:promote) uses REDIS_DATABASE_SCHEME variable" {
-  password="$(cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  dokku config:set my_app "REDIS_DATABASE_SCHEME=redis2" "REDIS_URL=redis://u:p@host:6379" "DOKKU_REDIS_BLUE_URL=redis2://l:$password@dokku-redis-l:6379"
-  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my_app
-  url=$(dokku config:get my_app REDIS_URL)
-  assert_equal "$url" "redis2://l:$password@dokku-redis-l:6379"
+  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
+  dokku config:set my-app "REDIS_DATABASE_SCHEME=redis2" "REDIS_URL=redis://:p@host:6379" "DOKKU_REDIS_BLUE_URL=redis2://:$password@dokku-redis-l:6379"
+  dokku "$PLUGIN_COMMAND_PREFIX:promote" l my-app
+  url=$(dokku config:get my-app REDIS_URL)
+  assert_equal "$url" "redis2://:$password@dokku-redis-l:6379"
 }

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" {
@@ -23,4 +23,3 @@ teardown() {
   run dokku "$PLUGIN_COMMAND_PREFIX:restart" l
   assert_success
 }
-

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" {
@@ -23,4 +23,3 @@ teardown() {
   run dokku "$PLUGIN_COMMAND_PREFIX:start" l
   assert_success
 }
-

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" {
@@ -23,4 +23,3 @@ teardown() {
   run dokku "$PLUGIN_COMMAND_PREFIX:stop" l
   assert_success
 }
-

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" {
@@ -25,4 +25,3 @@ teardown() {
   [[ ! -f $PLUGIN_DATA_ROOT/PORT ]]
   assert_contains "${lines[*]}" "Service l unexposed"
 }
-

tests/service_unlink.bats

@@ -2,63 +2,76 @@
 load test_helper
 
 setup() {
-  dokku apps:create my_app >&2
-  dokku "$PLUGIN_COMMAND_PREFIX:create" l >&2
+  dokku apps:create my-app
+  dokku "$PLUGIN_COMMAND_PREFIX:create" ls
 }
 
 teardown() {
-  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l >&2
-  rm -rf "$DOKKU_ROOT/my_app"
+  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" ls
+  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" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" l
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls
   assert_contains "${lines[*]}" "Please specify an app to run the command on"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) error when the app does not exist" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" l not_existing_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls not_existing_app
   assert_contains "${lines[*]}" "App not_existing_app does not exist"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) error when the service does not exist" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" not_existing_service my_app
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" not_existing_service my-app
   assert_contains "${lines[*]}" "service not_existing_service does not exist"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) error when service not linked to app" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
-  assert_contains "${lines[*]}" "Not linked to app my_app"
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
+  assert_contains "${lines[*]}" "Not linked to app my-app"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) removes link from docker-options" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app >&2
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
 
-  check_value=""
-  report_action="docker-options"
-  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)
+  check_value="Docker options build: Docker options deploy: --restart=on-failure:10 Docker options run:"
+  options=$(dokku --quiet docker-options:report my-app | xargs)
   assert_equal "$options" "$check_value"
 }
 
 @test "($PLUGIN_COMMAND_PREFIX:unlink) unsets config url from app" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app >&2
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
-  config=$(dokku config:get my_app REDIS_URL || true)
+  dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
+  config=$(dokku config:get my-app REDIS_URL || true)
   assert_equal "$config" ""
 }
+
+@test "($PLUGIN_COMMAND_PREFIX:unlink) respects --no-restart" {
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app
+  echo "output: $output"
+  echo "status: $status"
+  assert_output_contains "Skipping restart of linked app" 0
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:link" ls my-app
+  echo "output: $output"
+  echo "status: $status"
+  assert_success
+
+  run dokku "$PLUGIN_COMMAND_PREFIX:unlink" ls my-app --no-restart
+  echo "output: $output"
+  echo "status: $status"
+  assert_output_contains "Skipping restart of linked app"
+  assert_success
+}

tests/setup.sh

@@ -1,33 +1,33 @@
 #!/usr/bin/env bash
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
-source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/test_helper.bash"
+set -eo pipefail
+[[ $TRACE ]] && set -x
+sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 762E3157
+echo "deb http://nginx.org/packages/ubuntu $(lsb_release -cs) nginx" | sudo tee /etc/apt/sources.list.d/nginx.list
+curl -fsSL https://nginx.org/keys/nginx_signing.key | sudo apt-key add -
 
-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
-  git clone https://github.com/progrium/dokku.git $DOKKU_ROOT > /dev/null
+echo "dokku dokku/skip_key_file boolean true" | sudo debconf-set-selections
+wget https://raw.githubusercontent.com/dokku/dokku/master/bootstrap.sh
+if [[ "$DOKKU_VERSION" == "master" ]]; then
+  sudo bash bootstrap.sh
+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 -
 
-source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
-rm -rf $DOKKU_ROOT/plugins/$PLUGIN_COMMAND_PREFIX
-mkdir -p $DOKKU_ROOT/plugins/$PLUGIN_COMMAND_PREFIX $DOKKU_ROOT/plugins/$PLUGIN_COMMAND_PREFIX/subcommands
-find ./ -maxdepth 1 -type f -exec cp '{}' $DOKKU_ROOT/plugins/$PLUGIN_COMMAND_PREFIX \;
-find ./subcommands -maxdepth 1 -type f -exec cp '{}' $DOKKU_ROOT/plugins/$PLUGIN_COMMAND_PREFIX/subcommands \;
-echo "$DOKKU_VERSION" > $DOKKU_ROOT/VERSION
-
-if [[ ! -f $BIN_STUBS/plugn ]]; then
-  wget -O- "$PLUGN_URL" | tar xzf - -C "$BIN_STUBS"
-  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
+export DOKKU_LIB_ROOT="/var/lib/dokku"
+export DOKKU_PLUGINS_ROOT="$DOKKU_LIB_ROOT/plugins/available"
+pushd "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")" >/dev/null
+source "config"
+popd >/dev/null
+sudo rm -rf "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX"
+sudo mkdir -p "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/scripts" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/templates"
+sudo find ./ -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" \;
+[[ -d "./scripts" ]] && sudo find ./scripts -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/scripts" \;
+[[ -d "./subcommands" ]] && sudo find ./subcommands -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" \;
+[[ -d "./templates" ]] && sudo find ./templates -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/templates" \;
+sudo mkdir -p "$PLUGIN_CONFIG_ROOT" "$PLUGIN_DATA_ROOT"
+sudo dokku plugin:enable "$PLUGIN_COMMAND_PREFIX"
+sudo dokku plugin:install

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 python3
+# -*- 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_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/dokku"
-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="redis"
-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 REDIS_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/fixtures"
-export PLUGIN_DATA_ROOT="$REDIS_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:?}"/*
+export DOKKU_LIB_ROOT="/var/lib/dokku"
+source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
 
 flunk() {
-  { if [ "$#" -eq 0 ]; then cat -
-    else echo "$*"
+  {
+    if [ "$#" -eq 0 ]; then
+      cat -
+    else
+      echo "$*"
     fi
   }
   return 1
@@ -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,28 @@ assert_contains() {
   fi
 }
 
+# ShellCheck doesn't know about $output from Bats
+# shellcheck disable=SC2154
 assert_output() {
   local expected
-  if [ $# -eq 0 ]; then expected="$(cat -)"
-  else expected="$1"
+  if [ $# -eq 0 ]; then
+    expected="$(cat -)"
+  else
+    expected="$1"
   fi
   assert_equal "$expected" "$output"
 }
+
+# ShellCheck doesn't know about $output from Bats
+# shellcheck disable=SC2154
+assert_output_contains() {
+  local input="$output"
+  local expected="$1"
+  local count="${2:-1}"
+  local found=0
+  until [ "${input/$expected/}" = "$input" ]; do
+    input="${input/$expected/}"
+    found=$((found + 1))
+  done
+  assert_equal "$count" "$found"
+}