Release 1.18.0

feat: allow tailing a specific number of log lines
Release 1.17.1
2021-10-26 22:28:10 -04:00 · 2021-10-26 22:27:15 -04:00 · 2021-10-24 05:17:55 -04:00 · 2021-10-24 05:08:30 -04:00 · 2021-10-23 19:34:11 -04:00 · 2021-10-23 19:33:19 -04:00
64 changed files with 1929 additions and 491 deletions
--- a/.devcontainer/20_init_plugin
+++ b/.devcontainer/20_init_plugin
@@ -0,0 +1,24 @@
+#!/bin/bash
+set -eo pipefail
+
+log-info() {
+  declare desc="Log info formatter"
+  echo "    $*" 1>&2
+}
+
+log-fail() {
+  declare desc="Log fail formatter"
+  echo "!   $*" 1>&2
+  exit 1
+}
+
+main() {
+  dokku plugin:install
+
+  # built in the Dockerfile
+  PLUGIN_NAME="$(source /tmp/.env && echo "$PLUGIN_NAME")"
+  PLUGIN_VARIABLE="$(source /tmp/.env && echo "$PLUGIN_VARIABLE")"
+  echo "export ${PLUGIN_VARIABLE}_HOST_ROOT=${SERVICE_HOST_ROOT}/$PLUGIN_NAME" > /etc/default/dokku
+}
+
+main "$@"
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -0,0 +1,26 @@
+FROM dokku/dokku:latest
+
+RUN apt-get update
+RUN apt-get install --no-install-recommends -y build-essential 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
--- a/.devcontainer/bin/copy-file
+++ b/.devcontainer/bin/copy-file
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+main() {
+  PLUGIN_NAME="$(source /tmp/.env && echo "$PLUGIN_NAME")"
+  cp "$1" "/var/lib/dokku/plugins/enabled/$PLUGIN_NAME/$1"
+}
+
+main "$@"
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,16 @@
+{
+  "build": {
+    "dockerfile": "Dockerfile",
+    "context": ".."
+  },
+  "containerEnv": {
+    "SERVICE_HOST_ROOT": "${localWorkspaceFolder}/tmp/data"
+  },
+  "initializeCommand": ["mkdir", "-p", "tmp/data"],
+  "mounts": [
+    "source=/var/run/docker.sock,target=/var/run/docker.sock,type=bind",
+    "source=${localWorkspaceFolder}/tmp/data/,target=/var/lib/dokku/services/,type=bind"
+  ],
+  "overrideCommand": false,
+  "runArgs": ["--init"]
+}
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "docker"
+    directory: "/"
+    schedule:
+      interval: "daily"
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,100 @@
+---
+name: CI
+
+# yamllint disable-line rule:truthy
+on:
+  pull_request:
+    branches:
+      - '*'
+  push:
+    branches:
+      - master
+
+jobs:
+  unit-tests-master:
+    name: unit-tests
+    runs-on: ubuntu-18.04
+    strategy:
+      fail-fast: true
+    env:
+      DOKKU_VERSION: master
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v2
+        with:
+          python-version: '3.7.x'
+
+      - run: make setup
+
+      - run: sudo sysctl -w vm.max_map_count=262144
+
+      - run: |
+          git fetch -q origin master
+          changed=$(git --no-pager diff --name-only $GITHUB_SHA..origin/master)
+          if [ $changed = "Dockerfile" ]; then
+            echo "Please run 'make generate' to update the image version in the README.md"
+          else
+            make generate
+            if ! git diff --quiet README.md; then
+              echo "Please run 'make generate'"
+              git status --short
+              git --no-pager diff README.md
+              exit 1
+            fi
+          fi
+
+      - run: make test
+
+      - uses: actions/upload-artifact@v2
+        if: failure()
+        with:
+          name: tmp/test-results
+          path: test-results
+
+  unit-tests-0_19_0:
+    name: unit-tests-0.19.0
+    runs-on: ubuntu-18.04
+    strategy:
+      fail-fast: true
+    env:
+      DOKKU_TAG: v0.19.0
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v2
+        with:
+          python-version: '3.7.x'
+
+      - run: make setup
+
+      - run: sudo sysctl -w vm.max_map_count=262144
+
+      - run: |
+          git fetch -q origin master
+          changed=$(git --no-pager diff --name-only $GITHUB_SHA..origin/master)
+          if [ $changed = "Dockerfile" ]; then
+            echo "Please run 'make generate' to update the image version in the README.md"
+          else
+            make generate
+            if ! git diff --quiet README.md; then
+              echo "Please run 'make generate'"
+              git status --short
+              git --no-pager diff README.md
+              exit 1
+            fi
+          fi
+
+      - run: make test
+
+      - uses: actions/upload-artifact@v2
+        if: failure()
+        with:
+          name: tmp/test-results
+          path: test-results
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 /tmp
 .vagrant
+bootstrap.sh
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,9 +0,0 @@
-dist: trusty
-language: bash
-env:
-  - DOKKU_VERSION=master
-  - DOKKU_VERSION=v0.17.0
-install: make setup
-before_script: sudo sysctl -w vm.max_map_count=262144
-script: make test
-after_failure: make report
--- a/1
+++ b/1
@@ -0,0 +1 @@
+FROM redis:6.2.6
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,4 +1,4 @@
-Copyright (C) 2018 Jose Diaz-Gonzalez
+Copyright (C) 2020 Jose Diaz-Gonzalez

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

--- a/40
+++ b/40
@@ -1,5 +1,9 @@
 HARDWARE = $(shell uname -m)
 SYSTEM_NAME  = $(shell uname -s | tr '[:upper:]' '[:lower:]')
+SHFMT_VERSION = 3.0.2
+XUNIT_TO_GITHUB_VERSION = 0.3.0
+XUNIT_READER_VERSION = 0.1.0
+

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

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

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

 test: lint unit-tests

-report: tmp/xunit-to-github
-ifdef TRAVIS_REPO_SLUG
-ifdef GITHUB_ACCESS_TOKEN
-ifneq ($(TRAVIS_PULL_REQUEST),false)
-	tmp/xunit-to-github --skip-ok --job-url "$(TRAVIS_JOB_WEB_URL)" --pull-request-id "$(TRAVIS_PULL_REQUEST)" --repository-slug "$(TRAVIS_REPO_SLUG)" --title "DOKKU_VERSION=$(DOKKU_VERSION)" tmp/test-results/bats tmp/test-results/shellcheck
-endif
-endif
-endif
+report: tmp/xunit-reader
+	tmp/xunit-reader -p 'tmp/test-results/bats/*.xml'
+	tmp/xunit-reader -p 'tmp/test-results/shellcheck/*.xml'
+
+.PHONY: clean
+clean:
+	rm -f README.md
+
+.PHONY: generate
+generate: clean README.md
+
+.PHONY: README.md
+README.md:
+	bin/generate
--- a/README.md
+++ b/README.md
@@ -1,234 +1,685 @@
-# 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/workflow/status/dokku/dokku-redis/CI/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 5.0.5](https://hub.docker.com/_/redis/).
+Official redis plugin for dokku. Currently defaults to installing [redis 6.2.6](https://hub.docker.com/_/redis/).

-## requirements
+## Requirements

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

-## installation
+## Installation

 ```shell
-# on 0.12.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> <passphrase> Set a GPG passphrase for backups
-redis:backup-unschedule <name> Unschedules the backup of the redis service
-redis:backup-unset-encryption <name> Removes backup encryption for future backups of the redis service
-redis:clone <name> <new-name>  Create container <new-name> then copy data from <name> into <new-name>
-redis:connect <name>           Connect via redis-cli to a redis service
-redis:create <name>            Create a redis service with environment variables
-redis:destroy <name>           Delete the service, delete the data and stop its container if there are no links left
-redis:enter <name> [command]   Enter or run a command in a running redis service container
-redis:exists <service>         Check if the redis service exists
-redis:export <name> > <file>   Export a dump of the redis service database
-redis:expose <name> [port]     Expose a redis service on custom port if provided (random port otherwise)
-redis:import <name> <file>     Import a dump into the redis service database
-redis:info <name>              Print the connection information
-redis:link <name> <app>        Link the redis service to the app
-redis:linked <name> <app>      Check if the redis service is linked to an app
-redis:list                     List all redis services
-redis:logs <name> [-t]         Print the most recent log(s) for this service
-redis:promote <name> <app>     Promote service <name> as REDIS_URL in <app>
-redis:restart <name>           Graceful shutdown and restart of the redis service container
-redis:start <name>             Start a previously stopped redis service
-redis:stop <name>              Stop a running redis service
-redis:unexpose <name>          Unexpose a previously exposed redis service
-redis:unlink <name> <app>      Unlink the redis service from the app
-redis:upgrade <name>           Upgrade service <service> to the specified version
+redis:app-links <app>                              # list all redis service links for a given app
+redis:backup <service> <bucket-name> [--use-iam]   # 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:promote <service> <app>                      # promote service <service> as REDIS_URL in <app>
+redis:restart <service>                            # graceful shutdown and restart of the redis service container
+redis:start <service>                              # start a previously stopped redis service
+redis:stop <service>                               # stop a running redis service
+redis:unexpose <service>                           # unexpose a previously exposed redis service
+redis:unlink <service> <app>                       # unlink the redis service from the app
+redis:upgrade <service> [--upgrade-flags...]       # upgrade service <service> to the specified versions
 ```

-## usage
+## Usage
+
+Help for any commands can be displayed by specifying the command as an argument to redis:help. 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 (default: unlimited)
+- `-p|--password PASSWORD`: override the user-level service password
+- `-r|--root-password PASSWORD`: override the root-level service password
+- `-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
+- `--links`: show the service app links
+- `--service-root`: show the service root directory
+- `--status`: show the service running status
+- `--version`: show the service image version

-# 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 --links
+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
+
+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
+You can unlink a redis service:

-## Backups
+> NOTE: this will restart your app and unset related environment variables
+
+```shell
+dokku redis:unlink lollipop playground
+```
+
+### Service Lifecycle
+
+The lifecycle of each service can be managed through the following commands:
+
+### connect to the service via the redis connection tool
+
+```shell
+# usage
+dokku redis:connect <service>
+```
+
+Connect to the service via the redis connection tool:
+
+> 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 the running container:
+
+```shell
+dokku redis:stop 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
+- `-R|--restart-apps "true"`: whether to force an app restart
+- `-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 (default: unlimited)
+- `-p|--password PASSWORD`: override the user-level service password
+- `-r|--root-password PASSWORD`: override the root-level service password
+- `-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 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
+Setup s3 backup authentication:
+
+```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:
+
+```shell
+dokku redis:backup-auth lollipop AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION
+```
+
+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 pull` calls

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

--- a/bin/generate
+++ b/bin/generate
@@ -0,0 +1,538 @@
+#!/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/workflow/status/dokku/dokku-{service}/CI/master?style=flat-square "Build Status")](https://github.com/dokku/dokku-{service}/actions/workflows/ci.yml?query=branch%3Amaster)',
+            f'[![IRC Network](https://img.shields.io/badge/irc-libera-blue.svg?style=flat-square "IRC Libera")](https://webchat.libera.chat/?channels=dokku)',
+        ]
+    )
+
+
+def description(service, full_image, version):
+    base = "_"
+    image = full_image
+    if "/" in full_image:
+        base = "r/" + full_image.split("/")[0]
+        image = full_image.split("/")[1]
+
+    return f"Official {service} plugin for dokku. Currently defaults to installing [{full_image} {version}](https://hub.docker.com/{base}/{image}/)."
+
+
+def sponsors_section(service, sponsors):
+    if len(sponsors) == 0:
+        return ""
+
+    sponsor_data = ["## Sponsors", "", f"The {service} plugin was generously sponsored by the following:", ""]
+    sponsor_data.extend([f"- [{s}](https://github.com/{s})" for s in sponsors])
+
+    return "\n".join(
+        sponsor_data
+    )
+
+
+def requirements_section(dokku_version):
+    return "\n".join(
+        ["## Requirements", "", f"- dokku {dokku_version}", "- docker 1.8.x",]
+    )
+
+
+def installation_section(service, dokku_version):
+    return "\n".join(
+        [
+            "## Installation",
+            "",
+            "```shell",
+            f"# on {dokku_version}",
+            f"sudo dokku plugin:install https://github.com/dokku/dokku-{service}.git {service}",
+            "```",
+        ]
+    )
+
+
+def commands_section(service, variable, alias, image, scheme, ports, unimplemented):
+    content = [
+        "## Commands",
+        "",
+        "```",
+    ]
+
+    subcommands = os.listdir("subcommands")
+    subcommands.sort()
+
+    command_list = []
+    descriptions = []
+    for filename in subcommands:
+        if filename in unimplemented:
+            continue
+        data = command_data(filename, service, variable, alias, image, scheme, ports)
+        description = data["description"]
+        arguments = data["arguments_string"]
+
+        command_list.append(f"{service}:{filename} {arguments}")
+        descriptions.append(description)
+
+    maxlen = max(map(len, command_list))
+    if maxlen > 50:
+        maxlen = 50
+    for command, description in zip(command_list, descriptions):
+        space_count = maxlen - len(command)
+        content.append("{0}{1} # {2}".format(command, " " * space_count, description))
+
+    content.append("```")
+    return "\n".join(content)
+
+
+def usage_section(service, variable, alias, image, scheme, ports, 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"]
+    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",
+        "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 pull` calls",
+            "",
+            f"If you wish to disable the `docker pull` calls that the plugin triggers, you may set the `{service_prefix}_DISABLE_PULL` environment variable to `true`. Once disabled, you will need to pull the service image you wish to deploy as shown in the `stderr` output.",
+            "",
+            "Please ensure the proper images are in place when `docker pull` is disabled.",
+        ]
+    )
+
+
+def fetch_commands_content(
+    service, variable, alias, image, scheme, ports, 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()
--- a/226
+++ b/226
@@ -1,10 +1,23 @@
 #!/usr/bin/env bash
+source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/config"
 set -eo pipefail
 [[ $DOKKU_TRACE ]] && set -x
 source "$PLUGIN_AVAILABLE_PATH/config/functions"

+add_to_links_file() {
+  declare desc="add an app to the service link file"
+  declare SERVICE="$1" APP="$2"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local LINKS_FILE="$SERVICE_ROOT/LINKS"
+
+  touch "$LINKS_FILE"
+  sed -i.bak "/^$APP\$/d" "$LINKS_FILE" && rm "$LINKS_FILE.bak"
+  echo "$APP" >>"$LINKS_FILE"
+  sort "$LINKS_FILE" -u -o "$LINKS_FILE"
+}
+
 docker_ports_options() {
-  declare desc="Exports a list of exposed ports"
+  declare desc="export a list of exposed ports"
  declare PORTS=("$@")
  for ((i = 0; i < ${#PLUGIN_DATASTORE_PORTS[@]}; i++)); do
    echo -n "-p ${PORTS[i]}:${PLUGIN_DATASTORE_PORTS[i]} "
@@ -12,13 +25,13 @@ docker_ports_options() {
 }

 get_container_ip() {
-  declare desc="Retrieves the ip address of a container"
+  declare desc="retrieve the ip address of a container"
  declare CONTAINER_ID="$1"
  docker inspect --format '{{ .NetworkSettings.IPAddress }}' "$CONTAINER_ID" 2>/dev/null
 }

 get_database_name() {
-  declare desc="Retrieves a sanitized database name"
+  declare desc="retrieve a sanitized database name"
  declare SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"

@@ -30,7 +43,7 @@ get_database_name() {
 }

 get_random_ports() {
-  declare desc="Retrieves N random ports"
+  declare desc="retrieve N random ports"
  declare iterations="${1:-1}"
  for ((i = 0; i < iterations; i++)); do
    local port=$RANDOM
@@ -49,19 +62,28 @@ get_random_ports() {
 }

 get_service_name() {
-  declare desc="Retrieves a docker service label"
+  declare desc="retrieve a docker service label"
  declare SERVICE="$1"
  echo "dokku.${PLUGIN_COMMAND_PREFIX}.$SERVICE"
 }

 get_url_from_config() {
-  declare desc="Retrieves a given _URL from a list of configuration variables"
+  declare desc="retrieve a given _URL from a list of configuration variables"
  declare EXISTING_CONFIG="$1" CONFIG_VAR="$2"
  echo "$EXISTING_CONFIG" | grep "$CONFIG_VAR" | sed "s/$CONFIG_VAR:\s*//" | xargs
 }

+in_links_file() {
+  declare desc="check if a service LINKS file contains an app"
+  declare SERVICE="$1" APP="$2"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local LINKS_FILE="$SERVICE_ROOT/LINKS"
+
+  grep -qE "^$APP\$" "$LINKS_FILE"
+}
+
 is_container_status() {
-  declare desc="Returns 0 or 1 depending upon whether a given container has a certain status"
+  declare desc="return 0 or 1 depending upon whether a given container has a certain status"
  declare CID="$1" STATUS="$2"
  local TEMPLATE="{{.State.$STATUS}}"
  local CONTAINER_STATUS=$(docker inspect -f "$TEMPLATE" "$CID" 2>/dev/null || true)
@@ -89,7 +111,7 @@ is_implemented_command() {
 }

 is_valid_service_name() {
-  declare desc="Validates a service name"
+  declare desc="validate a service name"
  declare SERVICE="$1"
  [[ -z "$SERVICE" ]] && return 1

@@ -101,7 +123,7 @@ is_valid_service_name() {
 }

 remove_from_links_file() {
-  declare desc="Removes an app from the service link file"
+  declare desc="remove an app from the service link file"
  declare SERVICE="$1" APP="$2"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local LINKS_FILE="$SERVICE_ROOT/LINKS"
@@ -119,7 +141,7 @@ retry-docker-command() {
  local i=0 success=false
  until [ $i -ge 100 ]; do
    set +e
-    docker exec -it "$ID" sh -c "$COMMAND" 2>/dev/null
+    suppress_output docker exec "$ID" sh -c "$COMMAND"
    exit_code=$?
    set -e
    if [[ "$exit_code" == 0 ]]; then
@@ -136,7 +158,7 @@ retry-docker-command() {
 }

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

 service_app_links() {
-  declare desc="Outputs all service links for a given app"
+  declare desc="output all service links for a given app"
  declare APP="$1"
  local SERVICE LINKED_APP

@@ -169,7 +191,7 @@ service_app_links() {
 }

 service_backup() {
-  declare desc="Creates a backup of a service to an existing s3 bucket"
+  declare desc="create a backup of a service to an existing s3 bucket"
  declare SERVICE="$1" BUCKET_NAME="$2" USE_IAM_OPTIONAL_FLAG="$3"
  local SERVICE_BACKUP_ROOT="$PLUGIN_DATA_ROOT/$SERVICE/backup"
  local BACKUP_ENCRYPTION_CONFIG_ROOT="$PLUGIN_DATA_ROOT/$SERVICE/backup-encryption"
@@ -187,18 +209,18 @@ service_backup() {
    dokku_log_fail "Provide AWS credentials or use the --use-iam flag"
  fi

-  TMPDIR=$(mktemp -d)
-  trap 'rm -rf "$TMPDIR" > /dev/null' RETURN INT TERM EXIT
+  BACKUP_TMPDIR=$(mktemp -d --tmpdir)
+  trap 'rm -rf "$BACKUP_TMPDIR" > /dev/null' RETURN INT TERM EXIT

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

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

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

  if [[ -f "$SERVICE_BACKUP_ROOT/AWS_DEFAULT_REGION" ]]; then
    BACKUP_PARAMETERS="$BACKUP_PARAMETERS -e AWS_DEFAULT_REGION=$(cat "$SERVICE_BACKUP_ROOT/AWS_DEFAULT_REGION")"
@@ -217,11 +239,51 @@ service_backup() {
  fi

  # shellcheck disable=SC2086
-  docker run --rm $BACKUP_PARAMETERS dokku/s3backup:0.10.0
+  docker run --rm $BACKUP_PARAMETERS "$PLUGIN_S3BACKUP_IMAGE"
+}
+
+service_commit_config() {
+  declare SERVICE="$1"
+  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
+  local CONFIG_VARIABLE="${PLUGIN_VARIABLE}_CONFIG_OPTIONS"
+  local ENV_VARIABLE="${PLUGIN_VARIABLE}_CUSTOM_ENV"
+
+
+  custom_env="${!ENV_VARIABLE}"
+  [[ -n "$SERVICE_CUSTOM_ENV" ]] && custom_env="$SERVICE_CUSTOM_ENV"
+  if [[ -n $custom_env ]]; then
+    echo "$custom_env" | tr ';' "\n" >"$SERVICE_ROOT/ENV"
+  else
+    echo "" >"$SERVICE_ROOT/ENV"
+  fi
+
+  config_options="${!CONFIG_VARIABLE}"
+  [[ -n "$PLUGIN_CONFIG_OPTIONS" ]] && config_options="$PLUGIN_CONFIG_OPTIONS"
+  if [[ -n "$config_options" ]]; then
+    echo "$config_options" >"$SERVICE_ROOT/CONFIG_OPTIONS"
+  else
+    echo "" >"$SERVICE_ROOT/CONFIG_OPTIONS"
+  fi
+
+  if [[ -n "$SERVICE_MEMORY" ]]; then
+    echo "$SERVICE_MEMORY" >"$SERVICE_ROOT/SERVICE_MEMORY"
+  fi
+
+  if [[ -n "$SERVICE_SHM_SIZE" ]]; then
+    echo "$SERVICE_SHM_SIZE" >"$SERVICE_ROOT/SHM_SIZE"
+  fi
+
+  if [[ -n "$PLUGIN_IMAGE" ]]; then
+    echo "$PLUGIN_IMAGE" >"$SERVICE_ROOT/IMAGE"
+  fi
+
+  if [[ -n "$PLUGIN_IMAGE_VERSION" ]]; then
+    echo "$PLUGIN_IMAGE_VERSION" >"$SERVICE_ROOT/IMAGE_VERSION"
+  fi
 }

 service_backup_auth() {
-  declare desc="Sets up authentication"
+  declare desc="set up authentication"
  declare SERVICE="$1" AWS_ACCESS_KEY_ID="$2" AWS_SECRET_ACCESS_KEY="$3" AWS_DEFAULT_REGION="$4" AWS_SIGNATURE_VERSION="$5" ENDPOINT_URL="$6"
  local SERVICE_BACKUP_ROOT="$PLUGIN_DATA_ROOT/$SERVICE/backup"

@@ -243,7 +305,7 @@ service_backup_auth() {
 }

 service_backup_deauth() {
-  declare desc="Removes authentication"
+  declare desc="remove authentication"
  declare SERVICE="$1"
  local SERVICE_ROOT="${PLUGIN_DATA_ROOT}/${SERVICE}"
  local SERVICE_BACKUP_ROOT="${SERVICE_ROOT}/backup/"
@@ -281,7 +343,7 @@ service_backup_schedule_cat() {
 }

 service_backup_set_encryption() {
-  declare desc="Sets up backup encryption"
+  declare desc="set up backup encryption"
  declare SERVICE="$1" ENCRYPTION_KEY="$2"
  local SERVICE_ROOT="${PLUGIN_DATA_ROOT}/${SERVICE}"
  local SERVICE_BACKUP_ENCRYPTION_ROOT="${SERVICE_ROOT}/backup-encryption/"
@@ -291,7 +353,7 @@ service_backup_set_encryption() {
 }

 service_backup_unschedule() {
-  declare desc="unschedules the backup of the service"
+  declare desc="unschedule the backup of the service"
  declare SERVICE="$1"
  local CRON_FILE="/etc/cron.d/dokku-${PLUGIN_COMMAND_PREFIX}-${SERVICE}"

@@ -299,7 +361,7 @@ service_backup_unschedule() {
 }

 service_backup_unset_encryption() {
-  declare desc="Removes backup encryption"
+  declare desc="remove backup encryption"
  declare SERVICE="$1"
  local SERVICE_ROOT="${PLUGIN_DATA_ROOT}/${SERVICE}"
  local SERVICE_BACKUP_ENCRYPTION_ROOT="${SERVICE_ROOT}/backup-encryption/"
@@ -308,7 +370,7 @@ service_backup_unset_encryption() {
 }

 service_container_rm() {
-  declare desc="Stops a service and removes the running container"
+  declare desc="stop a service and remove the running container"
  declare SERVICE="$1"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
  local ID
@@ -328,14 +390,14 @@ service_container_rm() {
 }

 service_dns_hostname() {
-  declare desc="Retrieves the alias of a service"
+  declare desc="retrieve the alias of a service"
  declare SERVICE="$1"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
  echo "$SERVICE_NAME" | tr ._ -
 }

 service_enter() {
-  declare desc="enters running app container of specified proc type"
+  declare desc="enter running app container of specified proc type"
  declare SERVICE="$1" && shift 1
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local ID="$(cat "$SERVICE_ROOT/ID")"
@@ -350,7 +412,7 @@ service_enter() {
 }

 service_exposed_ports() {
-  declare desc="Lists exposed ports for a service"
+  declare desc="list exposed ports for a service"
  declare SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local PORT_FILE="$SERVICE_ROOT/PORT"
@@ -362,8 +424,14 @@ service_exposed_ports() {
 }

 service_image_exists() {
-  declare desc="Checks if the current image exists"
-  local IMAGE="$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION"
+  declare desc="check if the current image exists"
+  declare SERVICE="$1"
+  local plugin_image="$PLUGIN_IMAGE"
+  local plugin_image_version="$PLUGIN_IMAGE_VERSION"
+
+  [[ -f "$SERVICE_ROOT/IMAGE" ]] && plugin_image="$(cat "$SERVICE_ROOT/IMAGE")"
+  [[ -f "$SERVICE_ROOT/IMAGE_VERSION" ]] && plugin_image_version="$(cat "$SERVICE_ROOT/IMAGE_VERSION")"
+  local IMAGE="$plugin_image:$plugin_image_version"

  if [[ "$(docker images -q "$IMAGE" 2>/dev/null)" == "" ]]; then
    return 1
@@ -373,7 +441,7 @@ service_image_exists() {
 }

 service_info() {
-  declare desc="Retrieves information about a given service"
+  declare desc="retrieve information about a given service"
  declare SERVICE="$1" INFO_FLAG="$2"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_URL=$(service_url "$SERVICE")
@@ -382,7 +450,8 @@ service_info() {
  local flag key valid_flags

  local flag_map=(
-    "--config-dir: ${SERVICE_ROOT}/config"
+    "--config-dir: ${SERVICE_ROOT}/${PLUGIN_CONFIG_SUFFIX}"
+    "--config-options: $(cat "$SERVICE_ROOT/CONFIG_OPTIONS" 2>/dev/null || true)"
    "--data-dir: ${SERVICE_ROOT}/data"
    "--dsn: ${SERVICE_URL}"
    "--exposed-ports: $(service_exposed_ports "$SERVICE")"
@@ -394,7 +463,7 @@ service_info() {
    "--version: $(service_version "$SERVICE")"
  )
  if [[ -z "$INFO_FLAG" ]]; then
-    dokku_log_info2 "Container Information"
+    dokku_log_info2_quiet "$SERVICE $PLUGIN_COMMAND_PREFIX service information"
    for flag in "${flag_map[@]}"; do
      key="$(echo "${flag#--}" | cut -f1 -d' ' | tr - ' ')"
      dokku_log_verbose "$(printf "%-20s %-25s" "${key^}" "${flag#*: }")"
@@ -412,7 +481,7 @@ service_info() {
 }

 service_is_linked() {
-  declare desc="Links a service to an application"
+  declare desc="link a service to an application"
  declare SERVICE="$1" APP="$2"
  update_plugin_scheme_for_app "$APP"
  local SERVICE_URL=$(service_url "$SERVICE")
@@ -426,7 +495,7 @@ service_is_linked() {
 }

 service_link() {
-  declare desc="Links a service to an application"
+  declare desc="link a service to an application"
  declare SERVICE="$1" APP="$2"
  update_plugin_scheme_for_app "$APP"
  local SERVICE_URL=$(service_url "$SERVICE")
@@ -452,9 +521,8 @@ service_link() {
  fi

  [[ -n $LINK ]] && dokku_log_fail "Already linked as $LINK"
-  touch "$LINKS_FILE"
-  echo "$APP" >>"$LINKS_FILE"
-  sort "$LINKS_FILE" -u -o "$LINKS_FILE"
+  plugn trigger service-action pre-link "$SERVICE" "$APP"
+  add_to_links_file "$SERVICE" "$APP"

  if declare -f -F add_passed_docker_option >/dev/null; then
    # shellcheck disable=SC2034
@@ -464,11 +532,13 @@ service_link() {
    dokku docker-options:add "$APP" build,deploy,run "--link $SERVICE_NAME:$SERVICE_DNS_HOSTNAME"
  fi
  [[ -n "$SERVICE_QUERYSTRING" ]] && SERVICE_URL="${SERVICE_URL}?${SERVICE_QUERYSTRING}"
+  plugn trigger service-action post-link "$SERVICE" "$APP"
  config_set "$APP" "${ALIAS}_URL=$SERVICE_URL"
+  plugn trigger service-action post-link-complete "$SERVICE" "$APP"
 }

 service_linked_apps() {
-  declare desc="Lists all apps linked to a service for info output"
+  declare desc="list all apps linked to a service for info output"
  declare SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local LINKS_FILE="$SERVICE_ROOT/LINKS"
@@ -480,7 +550,7 @@ service_linked_apps() {
 }

 service_links() {
-  declare desc="Lists all apps linked to a service"
+  declare desc="list all apps linked to a service"
  declare SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local LINKS_FILE="$SERVICE_ROOT/LINKS"
@@ -492,33 +562,30 @@ service_links() {
 }

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

 service_logs() {
-  declare desc="Displays logs for a service"
-  declare SERVICE="$1" TAIL_FLAG="$2"
+  declare desc="display logs for a service"
+  declare SERVICE="$1" TAIL_FLAG="$2" TAIL_COUNT="$3"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local ID=$(cat "$SERVICE_ROOT/ID")
  local RE_INTEGER='^[0-9]+$'

-  DOKKU_LOGS_ARGS="--tail 100"
+  DOKKU_LOGS_ARGS="--tail $TAIL_COUNT"
  if [[ "$TAIL_FLAG" == "-t" ]] || [[ "$TAIL_FLAG" == "--tail" ]]; then
-    DOKKU_LOGS_ARGS="--follow"
+    DOKKU_LOGS_ARGS+=" --follow"
  fi

  docker inspect "$ID" &>/dev/null || dokku_log_fail "Service container does not exist"
@@ -548,13 +615,14 @@ service_parse_args() {
      "--querystring") set -- "$@" "-q" ;;
      "--restart-apps") set -- "$@" "-R" ;;
      "--root-password") set -- "$@" "-r" ;;
+      "--shm-size") set -- "$@" "-s" ;;
      "--user") set -- "$@" "-u" ;;
      *) set -- "$@" "$arg" ;;
    esac
  done

  OPTIND=1
-  while getopts "a:c:C:d:i:I:m:p:q:R:r:u:" opt; do
+  while getopts "a:c:C:d:i:I:m:p:q:R:r:s:u:" opt; do
    case "$opt" in
      a)
        SERVICE_ALIAS="${OPTARG^^}"
@@ -590,6 +658,9 @@ service_parse_args() {
      r)
        export SERVICE_ROOT_PASSWORD=$OPTARG
        ;;
+      s)
+        export SERVICE_SHM_SIZE=$OPTARG
+        ;;
      u)
        export SERVICE_USER=$OPTARG
        ;;
@@ -599,7 +670,7 @@ service_parse_args() {
 }

 service_password() {
-  declare desc="Fetch the password for a service"
+  declare desc="fetch the password for a service"
  declare SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local PASSWORD_FILE="$SERVICE_ROOT/PASSWORD"
@@ -609,7 +680,7 @@ service_password() {
 }

 service_root_password() {
-  declare desc="Fetch the root password for a service"
+  declare desc="fetch the root password for a service"
  declare SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local PASSWORD_FILE="$SERVICE_ROOT/ROOTPASSWORD"
@@ -619,14 +690,14 @@ service_root_password() {
 }

 service_port_expose() {
-  declare desc="Wrapper for exposing service ports"
+  declare desc="wrapper for exposing service ports"
  declare SERVICE="$1"
  service_start "$SERVICE" "true"
  service_port_unpause "$SERVICE" "true" "${@:2}"
 }

 service_port_pause() {
-  declare desc="Pauses service exposure"
+  declare desc="pause service exposure"
  declare SERVICE="$1" LOG_FAIL="$2"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local EXPOSED_NAME="$(get_service_name "$SERVICE").ambassador"
@@ -656,7 +727,7 @@ service_port_pause() {
 }

 service_port_unexpose() {
-  declare desc="Wrapper for pausing exposed service ports"
+  declare desc="wrapper for pausing exposed service ports"
  declare SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local PORT_FILE="$SERVICE_ROOT/PORT"
@@ -665,7 +736,7 @@ service_port_unexpose() {
 }

 service_port_unpause() {
-  declare desc="Starts service exposure"
+  declare desc="start service exposure"
  declare SERVICE="$1" LOG_FAIL="$2"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
@@ -689,14 +760,14 @@ service_port_unpause() {
  echo "${PORTS[@]}" >"$PORT_FILE"

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

 service_promote() {
-  declare desc="Promotes a secondary service to the primary env var"
+  declare desc="promote a secondary service to the primary env var"
  declare SERVICE="$1" APP="$2"
  local PLUGIN_DEFAULT_CONFIG_VAR="${PLUGIN_DEFAULT_ALIAS}_URL"
  local EXISTING_CONFIG=$(config_all "$APP")
@@ -724,7 +795,7 @@ service_promote() {
 }

 service_set_alias() {
-  declare desc="Sets the alias in use for a service"
+  declare desc="sets the alias in use for a service"
  declare SERVICE="$1" ALIAS="$2"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local ALIAS_FILE="$SERVICE_ROOT/ALIAS"
@@ -734,25 +805,19 @@ service_set_alias() {
 }

 service_status() {
-  declare desc="Displays the status of a service"
+  declare desc="display the status of a service"
  declare SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local ID="$(cat "$SERVICE_ROOT/ID")"
  local CONTAINER_STATUS

-  is_container_status "$ID" "Dead" && echo "dead" && return 0
-  is_container_status "$ID" "OOMKilled" && echo "oomkilled" && return 0
-  is_container_status "$ID" "Paused" && echo "paused" && return 0
-  is_container_status "$ID" "Restarting" && echo "restarting" && return 0
-  is_container_status "$ID" "Running" && echo "running" && return 0
-
-  CONTAINER_STATUS=$(docker inspect -f "{{.State.Status}}" "$CID" 2>/dev/null || true)
+  CONTAINER_STATUS=$(docker inspect -f "{{.State.Status}}" "$ID" 2>/dev/null || true)
  [[ -n "$CONTAINER_STATUS" ]] && echo "$CONTAINER_STATUS" && return 0
  echo "missing" && return 0
 }

 service_stop() {
-  declare desc="Stops a running service"
+  declare desc="stop a running service"
  declare SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
@@ -770,7 +835,7 @@ service_stop() {
 }

 service_unlink() {
-  declare desc="Unlinks an application from a service"
+  declare desc="unlink an application from a service"
  declare SERVICE="$1" APP="$2"
  update_plugin_scheme_for_app "$APP"
  local SERVICE_URL=$(service_url "$SERVICE")
@@ -779,6 +844,7 @@ service_unlink() {
  local SERVICE_DNS_HOSTNAME=$(service_dns_hostname "$SERVICE")
  local LINK=($(echo "$EXISTING_CONFIG" | grep "$SERVICE_URL" | cut -d: -f1)) || true

+  plugn trigger service-action pre-unlink "$SERVICE" "$APP"
  remove_from_links_file "$SERVICE" "$APP"

  if declare -f -F add_passed_docker_option >/dev/null; then
@@ -790,18 +856,20 @@ service_unlink() {
  fi

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

 service_version() {
-  declare desc="Displays the running version for an image"
+  declare desc="display the running version for an image"
  declare SERVICE="$1"
  local SERVICE_NAME="$(get_service_name "$SERVICE")"
  docker inspect -f '{{.Config.Image}}' "$SERVICE_NAME" 2>/dev/null || true
 }

 update_plugin_scheme_for_app() {
-  declare desc="Retrieves the updated plugin scheme"
+  declare desc="retrieve the updated plugin scheme"
  declare APP="$1"
  local DATABASE_SCHEME

@@ -810,7 +878,7 @@ update_plugin_scheme_for_app() {
 }

 verify_service_name() {
-  declare desc="Verifies that a service exists"
+  declare desc="verify that a service exists"
  declare SERVICE="$1"
  [[ -z "$SERVICE" ]] && dokku_log_fail "(verify_service_name) SERVICE must not be null"
  [[ ! -d "$PLUGIN_DATA_ROOT/$SERVICE" ]] && dokku_log_fail "$PLUGIN_SERVICE service $SERVICE does not exist"
@@ -818,7 +886,7 @@ verify_service_name() {
 }

 write_database_name() {
-  declare desc="Writes a sanitized database name"
+  declare desc="write a sanitized database name"
  declare SERVICE="$1"
  local SERVICE_ROOT="$PLUGIN_DATA_ROOT/$SERVICE"

--- a/13
+++ b/13
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
-export REDIS_IMAGE=${REDIS_IMAGE:="redis"}
-export REDIS_IMAGE_VERSION=${REDIS_IMAGE_VERSION:="5.0.5"}
+_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 REDIS_HOST_ROOT=${REDIS_HOST_ROOT:=$REDIS_ROOT}

@@ -21,6 +22,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
+
+export PLUGIN_BUSYBOX_IMAGE="busybox:1.31.1-uclibc"
+export PLUGIN_AMBASSADOR_IMAGE="dokku/ambassador:0.3.3"
+export PLUGIN_S3BACKUP_IMAGE="dokku/s3backup:0.10.3"
+export PLUGIN_WAIT_IMAGE="dokku/wait:0.4.3"
+
+export REDIS_CONFIG_OPTIONS=${REDIS_CONFIG_OPTIONS:=""}
--- a/docs/README.md
+++ b/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.
+
--- a/64
+++ b/64
@@ -17,7 +17,7 @@ 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 exec --env=LANG=C.UTF-8 --env=LC_ALL=C.UTF-8 -i $SERVICE_TTY_OPTS "$SERVICE_NAME" redis-cli -a "$PASSWORD"
 }

 service_create() {
@@ -40,15 +40,16 @@ service_create() {
    docker pull "$PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION" || dokku_log_fail "$PLUGIN_SERVICE image $PLUGIN_IMAGE:$PLUGIN_IMAGE_VERSION pull failed"
  fi

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

  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"
+    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
@@ -57,17 +58,13 @@ service_create() {
  fi
  echo "$PASSWORD" >"$SERVICE_ROOT/PASSWORD"
  chmod 640 "$SERVICE_ROOT/PASSWORD"
-  sed -i.bak "s/# requirepass.*/requirepass ${PASSWORD}/" "$SERVICE_ROOT/config/redis.conf" && rm "$SERVICE_ROOT/config/redis.conf.bak"
-
-  [[ -n "$SERVICE_CUSTOM_ENV" ]] && REDIS_CUSTOM_ENV="$SERVICE_CUSTOM_ENV"
-  if [[ -n $REDIS_CUSTOM_ENV ]]; then
-    echo "$REDIS_CUSTOM_ENV" | tr ';' "\n" >"$SERVICE_ROOT/ENV"
-  else
-    echo "" >"$SERVICE_ROOT/ENV"
-  fi
+  sed -i.bak "s/# requirepass.*/requirepass ${PASSWORD}/" "$SERVICE_ROOT/$PLUGIN_CONFIG_SUFFIX/redis.conf" && rm "$SERVICE_ROOT/$PLUGIN_CONFIG_SUFFIX/redis.conf.bak"

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

 service_create_container() {
@@ -76,11 +73,29 @@ 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)
+  if [[ -f "$SERVICE_ROOT/CONFIG_OPTIONS" ]]; then
+    export CONFIG_OPTIONS="$(cat "$SERVICE_ROOT/CONFIG_OPTIONS")"
+  fi
+
+  [[ -f "$SERVICE_ROOT/SERVICE_MEMORY" ]] && SERVICE_MEMORY="$(cat "$SERVICE_ROOT/SERVICE_MEMORY")"
+  if [[ -n "$SERVICE_MEMORY" ]]; then
+    MEMORY_LIMIT="--memory=${SERVICE_MEMORY}m"
+  fi
+
+  [[ -f "$SERVICE_ROOT/SHM_SIZE" ]] && SERVICE_SHM_SIZE="$(cat "$SERVICE_ROOT/SHM_SIZE")"
+  if [[ -n "$SERVICE_SHM_SIZE" ]]; then
+    SHM_SIZE="--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")"
+
+  # shellcheck disable=SC2086
+  ID=$(docker run --name "$SERVICE_NAME" $MEMORY_LIMIT $SHM_SIZE -v "$SERVICE_HOST_ROOT/data:/data" -v "$SERVICE_HOST_ROOT/$PLUGIN_CONFIG_SUFFIX:/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 $CONFIG_OPTIONS)
  echo "$ID" >"$SERVICE_ROOT/ID"

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

  dokku_log_info2 "$PLUGIN_SERVICE container created: $SERVICE"
  service_info "$SERVICE"
@@ -93,7 +108,16 @@ service_export() {
  local PASSWORD="$(service_password "$SERVICE")"

  [[ -n $SSH_TTY ]] && stty -opost
-  docker exec "$SERVICE_NAME" bash -c "echo SAVE | redis-cli -a ${PASSWORD}" >/dev/null 2>&1
+  LASTSAVE1=$(docker exec "$SERVICE_NAME" bash -c "echo LASTSAVE | redis-cli -a ${PASSWORD}")
+  docker exec "$SERVICE_NAME" bash -c "echo BGSAVE | redis-cli -a ${PASSWORD}" >/dev/null 2>&1
+  LASTSAVE2=$(docker exec "$SERVICE_NAME" bash -c "echo LASTSAVE | redis-cli -a ${PASSWORD}")
+
+  until [[ "$LASTSAVE1" != "$LASTSAVE2" ]];
+  do
+    LASTSAVE2=$(docker exec "$SERVICE_NAME" bash -c "echo LASTSAVE | redis-cli -a ${PASSWORD}")
+    sleep 5
+  done
+
  docker exec "$SERVICE_NAME" cat /data/dump.rdb
  status=$?
  [[ -n $SSH_TTY ]] && stty opost
@@ -138,7 +162,13 @@ service_start() {
  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
 }

@@ -146,5 +176,5 @@ 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]}"
 }
--- a/21
+++ b/21
@@ -76,10 +76,10 @@ 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"
@@ -141,7 +141,7 @@ fn-help-contents-subcommand() {
 }

 fn-help-fancy-tput() {
-  declare desc="A wrapper around tput"
+  declare desc="a wrapper around tput"

  if [[ -n "$DOKKU_NO_COLOR" ]] || [[ "$TERM" == "unknown" ]] || [[ "$TERM" == "dumb" ]]; then
    return
@@ -151,7 +151,7 @@ fn-help-fancy-tput() {
 }

 fn-help-fancy-color() {
-  declare desc="A wrapper around colors"
+  declare desc="a wrapper around colors"

  if [[ -n "$DOKKU_NO_COLOR" ]] || [[ "$TERM" == "unknown" ]] || [[ "$TERM" == "dumb" ]]; then
    return
@@ -164,8 +164,8 @@ 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
+      $PLUGIN_SERVICE services
+      service-name
 help_list
 }

@@ -191,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}"
@@ -202,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
@@ -309,7 +312,7 @@ fn-help-subcommand-sanitize() {
 }

 _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"
--- a/26
+++ b/26
@@ -1,5 +1,6 @@
 #!/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

@@ -17,10 +18,10 @@ plugin-install() {
  }

  pull-docker-image "${PLUGIN_IMAGE}:${PLUGIN_IMAGE_VERSION}"
-  pull-docker-image "busybox:1.31.0-uclibc"
-  pull-docker-image "dokku/ambassador:0.3.0"
-  pull-docker-image "dokku/s3backup:0.10.0"
-  pull-docker-image "dokku/wait:0.4.0"
+  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"
@@ -42,6 +43,23 @@ plugin-install() {
 EOL

  chmod 0440 "$_SUDOERS_FILE"
+
+  local SERVICES=$(ls "$PLUGIN_DATA_ROOT" 2>/dev/null)
+  for SERVICE in $SERVICES; 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
+
+    if [[ -f "$SERVICE_ROOT/${PLUGIN_VARIABLE}_CONFIG_OPTIONS" ]]; then
+      mv "$SERVICE_ROOT/${PLUGIN_VARIABLE}_CONFIG_OPTIONS" "$SERVICE_ROOT/CONFIG_OPTIONS"
+    fi
+  done
 }

 plugin-install "$@"
--- a/plugin.toml
+++ b/plugin.toml
@@ -1,4 +1,4 @@
 [plugin]
 description = "dokku redis service plugin"
-version = "1.9.0"
+version = "1.18.0"
 [plugin.config]
--- a/19
+++ b/19
@@ -0,0 +1,19 @@
+#!/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"
+
+  local SERVICES=$(ls "$PLUGIN_DATA_ROOT" 2>/dev/null)
+  for SERVICE in $SERVICES; 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 "$@"
--- a/19
+++ b/19
@@ -0,0 +1,19 @@
+#!/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"
+
+  local SERVICES=$(ls "$PLUGIN_DATA_ROOT" 2>/dev/null)
+  for SERVICE in $SERVICES; 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 "$@"
--- a/36
+++ b/36
@@ -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"
+
+  if [[ "$SCHEDULER" != "docker-local" ]]; then
+    return
+  fi
+
+  local SERVICES=$(ls "$PLUGIN_DATA_ROOT" 2>/dev/null)
+  for SERVICE in $SERVICES; do
+    if ! in_links_file "$SERVICE" "$APP"; then
+      continue
+    fi
+
+    local 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 "$@"
--- a/32
+++ b/32
@@ -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 SERVICES=$(ls "$PLUGIN_DATA_ROOT" 2>/dev/null)
+  for SERVICE in $SERVICES; do
+    if ! in_links_file "$SERVICE" "$APP"; then
+      continue
+    fi
+
+    local 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 "$@"
--- a/subcommands/backup
+++ b/subcommands/backup
@@ -6,12 +6,14 @@ source "$PLUGIN_BASE_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"
+  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"
--- a/subcommands/backup-auth
+++ b/subcommands/backup-auth
@@ -7,20 +7,20 @@ 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"
+  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"
--- a/subcommands/backup-deauth
+++ b/subcommands/backup-deauth
@@ -7,9 +7,9 @@ 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"
+  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"
--- a/subcommands/backup-schedule
+++ b/subcommands/backup-schedule
@@ -8,14 +8,14 @@ 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"
+  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"
--- a/subcommands/backup-schedule-cat
+++ b/subcommands/backup-schedule-cat
@@ -7,7 +7,7 @@ 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=("$@")
--- a/subcommands/backup-set-encryption
+++ b/subcommands/backup-set-encryption
@@ -6,11 +6,11 @@ source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

 service-backup-set-encryption-cmd() {
-  #E set a GPG passphrase for backups
-  #E 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 passphrase, a GPG-compatible passphrase
-  declare desc="sets encryption for all future backups of $PLUGIN_SERVICE service"
+  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"
--- a/subcommands/backup-unschedule
+++ b/subcommands/backup-unschedule
@@ -7,9 +7,9 @@ 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"
+  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"
--- a/subcommands/backup-unset-encryption
+++ b/subcommands/backup-unset-encryption
@@ -6,10 +6,10 @@ source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

 service-backup-unset-encryption-cmd() {
-  #E unset a GPG encryption key for backups
-  #E 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"
+  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"
--- a/subcommands/clone
+++ b/subcommands/clone
@@ -7,14 +7,17 @@ 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 (default: unlimited)
  #F -p|--password PASSWORD, override the user-level service password
  #F -r|--root-password PASSWORD, override the root-level service password
+  #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
--- a/subcommands/connect
+++ b/subcommands/connect
@@ -7,7 +7,8 @@ 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=("$@")
--- a/subcommands/create
+++ b/subcommands/create
@@ -6,23 +6,26 @@ source "$PLUGIN_BASE_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 (default: unlimited)
  #F -p|--password PASSWORD, override the user-level service password
  #F -r|--root-password PASSWORD, override the root-level service password
+  #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
--- a/subcommands/destroy
+++ b/subcommands/destroy
@@ -7,7 +7,7 @@ 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"
@@ -41,13 +41,15 @@ service-destroy-cmd() {
  fi

  dokku_log_info2_quiet "Deleting $SERVICE"
+  plugn trigger service-action pre-delete "$SERVICE"
  service_backup_unschedule "$SERVICE"
  service_container_rm "$SERVICE"

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

+  plugn trigger service-action post-delete "$SERVICE"
  dokku_log_info2 "$PLUGIN_SERVICE container deleted: $SERVICE"
 }

--- a/subcommands/enter
+++ b/subcommands/enter
@@ -8,10 +8,11 @@ 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=("$@")
--- a/subcommands/exists
+++ b/subcommands/exists
@@ -6,8 +6,8 @@ source "$PLUGIN_BASE_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=("$@")
--- a/subcommands/export
+++ b/subcommands/export
@@ -7,9 +7,9 @@ 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=("$@")
--- a/subcommands/expose
+++ b/subcommands/expose
@@ -7,10 +7,12 @@ 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)"
+  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}")
--- a/subcommands/import
+++ b/subcommands/import
@@ -7,7 +7,7 @@ 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=("$@")
--- a/subcommands/info
+++ b/subcommands/info
@@ -7,18 +7,18 @@ 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 --links
+  #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
@@ -30,7 +30,7 @@ service-info-cmd() {
  #F --service-root, show the service root directory
  #F --status, show the service running status
  #F --version, show the service image version
-  declare desc="print the connection information"
+  declare desc="print the service information"
  local cmd="$PLUGIN_COMMAND_PREFIX:info" argv=("$@")
  [[ ${argv[0]} == "$cmd" ]] && shift 1
  declare SERVICE="$1" INFO_FLAG="$2"
--- a/subcommands/link
+++ b/subcommands/link
@@ -10,34 +10,34 @@ 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
--- a/subcommands/linked
+++ b/subcommands/linked
@@ -6,8 +6,8 @@ source "$PLUGIN_BASE_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"
--- a/subcommands/links
+++ b/subcommands/links
@@ -6,8 +6,8 @@ source "$PLUGIN_BASE_PATH/common/functions"
 source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/functions"

 service-links-cmd() {
-  #E list all apps linked to the 'lolipop' $PLUGIN_COMMAND_PREFIX service.
-  #E dokku $PLUGIN_COMMAND_PREFIX:links lolipop
+  #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=("$@")
--- a/subcommands/logs
+++ b/subcommands/logs
@@ -7,19 +7,21 @@ 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"
+  declare SERVICE="$1" TAIL_FLAG="$2" TAIL_NUM_OPTIONAL="${3:-all}"

  [[ -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 "$@"
--- a/subcommands/promote
+++ b/subcommands/promote
@@ -9,7 +9,7 @@ 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
@@ -18,9 +18,9 @@ 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>"
--- a/subcommands/restart
+++ b/subcommands/restart
@@ -7,7 +7,7 @@ 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=("$@")
--- a/subcommands/start
+++ b/subcommands/start
@@ -7,7 +7,7 @@ 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=("$@")
--- a/subcommands/stop
+++ b/subcommands/stop
@@ -7,7 +7,7 @@ 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 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=("$@")
--- a/subcommands/unexpose
+++ b/subcommands/unexpose
@@ -7,7 +7,7 @@ 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=("$@")
--- a/subcommands/unlink
+++ b/subcommands/unlink
@@ -8,7 +8,7 @@ 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
  declare desc="unlink the $PLUGIN_SERVICE service from the app"
--- a/subcommands/upgrade
+++ b/subcommands/upgrade
@@ -8,12 +8,14 @@ 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 -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
@@ -36,6 +38,8 @@ service-upgrade-cmd() {
    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"
--- a/tests/hook_pre_delete.bats
+++ b/tests/hook_pre_delete.bats
@@ -2,18 +2,18 @@
 load test_helper

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

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

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

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

@test "($PLUGIN_COMMAND_PREFIX:import) error when data is not provided" {
+  if [[ -n "$GITHUB_WORKFLOW" ]]; then
+    skip "No tty is available on Github Actions"
+  fi
  run dokku "$PLUGIN_COMMAND_PREFIX:import" l
  assert_contains "${lines[*]}" "No data provided on stdin"
  assert_failure
--- a/tests/service_info.bats
+++ b/tests/service_info.bats
@@ -22,21 +22,21 @@ teardown() {
@test "($PLUGIN_COMMAND_PREFIX:info) success" {
  run dokku "$PLUGIN_COMMAND_PREFIX:info" l
  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  assert_contains "${lines[*]}" "redis://l:$password@dokku-redis-l:6379"
+  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="$(sudo cat "$PLUGIN_DATA_ROOT/test_with_underscores/PASSWORD")"
-  assert_contains "${lines[*]}" "redis://test_with_underscores:$password@dokku-redis-test-with-underscores:6379"
+  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="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  assert_output "redis://l:$password@dokku-redis-l:6379"
+  assert_output "redis://:$password@dokku-redis-l:6379"

  run dokku "$PLUGIN_COMMAND_PREFIX:info" l --config-dir
  assert_success
--- a/tests/service_link.bats
+++ b/tests/service_link.bats
@@ -4,13 +4,13 @@ load test_helper
 setup() {
  dokku "$PLUGIN_COMMAND_PREFIX:create" l
  dokku "$PLUGIN_COMMAND_PREFIX:create" m
-  dokku apps:create my_app
+  dokku apps:create my-app
 }

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


@@ -39,7 +39,7 @@ teardown() {
 }

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

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

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

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

@test "($PLUGIN_COMMAND_PREFIX:link) generates an alternate config url when 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
+  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_AQUA_URL"
  assert_success

-  dokku "$PLUGIN_COMMAND_PREFIX:link" m my_app
-  run dokku config my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:link" m my-app
+  run dokku config my-app
  assert_contains "${lines[*]}" "DOKKU_REDIS_BLACK_URL"
  assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" m my_app
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" m my-app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
 }

@test "($PLUGIN_COMMAND_PREFIX:link) links to app with docker-options" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app
-  run dokku docker-options my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app
+  run dokku docker-options:report my-app
  assert_contains "${lines[*]}" "--link dokku.redis.l:dokku-redis-l"
  assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
 }

@test "($PLUGIN_COMMAND_PREFIX:link) uses apps 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)
+  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="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  assert_contains "$url" "redis2://l:$password@dokku-redis-l:6379"
+  assert_contains "$url" "redis2://:$password@dokku-redis-l:6379"
  assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
 }

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

@test "($PLUGIN_COMMAND_PREFIX:link) uses a specified config url when alias is specified" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app --alias "ALIAS"
-  url=$(dokku config:get my_app ALIAS_URL)
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app --alias "ALIAS"
+  url=$(dokku config:get my-app ALIAS_URL)
  password="$(sudo cat "$PLUGIN_DATA_ROOT/l/PASSWORD")"
-  assert_contains "$url" "redis://l:$password@dokku-redis-l:6379"
+  assert_contains "$url" "redis://:$password@dokku-redis-l:6379"
  assert_success
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
 }
--- a/tests/service_list.bats
+++ b/tests/service_list.bats
@@ -10,27 +10,13 @@ teardown() {
 }

@test "($PLUGIN_COMMAND_PREFIX:list) with no exposed ports, no linked apps" {
-  run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "l     redis:5.0.5  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:5.0.5  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:5.0.5  running  -              my_app"
-  dokku --force apps:destroy my_app
+  run dokku --quiet "$PLUGIN_COMMAND_PREFIX:list"
+  assert_output "l"
 }

@test "($PLUGIN_COMMAND_PREFIX:list) when there are no services" {
  dokku --force "$PLUGIN_COMMAND_PREFIX:destroy" l
  run dokku "$PLUGIN_COMMAND_PREFIX:list"
-  assert_contains "${lines[*]}" "There are no Redis services"
+  assert_output "${lines[*]}" "There are no $PLUGIN_SERVICE services"
  dokku "$PLUGIN_COMMAND_PREFIX:create" l
 }
--- a/tests/service_promote.bats
+++ b/tests/service_promote.bats
@@ -3,14 +3,14 @@ load test_helper

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

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

@test "($PLUGIN_COMMAND_PREFIX:promote) error when there are no arguments" {
@@ -29,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="$(sudo 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"
+  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="$(sudo 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
+  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="$(sudo 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"
+  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"
 }
--- a/tests/service_unlink.bats
+++ b/tests/service_unlink.bats
@@ -2,13 +2,13 @@
 load test_helper

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

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

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

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

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

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

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

@test "($PLUGIN_COMMAND_PREFIX:unlink) unsets config url from app" {
-  dokku "$PLUGIN_COMMAND_PREFIX:link" l my_app >&2
-  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my_app
-  config=$(dokku config:get my_app REDIS_URL || true)
+  dokku "$PLUGIN_COMMAND_PREFIX:link" l my-app >&2
+  dokku "$PLUGIN_COMMAND_PREFIX:unlink" l my-app
+  config=$(dokku config:get my-app REDIS_URL || true)
  assert_equal "$config" ""
 }
--- a/tests/setup.sh
+++ b/tests/setup.sh
@@ -1,6 +1,14 @@
 #!/usr/bin/env 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 -
+
+sudo mkdir -p /etc/nginx
+sudo curl https://raw.githubusercontent.com/dokku/dokku/master/tests/dhparam.pem -o /etc/nginx/dhparam.pem
+
+echo "dokku dokku/skip_key_file boolean true" | sudo debconf-set-selections
 wget https://raw.githubusercontent.com/dokku/dokku/master/bootstrap.sh
 if [[ "$DOKKU_VERSION" == "master" ]]; then
  sudo bash bootstrap.sh
@@ -11,11 +19,15 @@ echo "Dokku version $DOKKU_VERSION"

 export DOKKU_LIB_ROOT="/var/lib/dokku"
 export DOKKU_PLUGINS_ROOT="$DOKKU_LIB_ROOT/plugins/available"
-source "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")/config"
+pushd "$(dirname "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)")" >/dev/null
+source "config"
+popd >/dev/null
 sudo rm -rf "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX"
-sudo mkdir -p "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands"
+sudo mkdir -p "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/scripts" "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/templates"
 sudo find ./ -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX" \;
-sudo find ./subcommands -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" \;
+[[ -d "./scripts" ]] && sudo find ./scripts -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/scripts" \;
+[[ -d "./subcommands" ]] && sudo find ./subcommands -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/subcommands" \;
+[[ -d "./templates" ]] && sudo find ./templates -maxdepth 1 -type f -exec cp '{}' "$DOKKU_PLUGINS_ROOT/$PLUGIN_COMMAND_PREFIX/templates" \;
 sudo mkdir -p "$PLUGIN_CONFIG_ROOT" "$PLUGIN_DATA_ROOT"
 sudo dokku plugin:enable "$PLUGIN_COMMAND_PREFIX"
 sudo dokku plugin:install
--- a/tests/shellcheck-exclude
+++ b/tests/shellcheck-exclude
@@ -1,3 +1,7 @@
 # SC1090 - Can't follow non-constant source. Use a directive to specify location - https://github.com/koalaman/shellcheck/wiki/SC1090
 # SC2034 - Variable appears unused. Verify it or export it - https://github.com/koalaman/shellcheck/wiki/SC2034
 # SC2155 - Declare and assign separately to avoid masking return values - https://github.com/koalaman/shellcheck/wiki/SC2155
+# SC2206 - Quote to prevent word splitting/globbing, or split robustly with mapfile or read -a - https://github.com/koalaman/shellcheck/wiki/SC2206
+# SC2207 - Prefer mapfile or read -a to split command output (or quote to avoid splitting) - https://github.com/koalaman/shellcheck/wiki/SC2207
+# SC2220 - Invalid flags are not handled. Add a *) case - https://github.com/koalaman/shellcheck/wiki/SC2220
+# SC2230 - which is non-standard. Use builtin 'command -v' instead - https://github.com/koalaman/shellcheck/wiki/SC2230
--- a/tests/shellcheck-to-junit
+++ b/tests/shellcheck-to-junit
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 from __future__ import print_function
 import argparse
Author	SHA1	Message	Date
Jose Diaz-Gonzalez	134442bd73	Release 1.18.0	2021-10-26 22:28:10 -04:00
Jose Diaz-Gonzalez	88e6d790e1	feat: allow tailing a specific number of log lines	2021-10-26 22:27:15 -04:00
Jose Diaz-Gonzalez	29f1f3dd3d	Release 1.17.1	2021-10-24 05:17:55 -04:00
Jose Diaz-Gonzalez	93dbdc4da5	fix: silence config-options error when there are no config-options set	2021-10-24 05:08:30 -04:00
Jose Diaz-Gonzalez	bd5ae9442d	Release 1.17.0	2021-10-23 19:34:11 -04:00
Jose Diaz-Gonzalez	cd18e9f4a3	feat: allow quiet header for :info command	2021-10-23 19:33:19 -04:00
Jose Diaz-Gonzalez	c2aff1a5a3	Release 1.16.2	2021-10-07 11:23:30 -04:00
Jose Diaz-Gonzalez	48277db27f	Merge pull request #169 from dokku/dependabot/docker/redis-6.2.6 chore(deps): bump redis from 6.2.5 to 6.2.6	2021-10-07 11:23:02 -04:00
dependabot[bot]	f9bac907df	chore(deps): bump redis from 6.2.5 to 6.2.6 Bumps redis from 6.2.5 to 6.2.6. --- updated-dependencies: - dependency-name: redis dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2021-10-06 15:11:34 +00:00
Jose Diaz-Gonzalez	258eb2fea8	fix: start linked datastores when an app is started or restored This won't _also_ fix issues when an app is deployed as there isn't an exposed hook for it, but it should fix many other issues. For the app deployment problem, we'll need a new hook upstream. Refs dokku/dokku-redis#138	2021-09-13 04:54:59 -04:00
Jose Diaz-Gonzalez	943f93227b	Release 1.16.1	2021-09-13 04:34:12 -04:00
Jose Diaz-Gonzalez	2e76628c88	fix: ensure cloned/renamed apps have a link to linked services Previously they would just 'disappear', resulting in broken applications until the app was relinked to the service in question. Closes dokku/dokku-redis#142	2021-09-13 04:27:29 -04:00
Jose Diaz-Gonzalez	b2cbea7508	Release 1.16.0	2021-09-13 03:34:12 -04:00
Jose Diaz-Gonzalez	f132d89425	docs: use a 'standard' name for the data dump	2021-09-13 03:25:06 -04:00
Jose Diaz-Gonzalez	ba85668e26	docs: document the possibility of zombie processes on ssh disconnect for :connect and :enter commands Apparently terminating the ssh connection that runs 'docker exec' may result in a process leak as the signal isn't propagated properly (moby/moby#9098). Since we cannot fix this, we should document it so that users do not stumble upon the issue unawares. Closes dokku/dokku-postgres#212	2021-09-13 03:21:24 -04:00
Jose Diaz-Gonzalez	7e73273ad3	fix: pin the image and image version of a created service at creation time This will help ensure that users upgrading to a new plugin version who stop/start databases will always get the same version. This is particularly important for datastores such as elasticsearch and postgres that have more involved upgraded processes.	2021-09-13 02:28:42 -04:00
Jose Diaz-Gonzalez	8d23856729	docs: add folder for supplementary documentation	2021-09-13 01:23:26 -04:00
Jose Diaz-Gonzalez	ced8d9a050	docs: add ability to inject supplementary documentation into the readme Some commands - such as link or upgrade - have extra documenation on a per-plugin basis. Rather than make some sort of weird templating logic in the help output generation, that documentation is added directly to the repository and then injected at generation time.	2021-09-13 01:21:20 -04:00
Jose Diaz-Gonzalez	6885913479	docs: properly spell lollipop I've been misspelling my stand-in variable name for years...	2021-09-13 00:57:34 -04:00
Jose Diaz-Gonzalez	d9a8bc3357	feat: allow setting shm-size on created containers Refs dokku/dokku-postgres#188 Closes dokku/dokku-postgres#201	2021-09-13 00:46:49 -04:00
Jose Diaz-Gonzalez	943f90f4b8	fix: properly handle unlink on promoted service	2021-09-13 00:04:28 -04:00
Jose Diaz-Gonzalez	386a97d68d	docs: correctly represent the url and env vars that get injected via docker link Closes dokku/dokku-postgres#221	2021-09-12 23:38:52 -04:00
Jose Diaz-Gonzalez	cb5aa08986	docs: fix the variable reference for plugins where the alias does not match the variable Closes dokku/dokku-postgres#199	2021-09-12 22:55:02 -04:00
Jose Diaz-Gonzalez	9cb2f75469	docs: make tense in command descriptions more consistent	2021-09-12 22:37:15 -04:00
Jose Diaz-Gonzalez	b186895205	chore: drop extra print in readme generator	2021-09-12 22:33:06 -04:00
Jose Diaz-Gonzalez	653e1e0ec5	dev: add file (for linting) and nano (for in-container editing) to devcontainer	2021-09-12 22:20:42 -04:00
Jose Diaz-Gonzalez	2b7b1cc1da	fix: use updated python shebang	2021-09-12 22:18:01 -04:00
Jose Diaz-Gonzalez	720ddea579	feat: add ability to set container config options during create/clone/upgrade actions Also add to documentation where possible. Closes dokku/dokku-mongo#131	2021-09-12 22:16:14 -04:00
Jose Diaz-Gonzalez	658e04df6f	fix: allow non-english characters in :connect shell Closes dokku/dokku-mysql#116	2021-09-12 08:24:53 -04:00
Jose Diaz-Gonzalez	9b6d6430fb	feat: add the ability to constrain memory on service start/clone Refs dokku/dokku-redis#86	2021-09-12 07:43:03 -04:00
Jose Diaz-Gonzalez	5ce48afd51	docs: add a note as to how to specify an interface/ip to bind on when exposing a service Closes dokku/dokku-mongo#128	2021-09-12 07:09:56 -04:00
Jose Diaz-Gonzalez	17a640e764	docs: translate single-quotes into backticks	2021-09-12 07:01:59 -04:00
Jose Diaz-Gonzalez	3aed82c9d7	docs: document how to restore a backup	2021-09-12 06:59:50 -04:00
Jose Diaz-Gonzalez	65e92bdd75	Release 1.15.1	2021-09-12 04:54:50 -04:00
Jose Diaz-Gonzalez	ec9b0049cf	dev: add convenience copy-file bin and fix data path used by plugin	2021-09-12 03:28:57 -04:00
Jose Diaz-Gonzalez	3418f4d76e	dev: make devcontainer setup plugin agnostic	2021-09-12 02:39:18 -04:00
Jose Diaz-Gonzalez	2e0e2db647	chore: show a better error message when the image is missing Refs dokku/dokku-clickhouse#4	2021-09-12 00:54:24 -04:00
Jose Diaz-Gonzalez	5b0dd26c73	dev: mount the service directory from the host to ensure tests can pass inside of a docker container	2021-09-12 00:53:13 -04:00
Jose Diaz-Gonzalez	c259f0fb97	fix: copy any existing templates and drop unnecessary interactivity	2021-09-12 00:40:42 -04:00
Jose Diaz-Gonzalez	8f8c9f2a2c	fix: use correct path	2021-09-11 23:45:01 -04:00
Jose Diaz-Gonzalez	4c71d0b4c5	fix: copy templates if they exist	2021-09-11 23:18:29 -04:00
Jose Diaz-Gonzalez	be18a78f36	feat: add devcontainer support This should make it possible to run tests locally in a lighter way than pulling up a full VM.	2021-09-11 21:06:06 -04:00
Jose Diaz-Gonzalez	99daa0f86f	docs: regenerate readme	2021-09-11 18:16:29 -04:00
Jose Diaz-Gonzalez	0d501c6f8d	Merge pull request #166 from dokku/dependabot/docker/redis-6.2.5 chore(deps): bump redis from 6.2.4 to 6.2.5	2021-09-11 18:11:40 -04:00
Jose Diaz-Gonzalez	a30b33ecc6	chore: drop references to circleci, libera, travis-ci	2021-09-11 17:57:22 -04:00
dependabot[bot]	71316e85d3	chore(deps): bump redis from 6.2.4 to 6.2.5 Bumps redis from 6.2.4 to 6.2.5. --- updated-dependencies: - dependency-name: redis dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2021-07-23 15:07:50 +00:00
Jose Diaz-Gonzalez	2082f89ac1	Release 1.15.0	2021-07-12 01:04:11 -04:00
Jose Diaz-Gonzalez	902112cc75	Merge pull request #164 from dokku/dependabot/docker/redis-6.2.4 chore(deps): bump redis from 5.0.7 to 6.2.4	2021-07-12 01:02:43 -04:00
dependabot[bot]	18c4fbc79e	chore(deps): bump redis from 5.0.7 to 6.2.4 Bumps redis from 5.0.7 to 6.2.4. --- updated-dependencies: - dependency-name: redis dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com>	2021-06-02 06:24:43 +00:00
Jose Diaz-Gonzalez	3a8b4511c4	tests: refactor tests to ignore readme generation for Dockerfile changes Ideally we can trigger a readme update on merge in the future. For now, this will work well.	2021-04-26 11:43:13 -04:00
Jose Diaz-Gonzalez	2dfcc76d26	chore: gitignore bootstrap file and minor cleanup of ci	2021-04-25 02:54:07 -04:00
Jose Diaz-Gonzalez	071afd4a31	Merge pull request #161 from dokku/github-actions-attempt tests: migrate to github actions	2021-04-25 01:07:10 -04:00
Jose Diaz-Gonzalez	04541a0fc6	tests: skip tests that require tty for github actions	2021-04-25 00:35:43 -04:00
Jose Diaz-Gonzalez	fea5aa6724	docs: regenerate readme	2021-04-24 14:09:33 -04:00
Jose Diaz-Gonzalez	f48f67f67b	tests: drop copying of test results Bats will now output the results on stdout so no need to copy results anywhere.	2021-04-24 14:05:47 -04:00
Jose Diaz-Gonzalez	8fda23f91c	tests: fix job name	2021-04-24 14:04:39 -04:00
Jose Diaz-Gonzalez	14ec6fd833	tests: split tests to version and tag	2021-04-24 14:03:02 -04:00
Jose Diaz-Gonzalez	dafc9c7a2d	chore: update min dokku version and only test push on master branch	2021-04-24 13:57:19 -04:00
Jose Diaz-Gonzalez	21df3ee116	tests: migrate to github actions	2021-04-24 02:20:30 -04:00
Jose Diaz-Gonzalez	98cabcce0b	Release 1.14.0	2021-04-24 00:32:25 -04:00
Jose Diaz-Gonzalez	f09a65e55f	feat: add dependabot config to all repositories	2021-04-24 00:10:34 -04:00
Jose Diaz-Gonzalez	71c828eabd	Merge pull request #159 from dokku/dockerfile-update Pull image from Dockerfile	2021-04-23 23:55:48 -04:00
Jose Diaz-Gonzalez	9eca41dcd5	tests: refactor source again	2021-02-26 00:45:09 -05:00
Jose Diaz-Gonzalez	6f392df029	tests: fix path to Dockerfile when sourcing config for tests	2021-02-26 00:27:52 -05:00
Jose Diaz-Gonzalez	aa8c6489ee	docs: handle image and version correctly	2021-02-26 00:11:16 -05:00
Jose Diaz-Gonzalez	f1629b8b51	refactor: move base image reference to Dockerfile This will allow us to take advantage of automatic update software to auto-pull new versions when they are released to docker hub.	2021-02-25 23:16:23 -05:00
Jose Diaz-Gonzalez	18ce6d43b5	tests: use dash instead of underscore	2021-02-25 20:32:57 -05:00
Jose Diaz-Gonzalez	bb2ba3807a	feat: add plugin trigger for service creation and deletion	2021-02-25 19:54:59 -05:00
Jose Diaz-Gonzalez	d2eecef68a	refactor: use pre/post triggers for service-action naming This is a bit more clear as the links aren't always idempotent and may have errors - this allows users to reconcile at what point a link may have failed so that they can take further action.	2021-02-25 16:05:25 -05:00
Jose Diaz-Gonzalez	9e0d948de7	feat: add service-action plugin trigger for link/unlink This can be used to track in alternate systems when a service is linked/unlinked from an app by implementing the custom trigger.	2021-02-25 15:58:31 -05:00
Jose Diaz-Gonzalez	90ab3a1191	Release 1.13.0	2021-02-02 21:50:08 -05:00
Jose Diaz-Gonzalez	23681960bf	Merge pull request #157 from gyfis/patch-1 Don't fill $SERVICE as username in REDIS_URL	2021-02-02 21:49:47 -05:00
Jose Diaz-Gonzalez	b8b97f0cb4	Release 1.12.6	2021-01-17 21:16:36 -05:00
Jose Diaz-Gonzalez	70c98338b0	fix: do not shadow TMPDIR variable This enables usage of the plugin with libpam-tmpdir. Refs dokku/dokku#3149	2021-01-17 21:02:28 -05:00
Tomas Hromada	872ed9c540	Merge branch 'patch-1' of https://github.com/gyfis/dokku-redis into patch-1	2020-11-22 09:00:53 +01:00
Tomas Hromada	c85770a873	✅ 💄 README.md from bin/generate	2020-11-22 09:00:44 +01:00
Tomáš Hromada	facd80f5bc	✅ 💄 Remove last empty line from README	2020-11-22 08:13:04 +01:00
Tomas Hromada	bc5985881a	✅ purge mentions of the faux-username from the codebase	2020-11-21 21:17:55 +01:00
Tomáš Hromada	4170c0b993	Don't fill $SERVICE as username in service_url() The URL generated by this plugin is invalid, but since Redis on versions 5 and lower didn't have a notion of usernames, it pretty much went unnoticed. Let's fix this by not setting the $SERVICE as the username in the service_url returned by this plugin. I believe that clients ignore the username (otherwise the Redis connection wouldn't go through), so this should be a non-breaking change. Fixes #155	2020-11-21 20:53:49 +01:00
Jose Diaz-Gonzalez	ca69e6f79d	fix: correct image link	2020-09-27 12:38:54 -04:00
Jose Diaz-Gonzalez	ca6b3b8815	Merge pull request #151 from dokku/configurable-config fix: allow config directory to be configurable	2020-05-16 12:57:10 -04:00
Jose Diaz-Gonzalez	e43904641b	fix: allow config directory to be configurable For postgres, the config directory doesn't actually exist, so adding this configurability allows the plugin's info command to report correctly.	2020-05-16 02:49:34 -04:00
Jose Diaz-Gonzalez	6d19569e82	Release 1.12.5	2020-05-15 00:59:58 -04:00
Jose Diaz-Gonzalez	01a1668867	fix: respect the TMPDIR environment variable Refs dokku/dokku-redis#143	2020-05-15 00:57:21 -04:00
Jose Diaz-Gonzalez	f2c531bb5e	Release 1.12.4	2020-05-15 00:54:38 -04:00
Jose Diaz-Gonzalez	2fd7152866	docs: correct help output Refs dokku/dokku-postgres#197	2020-05-15 00:40:25 -04:00
Jose Diaz-Gonzalez	f9d5735c6c	docs: correct casing/quoting on sentences	2020-05-15 00:34:38 -04:00
Jose Diaz-Gonzalez	6497135ae8	chore: run black	2020-05-14 23:57:49 -04:00
Jose Diaz-Gonzalez	adc1b724d3	docs: document all flags in readme	2020-05-14 23:37:57 -04:00
Jose Diaz-Gonzalez	b421d681af	docs: make the gpg passphrase a bit more clear	2020-05-14 23:33:01 -04:00
Jose Diaz-Gonzalez	1e43387487	Release 1.12.3	2020-05-14 23:00:57 -04:00
Jose Diaz-Gonzalez	7a003dea68	chore: update copyright date	2020-05-14 22:57:39 -04:00
Jose Diaz-Gonzalez	0aefafed16	docs: switch build shield to circleci	2020-04-05 20:41:00 -04:00
Jose Diaz-Gonzalez	2f72b26396	tests: use circleci 2.1	2020-04-05 20:40:20 -04:00
Jose Diaz-Gonzalez	75efb47a97	Release 1.12.2	2020-04-04 22:28:01 -04:00
Jose Diaz-Gonzalez	3d4258c794	fix: store the correct path	2020-04-04 22:25:11 -04:00
Jose Diaz-Gonzalez	4c194bf734	Release 1.12.1	2020-04-04 21:50:44 -04:00
Jose Diaz-Gonzalez	53968775f6	tests: drop travisci usage	2020-04-04 21:44:00 -04:00
Jose Diaz-Gonzalez	9589ad3924	tests: store test results for usage in circleci	2020-04-04 21:41:43 -04:00
Jose Diaz-Gonzalez	5093de6bd9	feat: enable circleci	2020-04-04 21:27:54 -04:00
Jose Diaz-Gonzalez	565dba9801	feat: speed up tests by dropping dhparam generation	2020-04-04 21:27:43 -04:00
Jose Diaz-Gonzalez	81cca3b12b	fix: use python3 for generating the readme	2020-04-04 16:47:36 -04:00
Jose Diaz-Gonzalez	2d07341518	docs: drop unimpemented commands from readme and reorganize	2020-04-04 16:43:31 -04:00
Jose Diaz-Gonzalez	18f925d9f4	feat: autogenerate readme from command help	2020-04-04 16:20:35 -04:00
Jose Diaz-Gonzalez	a4e1f43905	fix: correct issue where help output for info flag implied multiple flags	2020-04-04 16:18:22 -04:00
Jose Diaz-Gonzalez	a6f3ea4552	feat: update shellcheck excludes	2020-04-04 13:38:33 -04:00
Jose Diaz-Gonzalez	138bcd3fe1	feat: add xunit-reader to output xunit files in human readable format	2020-04-04 13:37:51 -04:00
Jose Diaz-Gonzalez	da6676efb8	feat: parameterize xunit-to-github version	2020-04-04 13:37:04 -04:00
Jose Diaz-Gonzalez	3a7564c401	fix: use non-deprecated method of fetching docker-options	2020-04-04 13:36:27 -04:00
Jose Diaz-Gonzalez	2d820a7c1c	feat: upgrade shfmt	2020-04-04 13:35:52 -04:00
Jose Diaz-Gonzalez	ba4024d202	Release 1.12.0	2020-03-31 01:38:34 -04:00
Jose Diaz-Gonzalez	34cbc30f63	feat: upgrade tertiary container images	2020-03-30 20:12:18 -04:00
Jose Diaz-Gonzalez	9ace27266c	feat: move all image names to config file This allows us to more quickly update the image versions in use for tertiary images.	2020-03-30 20:09:04 -04:00
Jose Diaz-Gonzalez	d2185f2144	feat: add service-specific header to info call	2020-03-20 15:59:03 -04:00
Jose Diaz-Gonzalez	6feb270037	fix: correct test case for :list command	2020-03-20 14:58:06 -04:00
Jose Diaz-Gonzalez	62484924e6	fix: ignore the keyfile install for tests	2020-03-20 11:14:27 -04:00
Jose Diaz-Gonzalez	b9740bffcd	fix: correct shellcheck issue	2020-03-20 11:05:44 -04:00
Jose Diaz-Gonzalez	3c4267fbb9	feat: update travis setup - Use ubuntu bionic - Upgrade tested version of dokku	2020-03-20 10:58:25 -04:00
Jose Diaz-Gonzalez	fb1b189aea	Release 1.11.1	2020-03-06 10:20:27 -05:00
Jose Diaz-Gonzalez	e216b97c23	fix: correct service title	2020-03-06 10:19:43 -05:00
Jose Diaz-Gonzalez	0c210e64f3	Release 1.11.0	2020-03-03 16:05:40 -05:00
Jose Diaz-Gonzalez	bc9874bc49	refactor: drop full info from :list command This can be fetched from :info if necessary, and slows down the list quite a bit.	2020-03-03 16:02:51 -05:00
Jose Diaz-Gonzalez	b7cfbd37b4	fix: speed up service_status by reducing container status calls	2020-03-03 15:57:21 -05:00
Jose Diaz-Gonzalez	0ecf4f7cfd	Release 1.10.4	2019-12-27 16:57:56 -05:00
Jose Diaz-Gonzalez	3bfcb5bc2c	chore: update dokku/wait version	2019-12-27 16:57:13 -05:00
Jose Diaz-Gonzalez	0fe6933897	Release 1.10.3	2019-12-27 16:56:17 -05:00
Jose Diaz-Gonzalez	0cec2f2119	chore: update dokku/ambassador version	2019-12-27 16:55:26 -05:00
Jose Diaz-Gonzalez	3dcf263b56	Release 1.10.2	2019-12-27 16:54:21 -05:00
Jose Diaz-Gonzalez	233b03e7ca	chore: update dokku/s3backup version	2019-12-27 16:53:23 -05:00
Jose Diaz-Gonzalez	9bc7830c0c	Release 1.10.1	2019-11-22 19:17:09 -05:00
Jose Diaz-Gonzalez	150591eb75	feat: update patch release of redis	2019-11-22 19:16:55 -05:00
Jose Diaz-Gonzalez	417311e9fb	Release 1.10.0	2019-09-19 15:29:17 -04:00
Jose Diaz-Gonzalez	6fe12abbb5	Merge pull request #139 from plotly/11839-modify-SAVE-call Modify export command to use BGSAVE.	2019-09-19 15:28:54 -04:00
Jose Diaz-Gonzalez	bb27a06da9	Release 1.9.1	2019-09-19 15:17:48 -04:00
V. Anastassiou	068145b46e	Modify export command to use BGSAVE.	2019-09-19 13:40:28 -04:00
Jose Diaz-Gonzalez	c5442f9754	Delete empty	2019-09-19 13:28:28 -04:00
Jose Diaz-Gonzalez	07c36b7e6f	Merge pull request #141 from dokku/test-ci fix: import the missing key and install nginx from upstream	2019-09-19 13:28:05 -04:00
Jose Diaz-Gonzalez	b2b39c86f1	fix: import the missing key and install nginx from upstream	2019-09-19 12:59:58 -04:00
Jose Diaz-Gonzalez	0a0e6c3140	fix: add missing ampersands	2019-07-30 10:51:51 -04:00
Jose Diaz-Gonzalez	007acf952a	chore: create scripts directory as necessary	2019-07-30 10:46:00 -04:00
Jose Diaz-Gonzalez	28275d777d	feat: skip subcommand copy if no subcommands directory exists	2019-07-29 22:03:01 -04:00